Val Town Code SearchReturn to Val Town

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);

5  const responses = await Promise.all(
6    tailscaleNodeIds.map(async (tailscaleNodeId) => {
7      const response = await fetch(`https://api.tailscale.com/api/v2/device/${tailscaleNodeId}`, {
8        headers: {
9          "Authorization": `Bearer ${Deno.env.get("tailscaleApiKey")}`,

93    return c.json(tracks);
94  } catch (error) {
95    console.error("Error fetching tracks:", error);
96    return c.json({ error: "Failed to fetch tracks" }, 500);
97  }
98});
123    return c.json(tasks);
124  } catch (error) {
125    console.error("Error fetching tasks:", error);
126    return c.json({ error: "Failed to fetch tasks" }, 500);
127  }
128});
136    return c.json(tasks);
137  } catch (error) {
138    console.error(`Error fetching tasks for track ${trackId}:`, error);
139    return c.json({ error: "Failed to fetch tasks" }, 500);
140  }
141});
188    return c.json(dailyLog);
189  } catch (error) {
190    console.error(`Error fetching daily log for ${date}:`, error);
191    return c.json({ error: "Failed to fetch daily log" }, 500);
192  }
193});
267    return c.json(weeklyReview);
268  } catch (error) {
269    console.error(`Error fetching weekly review for week ${weekNumber}:`, error);
270    return c.json({ error: "Failed to fetch weekly review" }, 500);
271  }
272});
347    return c.json(userStatus);
348  } catch (error) {
349    console.error("Error fetching user status:", error);
350    return c.json({ error: "Failed to fetch user status" }, 500);
351  }
352});
379    return c.json(trackPrompts);
380  } catch (error) {
381    console.error("Error fetching track prompts:", error);
382    return c.json({ error: "Failed to fetch track prompts" }, 500);
383  }
384});
397    return c.json(trackPrompt);
398  } catch (error) {
399    console.error(`Error fetching prompt for track ${trackId}:`, error);
400    return c.json({ error: "Failed to fetch track prompt" }, 500);
401  }
402});
580    return c.json(responses);
581  } catch (error) {
582    console.error("Error fetching AI responses:", error);
583    return c.json({ error: "Failed to fetch AI responses" }, 500);
584  }
585});
634
635// Export the app for HTTP val
636export default app.fetch

195});
196
197export default lastlogin((request: Request) => app.fetch(request));

231  const [isDragging, setIsDragging] = useState(false);
232
233  const fetchBlobs = useCallback(async () => {
234    setLoading(true);
235    try {
236      const response = await fetch(`/api/blobs?prefix=${encodeKey(searchPrefix)}&limit=${limit}`);
237      const data = await response.json();
238      setBlobs(data);
239    } catch (error) {
240      console.error("Error fetching blobs:", error);
241    } finally {
242      setLoading(false);
245
246  useEffect(() => {
247    fetchBlobs();
248  }, [fetchBlobs]);
249
250  const handleSearch = (e) => {
261      setBlobContentLoading(true);
262      try {
263        const response = await fetch(`/api/blob?key=${encodeKey(clickedBlob.key)}`);
264        const content = await response.text();
265        setSelectedBlob({ ...clickedBlob, key: decodeKey(clickedBlob.key) });
266        setEditContent(content);
267      } catch (error) {
268        console.error("Error fetching blob content:", error);
269      } finally {
270        setBlobContentLoading(false);
275  const handleSave = async () => {
276    try {
277      await fetch(`/api/blob?key=${encodeKey(selectedBlob.key)}`, {
278        method: "PUT",
279        body: editContent,
287  const handleDelete = async (key) => {
288    try {
289      await fetch(`/api/blob?key=${encodeKey(key)}`, { method: "DELETE" });
290      setBlobs(blobs.filter(b => b.key !== key));
291      if (selectedBlob && selectedBlob.key === key) {
304        const key = `${searchPrefix}${file.name}`;
305        formData.append("key", encodeKey(key));
306        await fetch("/api/blob", { method: "POST", body: formData });
307        const newBlob = { key, size: file.size, lastModified: new Date().toISOString() };
308        setBlobs([newBlob, ...blobs]);
312      }
313    }
314    fetchBlobs();
315  };
316
326      try {
327        const fullKey = `${searchPrefix}${key}`;
328        await fetch(`/api/blob?key=${encodeKey(fullKey)}`, {
329          method: "PUT",
330          body: "",
341  const handleDownload = async (key) => {
342    try {
343      const response = await fetch(`/api/blob?key=${encodeKey(key)}`);
344      const blob = await response.blob();
345      const url = window.URL.createObjectURL(blob);
360    if (newKey && newKey !== oldKey) {
361      try {
362        const response = await fetch(`/api/blob?key=${encodeKey(oldKey)}`);
363        const content = await response.blob();
364        await fetch(`/api/blob?key=${encodeKey(newKey)}`, {
365          method: "PUT",
366          body: content,
367        });
368        await fetch(`/api/blob?key=${encodeKey(oldKey)}`, { method: "DELETE" });
369        setBlobs(blobs.map(b => b.key === oldKey ? { ...b, key: newKey } : b));
370        if (selectedBlob && selectedBlob.key === oldKey) {
380    const newKey = `__public/${key}`;
381    try {
382      const response = await fetch(`/api/blob?key=${encodeKey(key)}`);
383      const content = await response.blob();
384      await fetch(`/api/blob?key=${encodeKey(newKey)}`, {
385        method: "PUT",
386        body: content,
387      });
388      await fetch(`/api/blob?key=${encodeKey(key)}`, { method: "DELETE" });
389      setBlobs(blobs.map(b => b.key === key ? { ...b, key: newKey } : b));
390      if (selectedBlob && selectedBlob.key === key) {
399    const newKey = key.slice(9); // Remove "__public/" prefix
400    try {
401      const response = await fetch(`/api/blob?key=${encodeKey(key)}`);
402      const content = await response.blob();
403      await fetch(`/api/blob?key=${encodeKey(newKey)}`, {
404        method: "PUT",
405        body: content,
406      });
407      await fetch(`/api/blob?key=${encodeKey(key)}`, { method: "DELETE" });
408      setBlobs(blobs.map(b => b.key === key ? { ...b, key: newKey } : b));
409      if (selectedBlob && selectedBlob.key === key) {

29    
30    try {
31      const response = await fetch('/api/quick-guidance', {
32        method: 'POST',
33        headers: {

21  
22  useEffect(() => {
23    fetchData();
24  }, [weekNumber]);
25  
26  const fetchData = async () => {
27    setIsLoading(true);
28    setError(null);
29    
30    try {
31      // Fetch tracks, tasks, and weekly review in parallel
32      const [tracksResponse, tasksResponse, weeklyReviewResponse] = await Promise.all([
33        fetch('/api/tracks'),
34        fetch('/api/tasks'),
35        fetch(`/api/weekly-reviews/${weekNumber}`)
36      ]);
37      
38      if (!tracksResponse.ok || !tasksResponse.ok) {
39        throw new Error('Failed to fetch data');
40      }
41      
87      }
88    } catch (error) {
89      console.error('Error fetching data:', error);
90      setError('Failed to load data. Please try refreshing the page.');
91    } finally {
227    
228    try {
229      const response = await fetch('/api/weekly-reviews', {
230        method: 'POST',
231        headers: {
250      // Send weekly email
251      try {
252        await fetch('/api/send-weekly-email', {
253          method: 'POST'
254        });
271    
272    try {
273      const response = await fetch('/api/weekly-review-feedback', {
274        method: 'POST',
275        headers: {

81    
82    try {
83      const response = await fetch('/api/user-status', {
84        method: 'POST',
85        headers: {