/** @jsxImportSource https://esm.sh/react@18.2.0 */ import { createRoot } from "https://esm.sh/react-dom@18.2.0/client"; import React, { createRef, useEffect, useRef, useState } from "https://esm.sh/react@18.2.0"; const quoteCount = 1840; function getUniqueLetters(word: string): string { return [...new Set(word.toUpperCase().replace(/[^A-Z]/g, ""))].join(""); } function incrementAgain(input: string): string { // Use a regular expression to detect if the string ends with `-again` const match = input.match(/^(.*-again)(\d+)$/); if (match) { // match[1] will be the part up to `-again` // match[2] will be the numeric part const prefix = match[1]; // e.g., "myString-again" const currentNumber = parseInt(match[2], 10); const nextNumber = currentNumber + 1; return `${prefix}${nextNumber}`; } // If no match, just append `-again1` return `${input}-again1`; } function appendToLocalStorage(text: string, author: string | null): void { const key = "known_texts"; // Get the existing data from local storage const storedData = localStorage.getItem(key); // If it exists, parse it; otherwise, use an empty array let arr: string[] = storedData ? JSON.parse(storedData) : []; const newValue = `${text} - ${author ?? ""}`; // Push the new value onto the array if it is not already in it if (!arr.includes(newValue)) { arr.push(newValue); } // Save the updated array back to local storage localStorage.setItem(key, JSON.stringify(arr)); } function isTextKnown(text: string, author: string | null): boolean { const key = "known_texts"; const storedData = localStorage.getItem(key); const arr = storedData ? JSON.parse(storedData) : []; const set = new Set(arr); return set.has(`${text} - ${author ?? ""}`); } function knownTexts(): string[] { const key = "known_texts"; const storedData = localStorage.getItem(key); return storedData ? JSON.parse(storedData) : []; } function generateHint(quote: string): { hint: string; source: "first" | "last" } { const words = quote.split(" "); let currentHint = ""; let hintWithSpaceRemoved = ""; let quoteWithLettersOnly = quote.replace(/[^A-Za-z]/g, ""); const source = Math.random() < 0.5 ? "first" : "last"; if (source === "first") { // Iterate through words, building the hint until we have exactly 4 unique letters for (let i = 0; i < quoteWithLettersOnly.length; i++) { currentHint += quoteWithLettersOnly[i]; hintWithSpaceRemoved = currentHint.replace(/\s/g, ""); if (hintWithSpaceRemoved.length === 4) { return { hint: currentHint.toUpperCase(), source: "first", }; } } // Fallback: if we can't find 4 unique letters, return the first word return { hint: words[0], source: "first", }; } else { // Iterate through words in reverse, building the hint until we have exactly 4 unique letters for (let i = quoteWithLettersOnly.length - 1; i >= 0; i--) { currentHint = quoteWithLettersOnly[i] + currentHint; hintWithSpaceRemoved = currentHint.replace(/\s/g, ""); if (hintWithSpaceRemoved.length === 4) { return { hint: currentHint.toUpperCase(), source: "last", }; } } // Fallback: if we can't find 4 unique letters, return the last word return { hint: words[words.length - 1], source: "last", }; } } function randomLetter(): string { const ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; return ALPHABET[Math.floor(Math.random() * ALPHABET.length)]; } function randomWordFromSentence(sentence: string): string { const words = sentence.split(" "); for (let i = 0; i < words.length * 2; i++) { const word = words[Math.floor(Math.random() * words.length)]; const alphabetsOnly = word.replace(/[^A-Za-z]/g, ""); if (alphabetsOnly.length >= 4) { return alphabetsOnly.toUpperCase(); } } return ""; } function randomSubstitutionMap(): { substitutionMap: Record; reverseSubstitutionMap: Record; } { const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".split(""); // Fisher-Yates shuffle to randomize mapping const shuffledAlphabet = [...alphabet].sort(() => Math.random() - 0.5); const substitutionMap: Record = {}; const reverseSubstitutionMap: Record = {}; for (let i = 0; i < alphabet.length; i++) { const originalLetter = alphabet[i]; const substitutedLetter = shuffledAlphabet[i]; // Ensure no letter maps to itself if (originalLetter === substitutedLetter) { // Swap with another letter const swapIndex = (i + 1) % alphabet.length; [shuffledAlphabet[i], shuffledAlphabet[swapIndex]] = [shuffledAlphabet[swapIndex], shuffledAlphabet[i]]; } substitutionMap[originalLetter] = shuffledAlphabet[i]; reverseSubstitutionMap[shuffledAlphabet[i]] = originalLetter; } return { substitutionMap, reverseSubstitutionMap }; } function substitutionAndReverseMaps( keyword: string, positionLetter: string, type: "k1" | "k2" | "random", ): { substitutionMap: Record; reverseSubstitutionMap: Record; } { if (type === "random") { return randomSubstitutionMap(); } const ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; // Normalize inputs const upperKeyword = keyword.toUpperCase().replace(/[^A-Z]/g, ""); const upperPosition = positionLetter.toUpperCase(); // 1. Remove duplicate letters from the keyword (in the order they appear) let uniqueKeyword: string[] = []; for (const char of upperKeyword) { if (!uniqueKeyword.includes(char)) { uniqueKeyword.push(char); } } // 2. Find the index of the position letter in the alphabet const positionIndex = ALPHABET.indexOf(upperPosition); if (positionIndex < 0) { throw new Error( `Position letter "${upperPosition}" is not a valid A–Z character.`, ); } // 3. Create an array of all letters except those in the keyword // (to help fill the rest of the alphabet) let remainingLetters = ALPHABET.split("").filter( (char) => !uniqueKeyword.includes(char), ); // 4. Sequence led by keyword const keywordLedSequence = uniqueKeyword.concat(remainingLetters); // 5. Rotation to make keyword start at the right index const keywordAtRightIndexSequence = keywordLedSequence.slice(keywordLedSequence.length - positionIndex) .concat(keywordLedSequence.slice(0, keywordLedSequence.length - positionIndex)); // 5. Build the final substitution dicts const substitutionMap: Record = {}; const reverseSubstitutionMap: Record = {}; if (type === "k2") { // for k2, keyword is in the ciphertext for (const index in keywordAtRightIndexSequence) { if (ALPHABET[index] === keywordAtRightIndexSequence[index]) { // Don't allow letter mapping to the same letter. try the next positionIndex return substitutionAndReverseMaps(keyword, ALPHABET[(positionIndex + 1) % ALPHABET.length], type); } substitutionMap[ALPHABET[index]] = keywordAtRightIndexSequence[index]; reverseSubstitutionMap[keywordAtRightIndexSequence[index]] = ALPHABET[index]; } } else { // for k1, keyword is in the plain text for (const index in keywordAtRightIndexSequence) { if (ALPHABET[index] === keywordAtRightIndexSequence[index]) { // Don't allow letter mapping to the same letter. try the next positionIndex return substitutionAndReverseMaps(keyword, ALPHABET[(positionIndex + 1) % ALPHABET.length], type); } substitutionMap[keywordAtRightIndexSequence[index]] = ALPHABET[index]; reverseSubstitutionMap[ALPHABET[index]] = keywordAtRightIndexSequence[index]; } } return { substitutionMap, reverseSubstitutionMap }; } function substitutionEncode( args: { plainText: string; keyword: string; positionLetter: string; type: "k1" | "k2" | "random"; groupingType: "aristocrat" | "patristocrat"; }, ): { encoded: string; original: string; cleanOriginal: string; encodedLetterCounts: Record; substitutionMap: Record; reverseSubstitutionMap: Record; keyword: string; positionLetter: string; type: "k1" | "k2" | "random"; groupingType: "aristocrat" | "patristocrat"; hint: string; hintSource: string; } { const { plainText, keyword, positionLetter, type, groupingType } = args; // 1. Normalize plaintext: uppercase, remove non-letters const normalizedText = plainText.toUpperCase().replace(/[^A-Z]/g, ""); // 2. get substitution and reverse substitution maps const { substitutionMap, reverseSubstitutionMap } = substitutionAndReverseMaps(keyword, positionLetter, type); // alert( // `substitutionMap: ${JSON.stringify(substitutionMap)}, reverseSubstitutionMap: ${ // JSON.stringify(reverseSubstitutionMap) // }`, // ); // 4.1 get cipher text let cipherText = ""; for (const char of normalizedText) { cipherText += substitutionMap[char]; } // 4.2 Group encoded letters into 5-letter groups let encodedGrouped = ""; if (groupingType === "aristocrat") { const normalizedTextWithSpace = plainText.toUpperCase().replace(/[^A-Z\ ]/g, ""); encodedGrouped = normalizedTextWithSpace.split("").map(letter => { return letter === " " ? " " : substitutionMap[letter]; }).join(""); } else if (groupingType === "patristocrat") { encodedGrouped = cipherText.split("").reduce((acc, letter, index) => { if (index > 0 && index % 5 === 0) { acc += " "; } return acc + letter; }, ""); } else { throw new Error(`Invalid grouping type: ${groupingType}`); } // 4.3 Generate letter counts const encodedLetterCounts: Record = cipherText.split("").reduce((acc, letter) => { acc[letter] = (acc[letter] || 0) + 1; return acc; }, {}); // 4.4 Hint (only give hint if it's patristocrat) const hintInfo = groupingType === "aristocrat" ? { hint: "", source: "" } : generateHint(plainText); // 5. Return the desired dictionary/object return { encoded: encodedGrouped, original: plainText, // The original (unmodified) plain text cleanOriginal: normalizedText, encodedLetterCounts, substitutionMap, // A->D, B->W, etc. reverseSubstitutionMap, // D->A, W->B, etc. keyword, positionLetter, type, groupingType, hint: hintInfo.hint, hintSource: hintInfo.source, }; } function App({ uuid }: { uuid: string }) { const [name, setName] = useState(localStorage.getItem("name")); const [cipher, setCipher] = useState | null>(null); const [decryptionAttempt, setDecryptionAttempt] = useState([]); const [startTime, setStartTime] = useState(null); const [solveTime, setSolveTime] = useState(null); const [isCorrect, setIsCorrect] = useState(null); const [hintCount, setHintCount] = useState(0); const [keywordRevealed, setKeywordRevealed] = useState(false); const [quoteAuthor, setQuoteAuthor] = useState(null); const [isLoading, setIsLoading] = useState(true); const [loadingError, setLoadingError] = useState(""); const [isRevealed, setIsRevealed] = useState(false); const [currentFocusIndex, setCurrentFocusIndex] = useState(null); const inputRefs = useRef[]>([]); const [copied, setCopied] = useState(false); const [knownTextsShown, setKnownTextsShown] = useState(false); const currentUrl = `${window.location.origin}${window.location.pathname}?id=${uuid}`; window.history.pushState({}, "", currentUrl); useEffect(() => { async function fetchQuote() { try { let loadedFromUUID = false; if (uuid) { const response = await fetch(`https://bao-simplevalueapi.web.val.run/getValue?id=${uuid}`); const responseData = await response.json(); const newCipher = responseData?.value?.cipher; const author = responseData?.value?.author; if (newCipher && author) { setCipher(newCipher); setQuoteAuthor(author); loadedFromUUID = true; // Initialize decryption attempt with empty strings const initialAttempt = newCipher.encoded.replace(/\s/g, "").split("").map(() => ""); setDecryptionAttempt(initialAttempt); // Create refs for each input inputRefs.current = initialAttempt.map(() => createRef()); setIsLoading(false); } } if (!loadedFromUUID) { let keyword = ""; let quote = ""; let author = ""; while (quote === "") { const randomId = Math.floor(Math.random() * quoteCount) + 1; const response = await fetch(`/quote?pageId=${randomId}`); const responseData = await response.json(); if ((responseData?.quote?.length ?? 0) >= 70) { keyword = responseData.keyword; quote = responseData.quote; author = responseData.author; break; } } const typeNumber = Math.random(); const groupingType = Math.random() < 0.6 ? "aristocrat" : "patristocrat"; const type = groupingType === "aristocrat" ? (typeNumber > 0.667 ? "random" : (typeNumber <= 0.333 ? "k1" : "k2")) : (typeNumber < 0.5 ? "k1" : "k2"); const positionLetter = randomLetter(); const newCipher = substitutionEncode({ plainText: quote, keyword, positionLetter, type, groupingType }); setCipher(newCipher); setQuoteAuthor(author); if (uuid) { const writeResult = await fetch("https://bao-simplevalueapi.web.val.run/setValue", { method: "POST", headers: { "Content-Type": "application/json", }, body: JSON.stringify({ id: uuid, value: { cipher: newCipher, author }, }), }); } // Initialize decryption attempt with empty strings const initialAttempt = newCipher.encoded.replace(/\s/g, "").split("").map(() => ""); setDecryptionAttempt(initialAttempt); // Create refs for each input inputRefs.current = initialAttempt.map(() => createRef()); setIsLoading(false); } } catch (error) { console.error("Failed to fetch quote:", error); setLoadingError(`${error}`); setIsLoading(false); } } fetchQuote(); }, []); const handleCopy = () => { navigator.clipboard.writeText(currentUrl).then(() => { setCopied(true); setTimeout(() => setCopied(false), 2000); }); }; const handleStartGame = () => { if (!name || !name.trim()) { return; } localStorage.setItem("name", name ?? ""); setStartTime(Date.now()); }; const handleAgain = () => { if (uuid) { const newId = incrementAgain(uuid); window.location.href = `${window.location.origin}${window.location.pathname}?id=${newId}`; } }; const handleLetterChange = (index: number, value: string) => { if (!cipher) return; const newAttempt = [...decryptionAttempt]; const uppercaseValue = value.toUpperCase(); // If the value is a letter, autofill all matching encoded letters if (/^[A-Z]$/.test(uppercaseValue)) { newAttempt[index] = uppercaseValue; // Find all indices of the same encoded letter and fill them decryptionAttempt.forEach((letter, idx) => { if (cipher.encoded.replace(/\s/g, "")[idx] === cipher.encoded.replace(/\s/g, "")[index]) { newAttempt[idx] = uppercaseValue; } }); // Find the next unfilled input and focus it const nextUnfilledIndex = newAttempt.findIndex((letter, i) => letter === "" && i > index); if (nextUnfilledIndex !== -1 && inputRefs.current[nextUnfilledIndex]?.current) { inputRefs.current[nextUnfilledIndex].current?.focus(); } } setDecryptionAttempt(newAttempt); }; const handleKeyDown = (index: number, event: React.KeyboardEvent) => { if (!cipher) return; // Handle backspace to clear all instances of the letter or move to previous input if (event.key === "Backspace") { const encodedWithoutSpace = cipher.encoded.replace(/\s/g, ""); // If current input is empty, move to previous input and delete its letter if (!decryptionAttempt[index]) { if (index > 0) { const prevIndex = index - 1; const newAttempt = [...decryptionAttempt]; // Remove the letter from the previous input const encodedLetterToRemove = encodedWithoutSpace[prevIndex]; newAttempt[prevIndex] = ""; // Remove the same letter from all other inputs const updatedAttempt = newAttempt.map((letter, index) => encodedWithoutSpace[index] === encodedLetterToRemove ? "" : letter ); setDecryptionAttempt(updatedAttempt); // Focus the previous input inputRefs.current[prevIndex].current?.focus(); } } else { // If current input is not empty, clear all instances of its letter const encodedLetterToRemove = encodedWithoutSpace[index]; const newAttempt = decryptionAttempt.map((letter, index) => encodedWithoutSpace[index] === encodedLetterToRemove ? "" : letter ); setDecryptionAttempt(newAttempt); // Focus the current input after clearing inputRefs.current[index].current?.focus(); } } }; const handleClear = async () => { if (cipher) { const initialAttempt = cipher.encoded.replace(/\s/g, "").split("").map(() => ""); setDecryptionAttempt(initialAttempt); } }; const handleSubmit = async () => { if (isRevealed || isCorrect) { return; } if (cipher) { // Remove spaces from the encoded message to match decryption attempt const cleanEncoded = cipher.encoded.replace(/\s/g, ""); // Translate the decryption attempt back to original letters const translatedAttempt = decryptionAttempt.join(""); const isMatch = translatedAttempt === cipher.cleanOriginal; setIsCorrect(isMatch); if (isMatch && startTime) { const timeTaken = Math.round((Date.now() - startTime) / 1000); setSolveTime(timeTaken); appendToLocalStorage(cipher.original, quoteAuthor); if (uuid && name) { await fetch("https://bao-simplevalueapi.web.val.run/addLog", { method: "POST", headers: { "Content-Type": "application/json", }, body: JSON.stringify({ id: uuid, log: `⭐️ ${name} completed the mission. Time: ${timeTaken} seconds. Hints: ${hintCount}. Keyword needed: ${ keywordRevealed ? "yes" : "no" }`, }), }); } } if (!isMatch && uuid && name) { await fetch("https://bao-simplevalueapi.web.val.run/addLog", { method: "POST", headers: { "Content-Type": "application/json", }, body: JSON.stringify({ id: uuid, log: `❌ ${name} submitted an incorrect answer. Hints so far: ${hintCount}. Keyword used: ${ keywordRevealed ? "yes" : "no" }`, }), }); } } }; const handleRevealAnswer = async () => { if (isCorrect) { return; } if (cipher) { const revealedAttempt = cipher.cleanOriginal.split(""); setDecryptionAttempt(revealedAttempt); setIsRevealed(true); appendToLocalStorage(cipher.original, quoteAuthor); if (uuid && name) { const writeResult = await fetch("https://bao-simplevalueapi.web.val.run/addLog", { method: "POST", headers: { "Content-Type": "application/json", }, body: JSON.stringify({ id: uuid, log: `💀 ${name} abandoned the mission`, }), }); } } }; const handleRevealKeyword = () => { if (cipher) { if (cipher.type === "random") { alert("It's a random substitution cipher. There is no keyword."); } else { alert(`The keyword is ${cipher.keyword}`); setKeywordRevealed(true); } } }; const handleRevealAuthor = () => { if (quoteAuthor) { alert(`The author is ${quoteAuthor}`); } else { alert(`No author for this`); } }; const handleHintType = () => { if (isCorrect || isRevealed) { return; } if (cipher && currentFocusIndex !== null) { // Get the original letter for the current encoded letter const encodedLetter = cipher.encoded.replace(/\s/g, "")[currentFocusIndex]; const originalLetter = Object.entries(cipher.reverseSubstitutionMap) .find(([encoded]) => encoded === encodedLetter)?.[1] || ""; if (originalLetter) { const newAttempt = [...decryptionAttempt]; newAttempt[currentFocusIndex] = originalLetter; // Fill all matching encoded letters decryptionAttempt.forEach((letter, idx) => { if (cipher.encoded.replace(/\s/g, "")[idx] === encodedLetter) { newAttempt[idx] = originalLetter; } }); setDecryptionAttempt(newAttempt); setHintCount(hintCount + 1); // Find the next unfilled input and focus it const nextUnfilledIndex = newAttempt.findIndex((letter, i) => letter === "" && i > currentFocusIndex); if (nextUnfilledIndex !== -1 && inputRefs.current[nextUnfilledIndex]?.current) { inputRefs.current[nextUnfilledIndex].current?.focus(); } } } }; const isDuplicated = (encodedLetter: string) => { if (!cipher) return false; const encodedWithoutSpace = cipher.encoded.replace(/\s/g, ""); let attemptForLetter = ""; for (const index in decryptionAttempt) { if (encodedWithoutSpace[index] === encodedLetter && decryptionAttempt[index] !== "") { attemptForLetter = decryptionAttempt[index]; break; } } for (const index in decryptionAttempt) { // if another encoded letter also uses attemptForLetter if ( decryptionAttempt[index] !== "" && encodedWithoutSpace[index] !== encodedLetter && decryptionAttempt[index] === attemptForLetter ) { return true; } } return false; }; const attemptedOriginalFor = (encodedLetter: string) => { if (!cipher) return ""; const encodedWithoutSpace = cipher.encoded.replace(/\s/g, ""); for (const index in decryptionAttempt) { if (encodedWithoutSpace[index] === encodedLetter && decryptionAttempt[index] !== "") { return decryptionAttempt[index]; } } return "?"; }; const attemptedEncodedFor = (originalLetter: string) => { if (!cipher) return ""; const encodedWithoutSpace = cipher.encoded.replace(/\s/g, ""); for (const index in decryptionAttempt) { if (decryptionAttempt[index] === originalLetter) { return encodedWithoutSpace[index]; } } return "?"; }; const indexFor = (groupIndex: number, indexInGroup: number): number => { if (!cipher) return 0; let index = 0; let words = cipher.encoded.split(" "); for (let i = 0; i < groupIndex; i += 1) { index += words[i].length; } return index + indexInGroup; }; if (isLoading) return

; if (!cipher) return

{`Error loading quote: ${loadingError}`}

; return (

Cipher Challenge 🕵️

{cipher && startTime === null && isTextKnown(cipher.original, quoteAuthor) && (

You have solved this puzzle before.

{knownTextsShown && (

= 0 ? "bold" : "regular" }}> {text}

)}

)} {startTime !== null && (

{cipher.encoded.split(" ").map((group, groupIndex) => (

{group.split("").map((letter, letterIndex) => (

{letter} {cipher?.encodedLetterCounts[letter].toString() ?? ""}

))}

{group.split("").map((letter, letterIndex) => ( handleLetterChange(indexFor(groupIndex, letterIndex), e.target.value)} onKeyDown={(e) => handleKeyDown(indexFor(groupIndex, letterIndex), e)} onFocus={() => setCurrentFocusIndex(indexFor(groupIndex, letterIndex))} style={{ width: "26px", height: "30px", textAlign: "center", textTransform: "uppercase", backgroundColor: letter === " " ? "transparent" : "#e0e0e0", }} disabled={letter === " "} /> ))}

))}

{cipher.hint && (

{cipher.hintSource === "first" ? "Beginning of the quote" : "End of the quote"}: {cipher.hint}

)}

{cipher.type} cipher → original:
{cipher.type !== "k2" ? "ABCDEFGHIJKLMNOPQRSTUVWXYZ".split("").map((letter, index) => ( {letter} {cipher.encodedLetterCounts[letter] ?? 0} {"→"} {attemptedOriginalFor(letter)} {" "} )) : "ABCDEFGHIJKLMNOPQRSTUVWXYZ".split("").map((letter, index) => ( {attemptedEncodedFor(letter)} {"→"} {letter} {" "} ))}

{cipher.type === "k2" && (

Cipher letter frequency:
{"ABCDEFGHIJKLMNOPQRSTUVWXYZ".split("").map((letter, index) => ( {letter} {":"} {cipher?.encodedLetterCounts[letter] ?? 0} {" "} ))}

)}

Codebreaker: {name ?? ""}

{isCorrect !== null && !isRevealed && (

{isCorrect ? ( <> 🎉 Correct! You solved the cipher in {solveTime} seconds with {hintCount} hints and{" "} {keywordRevealed ? "with the help of the keyword" : "without peeking the keyword"}.
Original Quote: "{cipher.original}" {quoteAuthor && (

Quote by: {quoteAuthor}

)} ) : ( "Incorrect. Try again! 🤔" )}

)}

)} {startTime === null && (

URGENT NOTICE

We’ve intercepted an enemy telegraph brimming with top-secret plans that could turn the tide of the war.

Your mission is to crack the cipher and extract its secrets before the enemy strikes. Lives depend on your speed and precision -- time is running out.

{cipher && (

We believe the message is encrypted with {cipher.type} {cipher.type === "random" ? "substitution " : ""} {cipher.groupingType}. Learn more about the cipher at{" "} this location .

)}

setName(e.target.value)} type="text" />

)}

Competing against friends? Send them this link to solve the same problem:

See Game Result

If your friends are on the same link, you can all tap this button to compete on a same puzzle again.

{startTime !== null && (

)} {isRevealed && (

🚨 Answer Revealed! Better luck next time. 🚨

)}

); } function client() { const root = document.getElementById("root"); if (root) { const uuid = root.dataset.uuid; createRoot(root).render(); } } if (typeof document !== "undefined") { client(); } export default async function server(request: Request): Promise { const requestPath = new URL(request.url).pathname; if (requestPath === "/quote") { const pageId = new URL(request.url).searchParams.get("pageId") ?? "1"; const pageIdInt = parseInt(pageId); console.log("Page ID:", pageIdInt); try { const notionToken = Deno.env.get("Notion_ready_only_api_token"); if (!notionToken) { throw new Error("Notion API token not found"); } const databaseId = "16e2c190bff080fd9ea8d2a8c21548b0"; // Use database query with filter instead of direct page fetch const response = await fetch(`https://api.notion.com/v1/databases/${databaseId}/query`, { method: "POST", headers: { "Authorization": `Bearer ${notionToken}`, "Notion-Version": "2022-06-28", "Content-Type": "application/json", }, body: JSON.stringify({ filter: { and: [ { property: "ID", // Uppercase ID property unique_id: { less_than_or_equal_to: pageIdInt + 2, // load a few more to make sure we have one that's long enough }, }, { property: "ID", // Uppercase ID property unique_id: { greater_than_or_equal_to: pageIdInt - 2, // load a few more to make sure we have one that's long enough }, }, ], }, }), }); // console.log(response); if (!response.ok) { throw new Error(`Failed to query Notion database: ${response.statusText}`); } const data = await response.json(); let keyword = ""; console.log(`Fetched ${data.results.length} pages from Notion API:`); for (const page of data.results) { // console.log("Checking page", page.properties.ID); // Extract plain text from rich text properties const quote = page.properties.quote?.rich_text?.[0]?.plain_text || ""; const author = page.properties.author?.rich_text?.[0]?.plain_text || ""; if (!keyword) { keyword = randomWordFromSentence(quote); // console.log("Found a keyword", keyword); continue; } if (quote.length >= 70) { // console.log("Found a quote long enough", quote); return new Response(JSON.stringify({ quote, author, keyword }), { headers: { "Content-Type": "application/json" }, }); } } throw new Error(`No page found with ID ${pageId}`); } catch (error) { return new Response(JSON.stringify({ error: error.message }), { status: 500, headers: { "Content-Type": "application/json" }, }); } } const url = new URL(request.url); const paramUuid = url.searchParams.get("id"); const displayUuid = paramUuid || "cipher-" + crypto.randomUUID(); return new Response( ` Cipher Challenge

`, { headers: { "content-type": "text/html", }, }, ); }