Val Town Code SearchReturn to Val Town

9    }
10
11    const response = await fetch(cacheUrl, { 
12      // Add timeout and other performance optimizations
13      signal: AbortSignal.timeout(5000),
19    
20    if (!response.ok) {
21      throw new Error('Failed to fetch zb.txt');
22    }
23
38    return newResponse;
39  } catch (error) {
40    // If fetch fails, provide a fallback or error response
41    return new Response(`Error retrieving zb.txt: ${error.message}`, { 
42      status: 500,

181
182    try {
183      const response = await fetch("/", {
184        method: "POST",
185        body: JSON.stringify({

135  const lastSunday = today.startOf("week").minus({ days: 1 });
136
137  // Fetch relevant memories using the utility function
138  const memories = await getRelevantMemories();
139

67  const [currentPage, setCurrentPage] = useState(1);
68
69  const fetchMemories = useCallback(async () => {
70    setLoading(true);
71    setError(null);
72    try {
73      const response = await fetch(API_BASE);
74      if (!response.ok) {
75        throw new Error(`HTTP error! status: ${response.status}`);
78      setMemories(data);
79    } catch (e) {
80      console.error("Failed to fetch memories:", e);
81      setError(e.message || "Failed to fetch memories.");
82    } finally {
83      setLoading(false);
86
87  useEffect(() => {
88    fetchMemories();
89  }, [fetchMemories]);
90
91  const handleAddMemory = async (e: React.FormEvent) => {
100
101    try {
102      const response = await fetch(API_BASE, {
103        method: "POST",
104        headers: { "Content-Type": "application/json" },
112      setNewMemoryTags("");
113      setShowAddForm(false);
114      await fetchMemories();
115    } catch (e) {
116      console.error("Failed to add memory:", e);
123
124    try {
125      const response = await fetch(`${API_BASE}/${id}`, {
126        method: "DELETE",
127      });
129        throw new Error(`HTTP error! status: ${response.status}`);
130      }
131      await fetchMemories();
132    } catch (e) {
133      console.error("Failed to delete memory:", e);
155
156    try {
157      const response = await fetch(`${API_BASE}/${editingMemory.id}`, {
158        method: "PUT",
159        headers: { "Content-Type": "application/json" },
164      }
165      setEditingMemory(null);
166      await fetchMemories();
167    } catch (e) {
168      console.error("Failed to update memory:", e);

135  ));
136
137// HTTP vals expect an exported "fetch handler"
138export default app.fetch;

163```
164
1655. **fetchTranspiledJavaScript** - Fetch and transpile TypeScript to JavaScript:
166```ts
167const jsCode = await fetchTranspiledJavaScript("https://esm.town/v/username/project/path/to/file.ts");
168```
169
242
243    // Inject data to avoid extra round-trips
244    const initialData = await fetchInitialData();
245    const dataScript = `<script>
246      window.__INITIAL_DATA__ = ${JSON.stringify(initialData)};
300
3015. **API Design:**
302   - `fetch` handler is the entry point for HTTP vals
303   - Run the Hono app with `export default app.fetch // This is the entry point for HTTP vals`
304   - Properly handle CORS if needed for external access

82  const [cookieAndTeaMode, setCookieAndTeaMode] = useState(false);
83
84  // Fetch images from backend instead of blob storage directly
85  useEffect(() => {
86    // Set default background color in case image doesn't load
89    }
90
91    // Fetch avatar image
92    fetch("/api/images/stevens.jpg")
93      .then((response) => {
94        if (response.ok) return response.blob();
103      });
104
105    // Fetch wood background
106    fetch("/api/images/wood.jpg")
107      .then((response) => {
108        if (response.ok) return response.blob();
129  }, []);
130
131  const fetchMemories = useCallback(async () => {
132    setLoading(true);
133    setError(null);
134    try {
135      const response = await fetch(API_BASE);
136      if (!response.ok) {
137        throw new Error(`HTTP error! status: ${response.status}`);
154      }
155    } catch (e) {
156      console.error("Failed to fetch memories:", e);
157      setError(e.message || "Failed to fetch memories.");
158    } finally {
159      setLoading(false);
162
163  useEffect(() => {
164    fetchMemories();
165  }, [fetchMemories]);
166
167  const handleAddMemory = async (e: React.FormEvent) => {
176
177    try {
178      const response = await fetch(API_BASE, {
179        method: "POST",
180        headers: { "Content-Type": "application/json" },
188      setNewMemoryTags("");
189      setShowAddForm(false);
190      await fetchMemories();
191    } catch (e) {
192      console.error("Failed to add memory:", e);
199
200    try {
201      const response = await fetch(`${API_BASE}/${id}`, {
202        method: "DELETE",
203      });
205        throw new Error(`HTTP error! status: ${response.status}`);
206      }
207      await fetchMemories();
208    } catch (e) {
209      console.error("Failed to delete memory:", e);
231
232    try {
233      const response = await fetch(`${API_BASE}/${editingMemory.id}`, {
234        method: "PUT",
235        headers: { "Content-Type": "application/json" },
240      }
241      setEditingMemory(null);
242      await fetchMemories();
243    } catch (e) {
244      console.error("Failed to update memory:", e);

12  const basic = Buffer.from(`${client_id}:${client_secret}`).toString("base64");
13
14  const response = await fetch(TOKEN_ENDPOINT, {
15    method: "POST",
16    headers: {
31    const { access_token } = await getAccessToken(client_id, client_secret, refresh_token);
32
33    const response = await fetch(NOW_PLAYING_ENDPOINT, {
34      headers: {
35        Authorization: `Bearer ${access_token}`,

32
33  useEffect(() => {
34    fetchContributions();
35  }, []);
36
37  const fetchContributions = async () => {
38    setError(null);
39    setContributionData(null);
40    setUserData(null);
41    try {
42      const response = await fetch("/contributions", {
43        method: "POST",
44        headers: { "Content-Type": "application/json" },
45        body: JSON.stringify({ username }),
46      });
47      if (!response.ok) throw new Error("Failed to fetch contributions");
48      const data = await response.json();
49      console.log("Fetched data:", data);
50      setContributionData(data.contributionCalendar);
51      setUserData(data.user);
52    } catch (err) {
53      console.error("Error fetching contributions:", err);
54      setError(err.message);
55    }
248  const handleKeyPress = (event) => {
249    if (event.key === "Enter") {
250      fetchContributions();
251    }
252  };
272          placeholder="Enter GitHub username"
273        />
274        <button onClick={fetchContributions}>Fetch Commits</button>
275      </div>
276      {error && <p className="error">{error}</p>}
331  if (request.method === "POST" && new URL(request.url).pathname === "/contributions") {
332    const { username } = await request.json();
333    const contributionData = await fetchGitHubContributions(username);
334    return new Response(JSON.stringify(contributionData), {
335      headers: { "Content-Type": "application/json" },
359}
360
361async function fetchGitHubContributions(username: string) {
362  const query = `
363    query($username: String!) {
381  `;
382
383  const response = await fetch("https://api.github.com/graphql", {
384    method: "POST",
385    headers: {
391
392  if (!response.ok) {
393    throw new Error("Failed to fetch GitHub data");
394  }
395

55    }
56
57    // Fetch authenticated user info
58    const { data: user } = await vt.me.retrieve();
59    if (!user) {
72    });
73  } catch (error) {
74    console.error("Error fetching user info:", error);
75    // Check for specific auth errors if vt was instantiated
76    if (error.message && (error.message.includes("401") || error.message.includes("Unauthorized"))) {
77      return c.json({ error: "Authentication failed. Please check your API Key." }, 401);
78    }
79    return c.json({ error: "Failed to fetch user info", details: error.message }, 500);
80  }
81});
95        return c.json({ username: user.username });
96      } catch (error) {
97        console.error(`Error fetching user by username ${username}:`, error);
98        return c.json({ error: "Username not found", details: error.message }, 404);
99      }
105      return c.json({ username: user.username });
106    } catch (error) {
107      console.error(`Error fetching user by username ${username}:`, error);
108      return c.json({ error: "Username not found", details: error.message }, 404);
109    }
110  } catch (error) {
111    console.error("Error in /api/username/:username:", error);
112    return c.json({ error: "Failed to fetch username", details: error.message }, 500);
113  }
114});
175    return c.json(valsWithEndpoints);
176  } catch (error) {
177    console.error("Error fetching vals:", error);
178    // Check for specific auth errors if vt was instantiated
179    if (error.message && (error.message.includes("401") || error.message.includes("Unauthorized"))) {
180        return c.json({ error: "Authentication failed. Please check your API Key." }, 401);
181    }
182    return c.json({ error: "Failed to fetch vals", details: error.message }, 500);
183  }
184});
262           );
263       } else {
264           // Fallback default if val details couldn't be fetched
265           result.content = "---\ntitle: \"Unknown Val\"\ndescription: \"Could not load val details.\"\ntags: [\"val-town\"]\n---\n\n## About\n\nDetails for this val could not be loaded. It might be private or deleted.\n";
266       }
270
271  } catch (error) {
272    console.error(`Top-level error fetching val moi.md for ${c.req.param("valId")}:`, error);
273    return c.json({ error: "Failed to fetch moi.md", details: error.message }, 500);
274  }
275});
453});
454
455export default app.fetch;