Val Town Code SearchReturn to Val Town

30  const [showCreateBranch, setShowCreateBranch] = useState<boolean>(false);
31
32  // Fetch branches when project changes
33  useEffect(() => {
34    if (!projectId) return;
35
36    const fetchBranches = async () => {
37      setIsLoadingBranches(true);
38      try {
39        const response = await fetch(`/api/project-branches?projectId=${projectId}`, {
40          headers: {
41            "Authorization": `Bearer ${bearerToken}`,
44
45        if (!response.ok) {
46          throw new Error(`Failed to fetch branches: ${response.statusText}`);
47        }
48
49        const data = await response.json();
50        const fetchedBranches = data.branches || [];
51        setBranches(fetchedBranches);
52
53        // Check if the stored branchId is valid for this project
54        const storedBranchIsValid = fetchedBranches.some((branch: Branch) => branch.id === branchId);
55
56        // Only set a new branchId if there isn't a valid one already stored
57        if (!storedBranchIsValid && fetchedBranches.length > 0) {
58          // If branches are loaded and there's a "main" branch, select it by default
59          const mainBranch = fetchedBranches.find((branch: Branch) => branch.name === "main");
60          if (mainBranch) {
61            setBranchId(mainBranch.id);
63          } else {
64            // Otherwise select the first branch
65            setBranchId(fetchedBranches[0].id);
66            setSelectedBranchName(fetchedBranches[0].name);
67          }
68        } else if (storedBranchIsValid) {
69          // Set the selected branch name based on the stored branchId
70          const selectedBranch = fetchedBranches.find((branch: Branch) => branch.id === branchId);
71          if (selectedBranch) {
72            setSelectedBranchName(selectedBranch.name);
74        }
75      } catch (error) {
76        console.error("Error fetching branches:", error);
77      } finally {
78        setIsLoadingBranches(false);
80    };
81
82    fetchBranches();
83  }, [projectId, bearerToken, branchId, setBranchId]);
84
105    // Refresh the branches list
106    if (projectId) {
107      const fetchBranches = async () => {
108        try {
109          const response = await fetch(`/api/project-branches?projectId=${projectId}`, {
110            headers: {
111              "Authorization": `Bearer ${bearerToken}`,
114
115          if (!response.ok) {
116            throw new Error(`Failed to fetch branches: ${response.statusText}`);
117          }
118
119          const data = await response.json();
120          const fetchedBranches = data.branches || [];
121          setBranches(fetchedBranches);
122
123          // Update the selected branch name
124          const selectedBranch = fetchedBranches.find((branch: Branch) => branch.id === newBranchId);
125          if (selectedBranch) {
126            setSelectedBranchName(selectedBranch.name);
127          }
128        } catch (error) {
129          console.error("Error fetching branches:", error);
130        }
131      };
132
133      fetchBranches();
134    }
135  };

1// Fetch project files from the backend
2export async function fetchProjectFiles(
3  { bearerToken, projectId, branchId }: { bearerToken: string; projectId: string; branchId?: string },
4) {
9  }
10
11  const response = await fetch(url.toString(), {
12    headers: {
13      "Authorization": "Bearer " + bearerToken,

ValTownForNotionhelpers.ts3 matches

@bradnoble•Updated 6 days ago

28    const origin = parsedUrl.origin;
29
30    // Fetch the HTML from the URL
31    const response = await fetch(url);
32    const html = await response.text();
33
62
63    // Verify the favicon exists
64    const faviconResponse = await fetch(faviconUrl, { method: "HEAD" });
65
66    if (!faviconResponse.ok) {

jeevessendDailyBrief.ts1 match

@brontojoris•Updated 1 week ago

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

jeevesNotebookView.tsx12 matches

@brontojoris•Updated 1 week ago

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

jeevesindex.ts2 matches

@brontojoris•Updated 1 week ago

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

jeeves.cursorrules5 matches

@brontojoris•Updated 1 week ago

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

jeevesApp.tsx17 matches

@brontojoris•Updated 1 week ago

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

300  }
301
302  // Fetch relevant memories using the utility function
303  const memories = await getRelevantMemories();
304

150  
151  try {
152    const tokenResponse = await fetch("https://oauth2.googleapis.com/token", {
153      method: "POST",
154      headers: { "Content-Type": "application/x-www-form-urlencoded" },
168    return tokenData.access_token;
169  } catch (error) {
170    console.error("OAuth Debug - Fetch Error:", error.message);
171    throw error;
172  }
181    const accessToken = await getGoogleAccessToken();
182    
183    // Fetch the list of available calendars
184    const calListUrl = "https://www.googleapis.com/calendar/v3/users/me/calendarList";
185    const calListResponse = await fetch(calListUrl, {
186      headers: {
187        "Authorization": `Bearer ${accessToken}`
190    
191    if (!calListResponse.ok) {
192      throw new Error(`Failed to fetch calendar list: ${await calListResponse.text()}`);
193    }
194    
210      
211      try {
212        // Fetch events for this specific calendar
213        const calendarEvents = await fetchCalendarEventsForCalendar(calendar.id, accessToken);
214        console.log(`Found ${calendarEvents.length} events in calendar "${calendar.summary}"`);
215        
223        allEvents = allEvents.concat(calendarEvents);
224      } catch (error) {
225        console.error(`Error fetching events for calendar ${calendar.summary}:`, error);
226      }
227    }
273}
274
275// Function to fetch events for a specific calendar
276async function fetchCalendarEventsForCalendar(calendarId: string, accessToken: string): Promise<CalendarEvent[]> {
277  // Get events for the next 30 days
278  const timeMin = new Date();
280  timeMax.setDate(timeMax.getDate() + 30);
281  
282  console.log(`Fetching events for calendar ${calendarId} from ${timeMin.toISOString()} to ${timeMax.toISOString()}`);
283  
284  const url = `https://www.googleapis.com/calendar/v3/calendars/${encodeURIComponent(calendarId)}/events?` + 
291    });
292  
293  const response = await fetch(url, {
294    headers: {
295      "Authorization": `Bearer ${accessToken}`
299  if (!response.ok) {
300    const error = await response.text();
301    throw new Error(`Failed to fetch calendar events: ${error}`);
302  }
303