Val Town Code SearchReturn to Val Town

23*/
24
25import { fetch as proxiedFetch } from "https://esm.town/v/std/fetch";
26import * as cheerio from "npm:cheerio";
27import { fetchLyricsMetadata } from "./lyrics";
28
29/**
55    }
56
57    const res = await fetchLyricsMetadata(query);
58
59    if (res.status === 200 && res.url !== "Not found") {
63        "Accept-Language": "en-US,en;q=0.9",
64        "Cache-Control": "max-age=0",
65        "Sec-Fetch-Dest": "document",
66        "Sec-Fetch-Mode": "navigate",
67        "Sec-Fetch-Site": "none",
68        "Sec-Fetch-User": "?1",
69        "Sec-Gpc": "1",
70        "Upgrade-Insecure-Requests": "1",
80      }
81
82      const response = await fetch(res.url, { headers: headers });
83      const targetHtml = await response.text();
84      let $ = cheerio.load(targetHtml);

23*/
24
25import { fetch as proxiedFetch } from "https://esm.town/v/std/fetch";
26
27interface LyricsResponse {
53}
54
55export const fetchLyricsMetadata = async (
56  searchTerm: string,
57): Promise<LyricsResponse> => {
73
74    // Make the API request
75    const response = await proxiedFetch(target, { headers });
76    const data = await response.json();
77

106    return c.json({ success: true, data: resumes });
107  } catch (error) {
108    console.error("Error fetching resumes:", error);
109    return c.json({ success: false, error: "Failed to fetch resumes" }, 500);
110  }
111});
125    return c.json({ success: true, data: resume });
126  } catch (error) {
127    console.error("Error fetching resume:", error);
128    return c.json({ success: false, error: "Failed to fetch resume" }, 500);
129  }
130});
169    return c.json({ success: true, data: jobs });
170  } catch (error) {
171    console.error("Error fetching job requirements:", error);
172    return c.json({ success: false, error: "Failed to fetch job requirements" }, 500);
173  }
174});
188    return c.json({ success: true, data: job });
189  } catch (error) {
190    console.error("Error fetching job requirement:", error);
191    return c.json({ success: false, error: "Failed to fetch job requirement" }, 500);
192  }
193});
298
299// Export the Hono app
300export default app.fetch;

26  const [error, setError] = useState<string | null>(null);
27
28  // Fetch resumes and jobs on initial load
29  React.useEffect(() => {
30    fetchResumes();
31    fetchJobs();
32  }, []);
33
34  // Fetch all resumes
35  const fetchResumes = async () => {
36    try {
37      const response = await fetch("/api/resumes");
38      const data = await response.json();
39      
41        setResumes(data.data);
42      } else {
43        setError(data.error || "Failed to fetch resumes");
44      }
45    } catch (error) {
46      console.error("Error fetching resumes:", error);
47      setError("Failed to fetch resumes");
48    }
49  };
50
51  // Fetch all jobs
52  const fetchJobs = async () => {
53    try {
54      const response = await fetch("/api/jobs");
55      const data = await response.json();
56      
58        setJobs(data.data);
59      } else {
60        setError(data.error || "Failed to fetch jobs");
61      }
62    } catch (error) {
63      console.error("Error fetching jobs:", error);
64      setError("Failed to fetch jobs");
65    }
66  };
72    
73    try {
74      const response = await fetch("/api/resumes", {
75        method: "POST",
76        headers: {
84      if (data.success) {
85        // Refresh resumes list
86        await fetchResumes();
87        setActiveTab("results");
88      } else {
103    
104    try {
105      const response = await fetch("/api/jobs", {
106        method: "POST",
107        headers: {
115      if (data.success) {
116        // Refresh jobs list
117        await fetchJobs();
118        setSelectedJob(data.data);
119        setActiveTab("results");
154      
155      // Score resumes
156      const response = await fetch("/api/score/batch", {
157        method: "POST",
158        headers: {
184    
185    try {
186      const response = await fetch("/api/score", {
187        method: "POST",
188        headers: {

20  
21  // Read the HTML file content
22  const response = await fetch(new URL(htmlFile, import.meta.url));
23  const html = await response.text();
24  

1const script = `
2export default {
3	async fetch(request, env, ctx) {
4		const url = new URL(request.url);
5		url.host = "embed-hono.lime4042.workers.dev";
6		console.log(url)
7		const r = await fetch(url,request);
8		return new Response((r).body,r);
9	},
19  files.append("uuid", uuid);
20  files.append("token", key);
21  const upload = await fetch(
22    `https://temptemp-workers.web.val.run/pushCode?uuid=${uuid}&token=${key}`,
23    {

20});
21
22export default app.fetch;

1/** @jsxImportSource https://esm.sh/hono@latest/jsx **/
2
3import { modifyFetchHandler } from "https://esm.town/v/andreterron/codeOnValTown?v=50";
4import { iframeHandler } from "https://esm.town/v/nbbaier/iframeHandler";
5import { resetStyle } from "https://esm.town/v/nbbaier/resetStyle";
16import { sqliteStyle } from "https://esm.town/v/robaggio/sqliteStyle";
17import { ResultSet, sqlite } from "https://esm.town/v/std/sqlite";
18import { reloadOnSaveFetchMiddleware } from "https://esm.town/v/stevekrouse/reloadOnSave";
19import { Hono } from "npm:hono";
20import type { FC } from "npm:hono/jsx";
175});
176
177export const handler = app.fetch;
178export default iframeHandler(modifyFetchHandler(passwordAuth(handler, { verifyPassword: verifyToken })));

149  const [showModal, setShowModal] = useState(false);
150
151  async function fetchLastWateredInternal() {
152    if (!syncId) return;
153    setIsLoading(true);
154    try {
155      const response = await fetch(`/api/${syncId}/last-watered`);
156      if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
157      const data = await response.json();
158      setLastWatered(data.lastWatered);
159    } catch (error) {
160      console.error("Error fetching last watered:", error);
161      setLastWatered(null); // Set to a default or error state
162    }
165
166  useEffect(() => {
167    fetchLastWateredInternal();
168  }, [syncId]);
169
220        <WatererSelectionModal
221          onClose={() => setShowModal(false)}
222          onWatered={fetchLastWateredInternal} // Pass the internal fetcher
223        />
224      )}
237  const [sortedWaterers, setSortedWaterers] = useState([]);
238
239  async function fetchWaterersInternal() {
240    if (!syncId) return;
241    try {
242      const response = await fetch(`/api/${syncId}/waterers`);
243      if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
244      const data = await response.json();
245      setWaterers(Array.isArray(data) ? data : []);
246    } catch (error) {
247      console.error("Error fetching waterers:", error);
248      setWaterers([]);
249    }
250  }
251
252  async function fetchRecentWaterersInternal() {
253    if (!syncId) return;
254    try {
255      const response = await fetch(`/api/${syncId}/history`);
256      if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
257      const data = await response.json();
264      setRecentWaterers(uniqueNames);
265    } catch (error) {
266      console.error("Error fetching recent waterers:", error);
267      setRecentWaterers([]);
268    }
303
304  useEffect(() => {
305    fetchWaterersInternal();
306    fetchRecentWaterersInternal();
307  }, [syncId]);
308
312
313    try {
314      await fetch(`/api/${syncId}/water`, {
315        method: "POST",
316        headers: { "Content-Type": "application/json" },
323      if (newWatererName.trim() && !selectedWaterer) {
324        // Add the new waterer to the list
325        await fetch(`/api/${syncId}/waterers`, {
326          method: "POST",
327          headers: { "Content-Type": "application/json" },
330      }
331
332      onWatered(); // This will call fetchLastWateredInternal in Plant component
333      onClose();
334    } catch (error) {
475  };
476
477  async function fetchDataInternal() {
478    if (!syncId) return;
479    setIsLoading(true);
481    try {
482      const [waterersResponse, historyResponse] = await Promise.all([
483        fetch(`/api/${syncId}/waterers`),
484        fetch(`/api/${syncId}/history`),
485      ]);
486      if (!waterersResponse.ok) throw new Error(`Waterers fetch error! status: ${waterersResponse.status}`);
487      if (!historyResponse.ok) throw new Error(`History fetch error! status: ${historyResponse.status}`);
488
489      const waterersData = await waterersResponse.json();
493      setHistory(Array.isArray(historyData) ? historyData : []);
494    } catch (error) {
495      console.error("Error fetching data for history:", error);
496      setWaterers([]);
497      setHistory([]);
502
503  useEffect(() => {
504    fetchDataInternal();
505  }, [syncId]);
506
510    setIsProcessing(true);
511    try {
512      await fetch(`/api/${syncId}/history/${entryId}`, { method: "DELETE" });
513      fetchDataInternal(); // Refresh
514    } catch (error) {
515      console.error("Error deleting history entry:", error);
673  const [isProcessing, setIsProcessing] = useState(false);
674
675  async function fetchWaterersInternal() {
676    if (!syncId) return;
677    setIsLoading(true);
678    setIsProcessing(true);
679    try {
680      const waterersResponse = await fetch(`/api/${syncId}/waterers`);
681      if (!waterersResponse.ok) throw new Error(`Waterers fetch error! status: ${waterersResponse.status}`);
682
683      const waterersData = await waterersResponse.json();
684      setWaterers(Array.isArray(waterersData) ? waterersData : []);
685    } catch (error) {
686      console.error("Error fetching waterers:", error);
687      setWaterers([]);
688    }
692
693  useEffect(() => {
694    fetchWaterersInternal();
695  }, [syncId]);
696
699    setIsProcessing(true);
700    try {
701      const response = await fetch(`/api/${syncId}/waterers`, {
702        method: "POST",
703        headers: { "Content-Type": "application/json" },
709      }
710      setNewWatererName("");
711      fetchWaterersInternal(); // Refresh waterers
712    } catch (error) {
713      console.error("Error adding waterer:", error);
723      setIsProcessing(true);
724      try {
725        await fetch(`/api/${syncId}/waterers/${watererId}`, {
726          method: "PUT",
727          headers: { "Content-Type": "application/json" },
728          body: JSON.stringify({ name: newName.trim() }),
729        });
730        fetchWaterersInternal(); // Refresh
731      } catch (error) {
732        console.error("Error renaming waterer:", error);
742    setIsProcessing(true);
743    try {
744      await fetch(`/api/${syncId}/waterers/${watererId}`, { method: "DELETE" });
745      fetchWaterersInternal(); // Refresh
746    } catch (error) {
747      console.error("Error deleting waterer:", error);
1034    });
1035    
1036    self.addEventListener('fetch', event => {
1037      // For navigation requests, try network first, then cache
1038      if (event.request.mode === 'navigate') {
1039        event.respondWith(
1040          fetch(event.request)
1041            .then(response => {
1042              // Cache a copy of the response
1048            })
1049            .catch(() => {
1050              // If network fetch fails, fallback to cache
1051              return caches.match(event.request);
1052            })
1057      // For all other requests, try network, don't cache
1058      event.respondWith(
1059        fetch(event.request)
1060          .catch(() => caches.match(event.request))
1061      );
1085          [currentSyncId],
1086        );
1087        // Fetch the newly created row to ensure consistent data structure
1088        result = await sqlite.execute(
1089          `SELECT waterers, watering_log, last_watered_timestamp FROM instances WHERE sync_id = ?`,

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