Val Town Code SearchReturn to Val Town

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

82  const [sortConfig, setSortConfig] = useState({ key: "name", direction: "ascending" });
83
84  // Fetch and process data
85  useEffect(() => {
86    const fetchData = async () => {
87      setIsLoading(true);
88      setError(null);
89      try {
90        const response = await fetch(JSON_URL);
91        if (!response.ok) {
92          throw new Error(`HTTP error! status: ${response.status}`);
117        setModesList(["", ...uniqueModes]); // Add "All" option
118      } catch (e) {
119        console.error("Failed to fetch or process model data:", e);
120        setError(e.message);
121      } finally {
123      }
124    };
125    fetchData();
126  }, []);
127

11  const [error, setError] = useState(null);
12
13  const fetchData = async () => {
14    try {
15      const projectEndpoint = new URL(PROJECT_ENDPOINT, window.location.origin);
23      };
24
25      const { project } = await fetch(projectEndpoint, { headers })
26        .then(res => res.json());
27      const { files } = await fetch(filesEndpoint, { headers })
28        .then(res => res.json());
29
40  useEffect(() => {
41    if (!projectId) return;
42    fetchData();
43  }, [projectId, branchId]);
44
45  return { data, loading, error, refetch: fetchData };
46}
47

10  const [error, setError] = useState(null);
11
12  const fetchData = async () => {
13    try {
14      const res = await fetch(ENDPOINT, {
15        headers: {
16          "Authorization": "Bearer " + token,
18      })
19      const data = await res.json();
20      console.log("useProjects fetchData", { res, data });
21      if (!res.ok) {
22        console.error(data);
39
40  useEffect(() => {
41    fetchData();
42  }, []);
43
44  return { data, loading, error, refetch: fetchData };
45}
46

19    setError(null);
20    try {
21      const res = await fetch(ENDPOINT, {
22        method: "POST",
23        headers: {

16    setData(null);
17    setError(null);
18    const res = await fetch(ENDPOINT, {
19      method: "POST",
20      headers: {

9  const [loading, setLoading] = useState(true);
10
11  const fetchData = async () => {
12    const endpoint = new URL(ENDPOINT, window.location.origin);
13    endpoint.searchParams.append("projectId", projectId);
14
15    const res = await fetch(endpoint, {
16      headers: {
17        "Authorization": "Bearer " + token,
24  useEffect(() => {
25    if (!projectId) return;
26    fetchData();
27  }, [projectId]);
28
29  return { data, loading, refetch: fetchData };
30}
31

15    // replace all this with oauth when it's ready
16    try {
17      const res = await fetch("/api/user", {
18        headers: {
19          "Authorization": "Bearer " + valTownAPIKey,

136  let type_: "file" | "http" | "script";
137  if (path.includes("backend/index.ts")) type_ = "http";
138  if (file_text?.includes("export default app.fetch")) type_ = "http";
139  if ([".ts", ".tsx", ".js", ".jsx"].some(ext => path.endsWith(ext))) {
140    type_ = "script";

233    
234    // Inject data to avoid extra round-trips
235    const initialData = await fetchInitialData();
236    const dataScript = `<script>
237      window.__INITIAL_DATA__ = ${JSON.stringify(initialData)};
280
2815. **API Design:**
282   - `fetch` handler is the entry point for HTTP vals
283   - Run the Hono app with `export default app.fetch // This is the entry point for HTTP vals`