toiljs 0.0.115 → 0.0.117

package/src/compiler/ssg.ts

@@ -1,177 +0,0 @@
-/**
- * Build-time SSG for dynamic routes. After the client bundle is written, this loads each dynamic
- * route that exports `generateStaticParams`, enumerates its concrete URLs, runs the route's
- * `generateMetadata` per URL, and bakes a `<url>/index.html` (so JS-less crawlers get per-page tags)
- * plus a `sitemap.xml` entry. Opt-in: a route without `generateStaticParams` is untouched, and the
- * whole pass is skipped when no such route exists or `seo` is unconfigured. Build-only.
- *
- * Runs from `build()` (not the prerender Vite plugin) so it can reuse `createViteConfig` without the
- * `vite.ts` <-> `prerender.ts` import cycle; it spins up a short-lived SSR server to load route source.
- */
-import fs from 'node:fs';
-import path from 'node:path';
-
-import { createServer } from 'vite';
-
-import { type ResolvedToilConfig } from './config.js';
-import { extractStaticMetadata, loadTypeScript } from './prerender.js';
-import { scanRoutes } from './routes.js';
-import { injectSeoHtml, joinUrl, type LlmsPage, llmsTxt, routeSeo, sitemapXml } from './seo.js';
-import { createViteConfig } from './vite.js';
-
-/** Reads a string field off a metadata record, or undefined. */
-function metaString(meta: Record<string, unknown> | null, key: string): string | undefined {
-    const value = meta?.[key];
-    return typeof value === 'string' ? value : undefined;
-}
-
-type StaticParams = Record<string, string | string[]>;
-
-interface RouteModule {
-    generateStaticParams?: () => StaticParams[] | Promise<StaticParams[]>;
-    generateMetadata?: (args: {
-        params: StaticParams;
-        searchParams: URLSearchParams;
-        data: unknown;
-    }) => unknown;
-    loader?: (args: { params: StaticParams; searchParams: URLSearchParams }) => unknown;
-    metadata?: Record<string, unknown>;
-}
-
-/** Substitutes `:param` / `*catch-all` segments in a route pattern with concrete param values. */
-export function fillPattern(pattern: string, params: StaticParams): string {
-    return pattern.replace(/[:*]([A-Za-z0-9_]+)/g, (_m, name: string) => {
-        const value = params[name] as string | string[] | undefined;
-        if (Array.isArray(value)) return value.join('/');
-        return value ?? '';
-    });
-}
-
-/** Coerces an unknown module export to a typed Metadata-ish record, or null. */
-function asMetadata(value: unknown): Record<string, unknown> | null {
-    return typeof value === 'object' && value !== null ? (value as Record<string, unknown>) : null;
-}
-
-/**
- * Pre-renders every dynamic route that opts in via `generateStaticParams`. Bakes per-URL HTML into
- * `outDir` and rewrites `sitemap.xml` with the generated URLs. Returns the list of generated URLs.
- */
-export async function prerenderStaticParams(cfg: ResolvedToilConfig): Promise<string[]> {
-    if (!cfg.seo) return [];
-    const outDir = path.resolve(cfg.root, cfg.outDir);
-    // Prefer the clean shell stashed by the prerender plugin (no per-route SEO baked in); fall back
-    // to the built index.html.
-    const stashed = path.join(cfg.toilDir, 'shell.html');
-    const shellPath = fs.existsSync(stashed) ? stashed : path.join(outDir, 'index.html');
-    if (!fs.existsSync(shellPath)) return [];
-
-    const allRoutes = scanRoutes(cfg.routesAbsDir);
-    const dynamic = allRoutes.filter(
-        (r) => r.slot === undefined && !r.intercept && /[:*]/.test(r.pattern),
-    );
-    if (dynamic.length === 0) return [];
-
-    const shell = fs.readFileSync(shellPath, 'utf8');
-    const server = await createServer({
-        ...(await createViteConfig(cfg)),
-        server: { middlewareMode: true, hmr: false },
-        appType: 'custom',
-        logLevel: 'silent',
-    });
-
-    const baseUrl = cfg.seo.url;
-    const generated: string[] = [];
-    const dynamicPages: LlmsPage[] = [];
-    const warn = (msg: string): void => {
-        process.stderr.write(`  toil: SSG ${msg}\n`);
-    };
-    try {
-        for (const route of dynamic) {
-            let mod: RouteModule;
-            try {
-                mod = (await server.ssrLoadModule(route.file)) as RouteModule;
-            } catch (err) {
-                warn(
-                    `skipped ${route.pattern} (${err instanceof Error ? err.message : String(err)})`,
-                );
-                continue;
-            }
-            if (typeof mod.generateStaticParams !== 'function') continue;
-            const paramSets = await mod.generateStaticParams();
-            for (const params of paramSets) {
-                const url = fillPattern(route.pattern, params);
-                // Containment guard: a param value with `..`/separators could make `url` resolve the
-                // output path outside `outDir`. Resolve the target up front and skip anything that
-                // escapes, so a (possibly externally-derived) param can't clobber files elsewhere.
-                const target = path.join(outDir, url.replace(/^\//, ''), 'index.html');
-                const outRoot = path.resolve(outDir);
-                const absTarget = path.resolve(target);
-                if (absTarget !== outRoot && !absTarget.startsWith(outRoot + path.sep)) {
-                    warn(`skipped ${route.pattern}: params escape outDir (${url})`);
-                    continue;
-                }
-                let metadata: Record<string, unknown> | null = null;
-                try {
-                    if (typeof mod.generateMetadata === 'function') {
-                        const searchParams = new URLSearchParams();
-                        const data =
-                            typeof mod.loader === 'function'
-                                ? await mod.loader({ params, searchParams })
-                                : undefined;
-                        metadata = asMetadata(
-                            await mod.generateMetadata({ params, searchParams, data }),
-                        );
-                    } else if (mod.metadata) {
-                        metadata = asMetadata(mod.metadata);
-                    }
-                } catch (err) {
-                    warn(
-                        `metadata failed for ${url} (${err instanceof Error ? err.message : String(err)})`,
-                    );
-                }
-                const html = injectSeoHtml(shell, routeSeo(cfg.seo, metadata, url));
-                fs.mkdirSync(path.dirname(target), { recursive: true });
-                fs.writeFileSync(target, html);
-                generated.push(url);
-                dynamicPages.push({
-                    title: metaString(metadata, 'title') ?? url,
-                    url: baseUrl !== undefined ? joinUrl(baseUrl, url) : url,
-                    description: metaString(metadata, 'description'),
-                });
-            }
-        }
-    } finally {
-        await server.close();
-    }
-
-    if (generated.length > 0) {
-        const sitemap = sitemapXml(cfg.seo, allRoutes, generated);
-        if (sitemap) fs.writeFileSync(path.join(outDir, 'sitemap.xml'), sitemap);
-        process.stdout.write(
-            `  ✓ prerendered ${String(generated.length)} dynamic route${generated.length === 1 ? '' : 's'}\n`,
-        );
-    }
-
-    // Rewrite llms.txt with the full page index: every static route's resolved title/description plus
-    // the enumerated dynamic pages, so AI crawlers get the whole site, not just the static paths.
-    if (baseUrl !== undefined) {
-        const ts = await loadTypeScript(cfg.root);
-        const staticPages: LlmsPage[] = allRoutes
-            .filter((r) => r.slot === undefined && !r.intercept && !/[:*]/.test(r.pattern))
-            .map((r): LlmsPage => {
-                const meta = ts ? extractStaticMetadata(ts, r.file) : null;
-                return {
-                    title: metaString(meta, 'title') ?? (r.pattern === '/' ? 'Home' : r.pattern),
-                    url: joinUrl(baseUrl, r.pattern),
-                    description: metaString(meta, 'description'),
-                };
-            });
-        const pages = [...staticPages, ...dynamicPages];
-        if (pages.length > 0) {
-            const llms = llmsTxt(cfg.seo, allRoutes, pages);
-            if (llms) fs.writeFileSync(path.join(outDir, 'llms.txt'), llms);
-        }
-    }
-
-    return generated;
-}

package/src/compiler/ssr-codegen.ts

@@ -1,85 +0,0 @@
-/**
- * Build-time codegen of the AssemblyScript surface a route's guest `render`
- * uses. From the extracted holes (see `template.ts`) this emits:
- *
- *   - a `Slot` enum (hole name -> stable numeric id, the SAME ids the host
- *     `.slots` manifest carries), so host and guest agree by construction; and
- *   - the coherence `HASH` (32 bytes) compiled into the guest and echoed in
- *     every values envelope; the host 500s on a mismatch (deploy skew).
- *
- * The render BODY is authored against `SlotValues` (the typed, hand-writable
- * API). A route's `render(req)` derives its data from the request/edge and
- * fills the slots:
- *
- * ```ts
- * import { Request } from 'toiljs/server/runtime';
- * import { SlotValues } from 'toiljs/server/runtime/ssr/slots';
- * import { Slot, HASH } from './_ssr/u_name.slots';
- *
- * export function renderUName(req: Request): SlotValues {
- *   const v = new SlotValues(HASH);
- *   v.setText(Slot.username, pathParam(req, 'name'));
- *   v.setRaw(Slot.bio, bio);
- *   const rows = new HtmlBuilder();
- *   for (let i = 0; i < posts.length; i++) rows.raw('<li>').text(posts[i]).raw('</li>');
- *   v.setRepeat(Slot.posts, rows);
- *   return v;
- * }
- * ```
- *
- * Generating that body automatically from the JSX-subset bindings is a later
- * phase; the typed enum + hash here are what make a hand-written or generated
- * body coherent with the deployed template.
- */
-
-import type { SlotRecord } from './template.js';
-import { assignSlotIds } from './template.js';
-
-/** Emit a `StaticArray<u8>` literal of the 32 hash bytes. */
-function hashLiteral(hash: Buffer): string {
-    const bytes = Array.from(hash.values())
-        .map((b) => `0x${b.toString(16).padStart(2, '0')}`)
-        .join(', ');
-    return `[${bytes}]`;
-}
-
-/** A slot name is a valid AS enum member iff it is a bare identifier; anything
- * else (e.g. a hyphenated id) is rejected so the generated module can't break
- * or smuggle code. */
-function isIdent(name: string): boolean {
-    return /^[A-Za-z_$][\w$]*$/.test(name);
-}
-
-/**
- * Generate the `<route>.slots.ts` AssemblyScript module: the `Slot` enum and
- * the `HASH` constant. `slots` is the top-level slot list from
- * `extractFromHtml`; ids are assigned in document order to match the host
- * `.slots` manifest written by `encodeSlots`.
- */
-export function generateSlotsModule(routeName: string, slots: SlotRecord[], hash: Buffer): string {
-    if (hash.length !== 32) throw new Error('toil ssr: coherence hash must be 32 bytes');
-    const ids = assignSlotIds(slots);
-    const members: string[] = [];
-    for (const [name, id] of ids) {
-        if (!isIdent(name)) {
-            throw new Error(
-                `toil ssr: hole id "${name}" in route "${routeName}" is not a valid identifier ` +
-                    `(use [A-Za-z_][\\w]*) so it can be a Slot enum member`,
-            );
-        }
-        members.push(`    ${name} = ${id},`);
-    }
-    return `// AUTO-GENERATED by toil (edge SSR). Do not edit.
-// Route: ${routeName}. Slot ids match the deployed .slots manifest; HASH is the
-// coherence hash the host checks against the template (deploy-skew guard).
-
-/** Stable hole ids for this route's template. */
-export enum Slot {
-${members.join('\n')}
-}
-
-/** Coherence hash (32 bytes) baked into the guest and echoed in every values
- * envelope; the host rejects a response whose hash != the deployed template. */
-export const HASH: StaticArray<u8> = ${hashLiteral(hash)};
-`;
-}