Val Town Code SearchReturn to Val Town

59  // If we get here, authentication was successful
60
61  // Fetch all rows from the usage table
62  // Fetch all rows from the usage table
63  const allUsageData = await sqlite.execute(`SELECT * FROM ${USAGE_TABLE} ORDER BY timestamp DESC`);
64
65  // Fetch aggregated data grouped by user_id
66  const groupedUsageData = await sqlite.execute(`
67    SELECT 

48
49  // Register the commands
50  const response = await fetch(`https://discord.com/api/v10/${endpoint}`, {
51    method: "PUT",
52    headers: {

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

9
10  useEffect(() => {
11    fetchTasks();
12  }, []);
13
14  const fetchTasks = async () => {
15    setLoading(true);
16    setError(null);
17    try {
18      const res = await fetch("/todoist-tasks");
19      if (!res.ok) {
20        throw new Error("Failed to fetch tasks");
21      }
22      const data = await res.json();
54        <div>
55          <button
56            onClick={fetchTasks}
57            style={{
58              backgroundColor: "#4CAF50",
141
142    try {
143      // Fetch active tasks from Todoist
144      const todoistResponse = await fetch(`${TODOIST_API_BASE}/tasks`, {
145        headers: {
146          "Authorization": `Bearer ${apiToken}`,
150
151      if (!todoistResponse.ok) {
152        throw new Error("Failed to fetch Todoist tasks");
153      }
154

510
511                  try {
512                      const response = await fetch(sourceApiUrl, {
513                          method: 'POST',
514                          body: formData // FormData handles multipart/form-data encoding
528                            // Optionally, clear the form and refresh parts of the page
529                            // uploadForm.reset();
530                            // Consider fetching and re-rendering tagsData if new tags were added.
531                            // For simplicity, a page reload might be easiest here, or more complex AJAX update.
532                            // Example: setTimeout(() => window.location.reload(), 3000); // Reload after 3s
626  // --- Dynamic Imports (Inside Handler for Val Town) ---
627  const { OpenAI } = await import("https://esm.town/v/std/openai");
628  const val_fetch = (await import("https://esm.town/v/std/fetch")).fetch;
629  const { PDFExtract } = await import("npm:pdf.js-extract");
630  type PDFExtractOptions = import("npm:pdf.js-extract").PDFExtractOptions;
735      try {
736        if (!input.documentUrl.match(/^https?:\/\//i)) throw new Error("Invalid URL scheme. Must be http or https.");
737        const res = await val_fetch(input.documentUrl, {
738          headers: {
739            "Accept": "text/plain, text/html, application/pdf",
742          redirect: "follow",
743        });
744        if (!res.ok) throw new Error(`HTTP error ${res.status} while fetching URL.`);
745        const ct = res.headers.get("content-type") || "";
746        if (ct.includes("application/pdf")) {
760        ) {
761          docText = await res.text();
762          if (!docText?.trim()) throw new Error("Fetched empty text from URL.");
763          if (ct.includes("text/html")) {
764            log.push({ agent: ingestAgent, type: "step", message: `HTML content detected. Attempting basic strip.` });
773        }
774      } catch (e) {
775        log.push({ agent: ingestAgent, type: "error", message: `URL fetch/process failed: ${e.message}` });
776      }
777    }
987      tagsData = (result.rows as StoredTag[]) || [];
988    } catch (e) {
989      console.error("Error fetching tags for UI:", e);
990      dbError = e.message;
991      tagsData = []; // Ensure tagsData is an empty array on error

1import { API_URL } from "https://esm.town/v/std/API_URL";
2import { fetchJSON } from "https://esm.town/v/stevekrouse/fetchJSON";
3import ValTown from "npm:@valtown/sdk";
4
30// Example of using the API to create a new val with a single file
31// First create the val
32const valResponse = await fetch(
33  `${API_URL}/v2/vals`,
34  {
52// Then create the file
53const val = await valResponse.json();
54const fileResponse = await fetch(
55  `${API_URL}/v2/vals/${val.id}/files?path=main.tsx`,
56  {

4import { NodeHtmlMarkdown, NodeHtmlMarkdownOptions } from "npm:node-html-markdown";
5
6const html = await fetch("https://github.com/trending").then(r => r.text());
7
8const { window: { document } } = new JSDOM(html);