Val Town Code SearchReturn to Val Town

9 * Added 25 small prompt phrases below the generate button to assist in website generation.
10 * A welcome message from the Mayor of val.town is now included.
11 * When submitted, it now iterates step by step in a tree structure on features for main functionality.
12 * Sub-functionalities are now listed under the main functionality to help describe it better.
13 */
14/** @jsxImportSource https://esm.sh/react */
124    "serverless",
125    "aws-sdk",
126    "azure-functions",
127  ],
128  database: [
270];
271
272function App() {
273  const [idea, setIdea] = useState("");
274  const [prompt, setPrompt] = useState("");
294    }
295
296    const subFunctionalities = generateSubFunctionalities(idea);
297
298    const generatedPrompt = `Create a Hono application for Deno with the following features:
2991. Main functionality: ${idea}
300   Sub-functionalities:
301   ${subFunctionalities.map(sub => `   - ${sub}`).join("\n")}
3022. Incorporate Hono features:
303   ${features.hono.map(feature => `- ${feature}`).join("\n   ")}
330      "Initialize project structure",
331      "Set up Hono router",
332      "Implement main functionality logic",
333      "Add database integration",
334      "Implement authentication system",
342  };
343
344  const generateSubFunctionalities = (mainIdea: string) => {
345    // This is a simple example. In a real-world scenario, you might use AI or a more sophisticated algorithm
346    const commonSubFunctionalities = [
347      "User authentication and authorization",
348      "Data persistence and retrieval",
352    ];
353
354    const specificSubFunctionalities = mainIdea.split(" ")
355      .filter(word => word.length > 3)
356      .map(word => `${word.charAt(0).toUpperCase() + word.slice(1)} management`);
357
358    return [...new Set([...commonSubFunctionalities, ...specificSubFunctionalities])].slice(0, 5);
359  };
360
516}
517
518function client() {
519  createRoot(document.getElementById("root")).render(<App />);
520}
524}
525
526async function server(request: Request): Promise<Response> {
527  return new Response(
528    `

21];
22
23function App() {
24  const [idea, setIdea] = useState("");
25  const [prompt, setPrompt] = useState("");
81}
82
83function client() {
84  createRoot(document.getElementById("root")).render(<App />);
85}
89}
90
91async function server(request: Request): Promise<Response> {
92  const url = new URL(request.url);
93

12const app = new Hono();
13
14function App() {
15  const [page, setPage] = React.useState('home');
16
53}
54
55function HomePage() {
56  return (
57    <div>
62}
63
64function AboutPage() {
65  return (
66    <div>
71}
72
73function ServicesPage() {
74  return (
75    <div>
86}
87
88function client() {
89  createRoot(document.getElementById("root")).render(<App />);
90}

3import { rssFeeds } from "https://www.val.town/v/cdnclass/scrawnyLavenderThrush/rssFeeds";
4
5export async function pollRSSFeeds({ lastRunAt }: Interval) {
6  return Promise.all(
7    Object.entries(rssFeeds).map(async ([name, url]) => {

8import _ from "npm:lodash@4";
9
10async function main(req: Request): Promise<Response> {
11  const { readable, writable } = new TransformStream();
12  const writer = writable.getWriter();
20        <script>
21          // Scroll to the bottom of the page when the page changes.
22          (new MutationObserver(function (mutationsList, observer) {
23            window.scrollTo({ left: 0, top: document.body.scrollHeight, behavior: "instant" });
24          })).observe(document, { childList: true, characterData: true, subtree: true });
47            Your response should start with \`\`\`ts and end with \`\`\`, so full code fences.
48            There should be no comments like "more content here", it should be complete and directly runnable.
49            The val should have an "export default async function main". The val should return a valid HTML website.
50            Prefer using Tailwind. Put frontend functions in a <script> tag, using dangerouslySetInnerHTML. Don't use Hono. Don't use Response.redirect.
51            `.replace("\n", " "),
52          },

2 * This val creates a Postman-like interface for testing HTTP requests directly in the browser.
3 * It uses React for the UI and the Fetch API to make requests.
4 * The server function serves the HTML and handles the API requests.
5 */
6
9import { createRoot } from "https://esm.sh/react-dom/client";
10
11function App() {
12  const [url, setUrl] = useState('https://jsonplaceholder.typicode.com/posts/1');
13  const [method, setMethod] = useState('GET');
94}
95
96function client() {
97  createRoot(document.getElementById("root")).render(<App />);
98}
102}
103
104async function server(request: Request): Promise<Response> {
105  const url = new URL(request.url);
106

8
9// Server-side only code
10export default async function server(request: Request): Promise<Response> {
11  const { sqlite } = await import("https://esm.town/v/stevekrouse/sqlite");
12  const SCHEMA_VERSION = 1

37// });
38
39function parseResultSet<T>(row: ResultSet): T[] {
40  return row.rows.map((r) => Object.fromEntries(r.map((c, i) => [row.columns[i], c]))) as T[];
41}
51};
52
53function diffCircles(array1: Circle[], array2: Circle[]): Circle[] {
54  const changes: Circle[] = [];
55
74
75  const drag = (() => {
76    function dragstarted() {
77      d3.select(this).attr("stroke", "black");
78    }
79
80    function dragged(event, d) {
81      d3.select(this).raise().attr("cx", d.x = event.x).attr("cy", d.y = event.y);
82    }
83
84    function dragended() {
85      const x = d3.select(this).attr("cx");
86      const y = d3.select(this).attr("cy");
105    .call(drag)
106    .on("click", clicked);
107  function clicked(event, d) {
108    if (event.defaultPrevented) return; // dragged
109

10import { createRoot } from "https://esm.sh/react-dom/client";
11
12function App() {
13  const [image, setImage] = useState(null);
14  const [text, setText] = useState("Enter text here");
178}
179
180function client() {
181  createRoot(document.getElementById("root")).render(<App />);
182}
186}
187
188async function server(request: Request): Promise<Response> {
189  return new Response(`
190    <html>

1import Anthropic from "npm:@anthropic-ai/sdk@0.24.3";
2
3export default async function(req: Request): Promise<Response> {
4  if (req.method === "OPTIONS") {
5    return new Response(null, {