Val Town Code SearchReturn to Val Town

1/** @jsxImportSource https://esm.sh/react@18.2.0 */
2import React, {
3  useState,
4  useEffect,
5  useCallback,
6  useMemo,
7} from "https://esm.sh/react@18.2.0";
8import { type Memory } from "../../shared/types.ts";
9
89  }, [fetchMemories]);
90
91  const handleAddMemory = async (e: React.FormEvent) => {
92    e.preventDefault();
93    if (!newMemoryText.trim()) return;
144  };
145
146  const handleUpdateMemory = async (e: React.FormEvent) => {
147    e.preventDefault();
148    if (!editingMemory || !editingMemory.text.trim()) return;

1/** @jsxImportSource https://esm.sh/react@18.2.0 */
2import { createRoot } from "https://esm.sh/react-dom@18.2.0/client";
3import { App } from "./components/App.tsx";
4

1/**
2 * @jsxImportSource https://esm.sh/react@18.2.0
3 */
4import { blob } from "https://esm.town/v/std/blob";

155- Current health goals and any medication reminders needed?
156
157Your goal is to collect this information naturally through conversation and store it as memories (as undated memories). Once you've gathered sufficient background information, you can conclude the intake process and transition to normal reactive chat.
158
159If the conversation is already past the intake stage, then analyze the message content and think about which memories might be worth creating based on the information provided.

199- **Storage Strategy:** Only use backend storage if explicitly required; prefer simple static client-side sites
200- For persistence, use Val Town SQLite or Blob storage with `import.meta.url` for keys/table names
201- **React Configuration:** When using React libraries, pin versions with `?deps=react@18.2.0,react-dom@18.2.0` and include the `@jsxImportSource` pragma
202- When facing client-side render issues, check if all React dependencies are pinned to the same version
203- **Styling:** Default to using TailwindCSS via `<script src="https://cdn.twind.style" crossorigin></script>` unless otherwise specified
204
262
263### Frontend Best Practices
264- Structure as a standard client-side React app
265- Use SVG for favicons (Val Town only supports text files)
266- Separate components into individual files
267- Access bootstrapped data from `window.__INITIAL_DATA__`
268- Use React 18.2.0 consistently in all imports and the `@jsxImportSource` pragma
269- Follow the React component pattern from the example project
270- Handle API calls properly with proper error catching
271
289   - Always run table creation before querying
290
2913. **React Configuration:**
292   - All React dependencies must be pinned to 18.2.0
293   - Always include `@jsxImportSource https://esm.sh/react@18.2.0` at the top of React files
294   - Rendering issues often come from mismatched React versions
295
2964. **File Handling:**

1/** @jsxImportSource https://esm.sh/react@18.2.0 */
2import React, {
3  useState,
4  useEffect,
5  useCallback,
6  useMemo,
7} from "https://esm.sh/react@18.2.0";
8import { type Memory } from "../../shared/types.ts";
9import { ASSETS, SCENE_POSITIONS, SOURCE_TYPES } from "./assets.ts";
165  }, [fetchMemories]);
166
167  const handleAddMemory = async (e: React.FormEvent) => {
168    e.preventDefault();
169    if (!newMemoryText.trim()) return;
220  };
221
222  const handleUpdateMemory = async (e: React.FormEvent) => {
223    e.preventDefault();
224    if (!editingMemory || !editingMemory.text.trim()) return;

1// Map Vote Tallying Function with Rate Limit Service Integration
2// This function counts emoji reactions and announces winners in a Hell Let Loose map vote
3import seedrandom from "https://esm.sh/seedrandom";
4import { DiscordRateLimitService } from "https://esm.town/v/ktodaz/Discord_Bot_Services/discord-rate-limit-service.tsx";
103}
104
105// Get emoji mapping to decode emoji reactions
106function getEmojiMapping() {
107  return {
219}
220
221// Get reactions for a specific message with rate limiting
222async function getMessageReactions(channelId: string, messageId: string, emoji: string) {
223  try {
224    const encodedEmoji = encodeURIComponent(emoji);
225    const routeKey = `/channels/${channelId}/messages/${messageId}/reactions`;
226
227    return rateLimitService.executeWithRateLimit(routeKey, async () => {
228      const endpoint = `/channels/${channelId}/messages/${messageId}/reactions/${encodedEmoji}?limit=100`;
229      const reactions = await discordRequest(endpoint);
230      return reactions;
231    });
232  } catch (error) {
233    console.error(`Error getting reactions for message ${messageId}:`, error);
234    return []; // Return empty array on error to continue processing
235  }
578      }
579
580      // Get all reactions on this message
581      const reactions = msg.reactions || [];
582
583      // Process each reaction type
584      for (const reaction of Object.values(reactions)) {
585        const emoji = reaction.emoji.name;
586
587        // Skip if this emoji is not in our mapping
592
593        const variant = emojiMapping[emoji];
594        console.log(`Processing: Embed: ${mapName} (${variant}), Reactions: ${reaction.count}`);
595
596        // Get users who reacted with this emoji - using rate limited function
597        const reactedUsers = await getMessageReactions(channelId, msg.id, emoji);
598        console.log(`Emote key ${variant}: ${reactedUsers.length} users`);
599
600        // Process each user's reaction
601        for (const user of reactedUsers) {
602          // Skip bot reactions
603          if (user.bot) continue;
604
623    const random = seedrandom(Date.now().toString());
624    const userVotes: UserVote[] = [];
625    const embedVariantReactionCounts: Record<string, number> = {};
626
627    // Process users in smaller batches to manage rate limits better
673        for (const vote of votes) {
674          const key = `${vote.embed.title} ${vote.variant}`;
675          embedVariantReactionCounts[key] = (embedVariantReactionCounts[key] || 0) + 1;
676        }
677      }
682
683    // Convert to array of MapVote objects
684    for (const [key, count] of Object.entries(embedVariantReactionCounts)) {
685      const [mapName, variant] = key.split(/\s(?=[^\s]+$)/); // Split at the last space
686      mapVotes.push({
695    // Handle ties with random shuffle (match C# implementation)
696    const randomVariants = seedrandom(Date.now().toString());
697    const sortedVotes = Object.entries(embedVariantReactionCounts)
698      .map(([key, count]) => {
699        const [mapName, variant] = key.split(/\s(?=[^\s]+$)/);

1/** @jsxImportSource https://esm.sh/react */
2import { renderToString } from "npm:react-dom/server";
3
4const notesStyle = {

101}
102
103// Add emoji reaction to message - RATE LIMITED VERSION
104async function addReaction(channelId: string, messageId: string, emoji: string) {
105  const routeKey = `/channels/${channelId}/messages/${messageId}/reactions`;
106
107  return rateLimitService.executeWithRateLimit(routeKey, async () => {
108    const url = `${API_BASE}/channels/${channelId}/messages/${messageId}/reactions/${emoji}/@me`;
109    const token = Deno.env.get("DISCORD_BOT_TOKEN");
110
123    if (!response.ok) {
124      let errorText = await response.text();
125      console.error(`Error adding reaction: Status ${response.status}, Body: ${errorText}`);
126      throw new Error(`Failed to add reaction: ${response.status}`);
127    }
128
129    // Successful reaction add
130    return true;
131  });
195        type: 0, // Role type
196        allow: "1024", // VIEW_CHANNEL, READ_MESSAGE_HISTORY
197        deny: "64", // ADD_REACTIONS
198      },
199      {
201        type: 0, // Role type
202        allow: "1024", // VIEW_CHANNEL, READ_MESSAGE_HISTORY
203        deny: "64", // ADD_REACTIONS
204      },
205      {
271}
272
273// Process variants for a map and add emoji reactions
274async function processMapVariants(messageId: string, channelId: string, map: MapInfo, variantOptions: any) {
275  const mapMetaVariants: string[] = [];
279  if (variantOptions.EnableDawn && map.MapDetails.Dawn) {
280    if (map.MapDetails.Dawn === "meta") {
281      console.log(`${map.MapName} Dawn variant is meta, not adding reaction`);
282      mapMetaVariants.push(`${map.MapName} Dawn`);
283      mapEnabledVariants.push("Dawn");
284    } else if (map.MapDetails.Dawn === "enabled") {
285      await addReaction(channelId, messageId, encodeURIComponent(EMOJIS.DAWN));
286      mapEnabledVariants.push("Dawn");
287    }
291  if (variantOptions.EnableDay && map.MapDetails.Day) {
292    if (map.MapDetails.Day === "meta") {
293      console.log(`${map.MapName} Day variant is meta, not adding reaction`);
294      mapMetaVariants.push(`${map.MapName} Day`);
295      mapEnabledVariants.push("Day");
296    } else if (map.MapDetails.Day === "enabled") {
297      await addReaction(channelId, messageId, encodeURIComponent(EMOJIS.DAY));
298      mapEnabledVariants.push("Day");
299    }
303  if (variantOptions.EnableDusk && map.MapDetails.Dusk) {
304    if (map.MapDetails.Dusk === "meta") {
305      console.log(`${map.MapName} Dusk variant is meta, not adding reaction`);
306      mapMetaVariants.push(`${map.MapName} Dusk`);
307      mapEnabledVariants.push("Dusk");
308    } else if (map.MapDetails.Dusk === "enabled") {
309      await addReaction(channelId, messageId, encodeURIComponent(EMOJIS.DUSK));
310      mapEnabledVariants.push("Dusk");
311    }
315  if (variantOptions.EnableNight && map.MapDetails.Night) {
316    if (map.MapDetails.Night === "meta") {
317      console.log(`${map.MapName} Night variant is meta, not adding reaction`);
318      mapMetaVariants.push(`${map.MapName} Night`);
319      mapEnabledVariants.push("Night");
320    } else if (map.MapDetails.Night === "enabled") {
321      await addReaction(channelId, messageId, encodeURIComponent(EMOJIS.NIGHT));
322      mapEnabledVariants.push("Night");
323    }
327  if (variantOptions.EnableFog && map.MapDetails.Fog) {
328    if (map.MapDetails.Fog === "meta") {
329      console.log(`${map.MapName} Fog variant is meta, not adding reaction`);
330      mapMetaVariants.push(`${map.MapName} Fog`);
331      mapEnabledVariants.push("Fog");
332    } else if (map.MapDetails.Fog === "enabled") {
333      await addReaction(channelId, messageId, encodeURIComponent(EMOJIS.FOG));
334      mapEnabledVariants.push("Fog");
335    }
339  if (variantOptions.EnableOvercast && map.MapDetails.Overcast) {
340    if (map.MapDetails.Overcast === "meta") {
341      console.log(`${map.MapName} Overcast variant is meta, not adding reaction`);
342      mapMetaVariants.push(`${map.MapName} Overcast`);
343      mapEnabledVariants.push("Overcast");
344    } else if (map.MapDetails.Overcast === "enabled") {
345      await addReaction(channelId, messageId, encodeURIComponent(EMOJIS.OVERCAST));
346      mapEnabledVariants.push("Overcast");
347    }
351  if (variantOptions.EnableRain && map.MapDetails.Rain) {
352    if (map.MapDetails.Rain === "meta") {
353      console.log(`${map.MapName} Rain variant is meta, not adding reaction`);
354      mapMetaVariants.push(`${map.MapName} Rain`);
355      mapEnabledVariants.push("Rain");
356    } else if (map.MapDetails.Rain === "enabled") {
357      await addReaction(channelId, messageId, encodeURIComponent(EMOJIS.RAIN));
358      mapEnabledVariants.push("Rain");
359    }
363  if (variantOptions.EnableSandstorm && map.MapDetails.Sandstorm) {
364    if (map.MapDetails.Sandstorm === "meta") {
365      console.log(`${map.MapName} Sandstorm variant is meta, not adding reaction`);
366      mapMetaVariants.push(`${map.MapName} Sandstorm`);
367      mapEnabledVariants.push("Sandstorm");
368    } else if (map.MapDetails.Sandstorm === "enabled") {
369      await addReaction(channelId, messageId, encodeURIComponent(EMOJIS.SAND));
370      mapEnabledVariants.push("Sandstorm");
371    }
375  if (variantOptions.EnableSnowstorm && map.MapDetails.Snowstorm) {
376    if (map.MapDetails.Snowstorm === "meta") {
377      console.log(`${map.MapName} Snowstorm variant is meta, not adding reaction`);
378      mapMetaVariants.push(`${map.MapName} Snowstorm`);
379      mapEnabledVariants.push("Snowstorm");
380    } else if (map.MapDetails.Snowstorm === "enabled") {
381      await addReaction(channelId, messageId, encodeURIComponent(EMOJIS.SNOW));
382      mapEnabledVariants.push("Snowstorm");
383    }
387}
388
389// Populate channel with map options and add reactions
390async function populateChannelWithMaps(
391  channel: any,
662    const initialMessage = await sendInitialEmbed(channel, initialEmbedData);
663
664    // Populate channel with map options and reactions
665    const { metaVariants, enabledVariants } = await populateChannelWithMaps(
666      channel,

luciaMagicLinkStarterApp.tsx3 matches

@stevekrouse•Updated 1 week ago

1/** @jsxImportSource https://esm.sh/react@18.2.0 */
2import { useState } from "https://esm.sh/react@18.2.0";
3
4export function App() {
6  return (
7    <div>
8      <h1>Val Town React + Hono Starter</h1>
9      I've been clicked <button onClick={() => setClicked((c) => c + 1)}>{clicked}</button> times
10    </div>