tachyon-dom 0.1.0

package/dist/vite.js

@@ -0,0 +1,426 @@
+import { cp, mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { createNodeFetchHandler } from "./adapters/node.js";
+import { defineApp, generateTachyonModuleTypes, pagesFromRouteFiles, } from "./app.js";
+import { resolveHtmlWhitespacePolicy } from "./html-whitespace.js";
+import { generateScriptOnlyModule, transformSfcScript } from "./compiler/sfc.js";
+import { generateClientModule, generateServerModule, generateServerStreamModule } from "./compiler/index.js";
+import { diagnoseTachyonSfc, diagnosticFromCompilerError, formatDiagnostic } from "./diagnostics.js";
+import { createFileRouteManifest } from "./router.js";
+import { scanFileRoutes } from "./router-node.js";
+import { err, ok } from "./result.js";
+import { appendInlineSourceMap, createSourceMap, shouldEmitSourceMap } from "./source-map.js";
+const configuredAppHtmlWhitespace = (options) => {
+    if (options.htmlWhitespace !== undefined)
+        return resolveHtmlWhitespacePolicy(options.htmlWhitespace);
+    if (options.minifyHtml !== undefined)
+        return options.minifyHtml ? "normalize-tags" : "preserve-tags";
+    return undefined;
+};
+export const loadRouteApp = async ({ routesDir, ...definition }) => {
+    const absoluteRoutesDir = resolve(routesDir);
+    const manifest = await scanFileRoutes(absoluteRoutesDir);
+    const pageFiles = manifest.filter((route) => route.kind === "template").map((route) => route.file);
+    const pages = await Promise.all(pagesFromRouteFiles(pageFiles, {
+        rootDir: absoluteRoutesDir,
+        ...(definition.templateWhitespace ? { templateWhitespace: definition.templateWhitespace } : {}),
+    }).map(async (page) => ({
+        ...page,
+        template: await readFile(page.file, "utf8"),
+    })));
+    return defineApp({ ...definition, pages });
+};
+const cloudflarePagesWorkerSource = (options) => {
+    const exportName = options.exportName ?? "renderRequest";
+    const fallthroughStatuses = options.fallthroughStatuses ?? [404];
+    const runtimeEnvKeys = options.runtimeEnvKeys ?? [];
+    return `import * as entry from ${JSON.stringify(pathToFileURL(options.entry).href)};
+
+const renderer = entry[${JSON.stringify(exportName)}] ?? entry.default;
+const fallthroughStatuses = new Set(${JSON.stringify(fallthroughStatuses)});
+const runtimeEnvKeys = ${JSON.stringify(runtimeEnvKeys)};
+
+const runtimeEnvFor = (env) => Object.fromEntries(runtimeEnvKeys.map((key) => [key, env?.[key]]));
+
+export default {
+  async fetch(request, env = {}, ctx) {
+    const assets = env && typeof env === "object" ? env.ASSETS : undefined;
+    if (assets && typeof assets.fetch === "function") {
+      const assetResponse = await assets.fetch(request);
+      if (!fallthroughStatuses.has(assetResponse.status)) {
+        return assetResponse;
+      }
+    }
+    if (typeof renderer !== "function") {
+      return new Response("Cloudflare Pages renderer export was not found.", { status: 500 });
+    }
+    return renderer(request, env, ctx, runtimeEnvFor(env));
+  },
+};
+`;
+};
+export const packageCloudflarePages = async (options) => {
+    const tempDir = await mkdtemp(join(tmpdir(), "tachyon-cloudflare-pages-"));
+    try {
+        await rm(options.outDir, { recursive: true, force: true });
+        await mkdir(options.outDir, { recursive: true });
+        if (options.assetsDir) {
+            await cp(options.assetsDir, options.outDir, { recursive: true, force: true });
+        }
+        const workerEntry = join(tempDir, "worker-entry.js");
+        await writeFile(workerEntry, cloudflarePagesWorkerSource(options));
+        const vite = await import("vite");
+        await vite.build({
+            configFile: false,
+            logLevel: "silent",
+            publicDir: false,
+            ssr: { noExternal: true },
+            build: {
+                emptyOutDir: false,
+                minify: false,
+                outDir: options.outDir,
+                sourcemap: false,
+                ssr: true,
+                target: "es2022",
+                lib: {
+                    entry: workerEntry,
+                    formats: ["es"],
+                    fileName: () => "_worker.js",
+                },
+                rollupOptions: {
+                    output: {
+                        entryFileNames: "_worker.js",
+                    },
+                },
+            },
+        });
+        return ok({ outDir: options.outDir, workerPath: join(options.outDir, "_worker.js") });
+    }
+    catch (error) {
+        return err(error instanceof Error ? error.message : String(error));
+    }
+    finally {
+        await rm(tempDir, { recursive: true, force: true });
+    }
+};
+const codeForTarget = (target, template, reactive, scriptOnly, defaultScopeName) => {
+    if (scriptOnly) {
+        return generateScriptOnlyModule(target);
+    }
+    if (target === "server") {
+        return generateServerModule(template);
+    }
+    if (target === "stream") {
+        return generateServerStreamModule(template);
+    }
+    return generateClientModule(template, { reactive, ...(defaultScopeName ? { defaultScopeName } : {}) });
+};
+const cleanId = (id) => id.split("?", 1)[0] ?? id;
+const queryForId = (id) => new URLSearchParams(id.split("?")[1] ?? "");
+const targetForId = (id, fallback) => {
+    const query = queryForId(id);
+    if (query.has("server")) {
+        return "server";
+    }
+    if (query.has("stream")) {
+        return "stream";
+    }
+    if (query.has("client")) {
+        return "client";
+    }
+    return fallback;
+};
+const isEntryRequest = (id) => queryForId(id).has("entry");
+const shouldIgnoreQueryRequest = (id) => {
+    const query = queryForId(id);
+    return query.has("raw") || query.has("url");
+};
+const declarationSourceFor = (source, id) => {
+    if (!queryForId(id).has("raw") || !source.trimStart().startsWith("export default")) {
+        return source;
+    }
+    const match = /^\s*export\s+default\s+("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')\s*;?\s*$/s.exec(source);
+    if (!match?.[1])
+        return source;
+    if (match[1].startsWith('"'))
+        return JSON.parse(match[1]);
+    return match[1].slice(1, -1).replace(/\\'/g, "'").replace(/\\\\/g, "\\");
+};
+const entryCodeFor = (id) => {
+    const moduleId = cleanId(id);
+    const query = queryForId(id);
+    const mountName = query.get("mount") ?? "mount";
+    return [
+        `import { reportHydrationDiagnostics as __tachyonReportHydrationDiagnostics } from "tachyon-dom/runtime/hydrate";`,
+        `import * as module from ${JSON.stringify(moduleId)};`,
+        `export * from ${JSON.stringify(moduleId)};`,
+        `export default module;`,
+        `const root = typeof document === "undefined" ? null : document.querySelector(${JSON.stringify(query.get("root") ?? "#app")});`,
+        `const mount = module[${JSON.stringify(mountName)}] ?? module.mountApp ?? module.mountWebExample ?? module.mountAuthTodoExample ?? module.mountFullAppExample ?? module.default;`,
+        `if (root instanceof HTMLElement && typeof mount === "function") {`,
+        `  void mount(root);`,
+        `}`,
+        `const __tachyonHydrationIds = (module.hydrationBoundaries ?? []).map((boundary) => boundary && typeof boundary === "object" && boundary.idKind !== "expression" && typeof boundary.id === "string" ? boundary.id : undefined).filter((id) => typeof id === "string");`,
+        `if (root instanceof HTMLElement && import.meta.hot && __tachyonHydrationIds.length > 0) {`,
+        `  queueMicrotask(() => __tachyonReportHydrationDiagnostics(root, __tachyonHydrationIds, { hot: import.meta.hot }));`,
+        `}`,
+    ].join("\n");
+};
+const shouldLogRequests = (options) => options === undefined || options === true || (typeof options === "object" && options.enabled !== false);
+const requestLogPath = (url, includeQuery) => {
+    if (!url) {
+        return "/";
+    }
+    const parsed = new URL(url, "http://tachyon.local");
+    return includeQuery ? `${parsed.pathname}${parsed.search}` : parsed.pathname;
+};
+export const tachyonDom = (options = {}) => {
+    const include = options.include ?? /\.(?:td|tachyon(?:\.html)?)$/;
+    const target = options.target ?? "client";
+    let command = "serve";
+    let mode = "development";
+    let configResolved = false;
+    let rootDir;
+    return {
+        name: "tachyon-dom",
+        enforce: "pre",
+        configResolved(config) {
+            command = config.command;
+            mode = config.mode;
+            configResolved = true;
+            rootDir = typeof config.root === "string" ? config.root : undefined;
+        },
+        configureServer(server) {
+            if (!shouldLogRequests(options.requestLog)) {
+                return;
+            }
+            const log = typeof options.requestLog === "object" && options.requestLog.logger
+                ? options.requestLog.logger
+                : (message) => server.config.logger.info(message, { timestamp: true });
+            server.middlewares.use((request, response, next) => {
+                const startedAt = performance.now();
+                const method = request.method ?? "GET";
+                const path = requestLogPath(request.url, typeof options.requestLog === "object" && options.requestLog.includeQuery === true);
+                response.once("finish", () => {
+                    const durationMs = Math.max(0, Math.round(performance.now() - startedAt));
+                    log(`${method} ${path} ${response.statusCode} ${durationMs}ms`);
+                });
+                next();
+            });
+        },
+        async transform(source, id) {
+            if (include.test(cleanId(id)) && !queryForId(id).has("url") && !isEntryRequest(id)) {
+                const declarationOutput = options.declarationOutput === false
+                    ? undefined
+                    : typeof options.declarationOutput === "function"
+                        ? options.declarationOutput(cleanId(id))
+                        : configResolved && rootDir && cleanId(id).startsWith(rootDir)
+                            ? `${cleanId(id)}.d.ts`
+                            : undefined;
+                if (declarationOutput) {
+                    const declarationSource = declarationSourceFor(source, id);
+                    const diagnostic = diagnoseTachyonSfc(declarationSource);
+                    if (!diagnostic.ok) {
+                        this.error(formatDiagnostic(diagnostic.error, cleanId(id)));
+                    }
+                    const declarations = generateTachyonModuleTypes(declarationSource);
+                    if (!declarations.ok) {
+                        this.error(declarations.error);
+                    }
+                    await mkdir(dirname(declarationOutput), { recursive: true });
+                    await writeFile(declarationOutput, declarations.value);
+                }
+            }
+            if (shouldIgnoreQueryRequest(id)) {
+                return null;
+            }
+            if (isEntryRequest(id)) {
+                return {
+                    code: entryCodeFor(id),
+                    map: null,
+                };
+            }
+            if (!include.test(cleanId(id))) {
+                return null;
+            }
+            const resolvedTarget = targetForId(id, target);
+            const result = diagnoseTachyonSfc(source, {
+                whitespace: options.templateWhitespace ?? "preserve",
+            });
+            if (!result.ok) {
+                this.error(formatDiagnostic(result.error, id));
+            }
+            const script = transformSfcScript(result.value.descriptor.script);
+            if (!script.ok) {
+                this.error(formatDiagnostic(diagnosticFromCompilerError(source, script.error), id));
+            }
+            const code = `${script.value.code}${codeForTarget(resolvedTarget, result.value.template, options.reactive === true, result.value.scriptOnly, resolvedTarget === "client" && script.value.defaultScopeName ? script.value.defaultScopeName : undefined)}`;
+            const emitSourceMap = shouldEmitSourceMap({
+                sourcemap: options.sourcemap,
+                productionSourceMap: options.productionSourceMap,
+                command,
+                mode,
+            });
+            if (!emitSourceMap && (!options.onSourceMap || options.sourcemap === false)) {
+                return {
+                    code,
+                    map: null,
+                };
+            }
+            const map = createSourceMap(source, id, `${id}.js`);
+            await options.onSourceMap?.({ id, code, map, source });
+            return {
+                code: emitSourceMap ? appendInlineSourceMap(code, map) : code,
+                map: null,
+            };
+        },
+        load(id) {
+            if (shouldIgnoreQueryRequest(id)) {
+                return null;
+            }
+            if (!include.test(cleanId(id)) || !isEntryRequest(id)) {
+                return null;
+            }
+            return entryCodeFor(id);
+        },
+    };
+};
+export const tachyonDomRoutes = (options) => {
+    const virtualId = options.virtualId ?? "virtual:tachyon-dom/routes";
+    const resolvedVirtualId = `\0${virtualId}`;
+    const routes = () => [
+        ...(options.routes ?? []),
+        ...(options.files && options.rootDir
+            ? createFileRouteManifest(options.files, { rootDir: options.rootDir }).map((route) => ({
+                id: route.id,
+                path: route.path,
+                module: route.file,
+            }))
+            : []),
+    ];
+    return {
+        name: "tachyon-dom-routes",
+        resolveId(id) {
+            return id === virtualId ? resolvedVirtualId : null;
+        },
+        load(id) {
+            if (id !== resolvedVirtualId) {
+                return null;
+            }
+            const modules = routes()
+                .map((route) => `{ id: ${JSON.stringify(route.id)}, path: ${JSON.stringify(route.path)}, module: () => import(${JSON.stringify(route.module)}) }`)
+                .join(", ");
+            return `export const routes = [${modules}];\nexport const manifest = routes.map(({ id, path }) => ({ id, path }));\n`;
+        },
+        handleHotUpdate(context) {
+            const changed = routes().filter((route) => route.module === context.file);
+            if (changed.length === 0) {
+                return;
+            }
+            const module = context.server.moduleGraph.getModuleById(resolvedVirtualId);
+            if (!module) {
+                return;
+            }
+            context.server.moduleGraph.invalidateModule(module);
+            context.server.ws.send({
+                type: "custom",
+                event: "tachyon-dom:routes-update",
+                data: { routeIds: changed.map((route) => route.id) },
+            });
+            return [module, ...context.modules];
+        },
+    };
+};
+const prefixed = (prefix, fileName) => `${prefix}/${fileName}`;
+const viteInternalExactPaths = ["/@vite/client", "/@react-refresh", "/__vite_ping"];
+const viteInternalPrefixes = ["/@id/", "/@fs/", "/src/", "/node_modules/"];
+export const isViteSsrPassthroughRequest = (url) => viteInternalExactPaths.includes(url.pathname) ||
+    viteInternalPrefixes.some((prefix) => url.pathname.startsWith(prefix));
+const resolveClientScript = async (request, clientScript) => {
+    if (typeof clientScript === "function") {
+        return clientScript(request);
+    }
+    return clientScript;
+};
+export const createTachyonSsrMiddleware = (options) => {
+    const { fetch, clientScript, bypass = isViteSsrPassthroughRequest, ...adapterOptions } = options;
+    const handler = createNodeFetchHandler({
+        ...adapterOptions,
+        fetch: async (request) => {
+            const resolvedClientScript = await resolveClientScript(request, clientScript);
+            return fetch(request, resolvedClientScript ? { clientScript: resolvedClientScript } : {});
+        },
+    });
+    return (request, response, next) => {
+        let url;
+        try {
+            url = new URL(request.url ?? "/", "http://tachyon.local");
+        }
+        catch {
+            next();
+            return;
+        }
+        if (bypass(url, request)) {
+            next();
+            return;
+        }
+        void handler(request, response).catch((error) => next(error));
+    };
+};
+export const tachyonSsr = (options) => ({
+    name: "tachyon-dom-ssr",
+    configureServer(server) {
+        const { staticAssets = { rootDir: server.config.publicDir, basePath: "/", fallthroughOnNotFound: true }, ...rest } = options;
+        server.middlewares.use(createTachyonSsrMiddleware({
+            ...rest,
+            ...(staticAssets === false ? {} : { staticAssets }),
+        }));
+    },
+});
+export const tachyonApp = (app, options = {}) => {
+    const configuredWhitespace = configuredAppHtmlWhitespace(options);
+    const whitespaceFor = (mode) => configuredWhitespace ?? (mode === "development" ? "preserve-tags" : "normalize-tags");
+    return {
+        name: "tachyon-dom-app",
+        configureServer(server) {
+            server.middlewares.use((request, response, next) => {
+                const page = app.pageForPath(new URL(request.url ?? "/", "http://tachyon.local").pathname);
+                if (!page) {
+                    next();
+                    return;
+                }
+                response.statusCode = 200;
+                response.setHeader("Content-Type", "text/html; charset=utf-8");
+                response.end(app.renderDocument(page.path, {
+                    assets: {
+                        scripts: [options.appScript ?? `${page.assetPrefix ?? "."}/main.ts`],
+                        styles: [`${page.assetPrefix ?? "."}/styles.css`],
+                    },
+                    whitespace: whitespaceFor("development"),
+                }));
+            });
+        },
+        generateBundle(_outputOptions, bundle) {
+            const entry = Object.values(bundle).find((item) => item.type === "chunk" && item.isEntry);
+            const cssFiles = Object.values(bundle).flatMap((item) => item.type === "asset" && item.fileName.endsWith(".css") ? [item.fileName] : []);
+            for (const page of app.pages) {
+                const prefix = page.assetPrefix ?? ".";
+                const assets = {
+                    scripts: entry && entry.type === "chunk" ? [prefixed(prefix, entry.fileName)] : [],
+                    styles: cssFiles.map((fileName) => prefixed(prefix, fileName)),
+                };
+                this.emitFile({
+                    fileName: page.fileName,
+                    source: app.renderDocument(page.path, {
+                        assets,
+                        whitespace: whitespaceFor("production"),
+                    }),
+                    type: "asset",
+                });
+            }
+        },
+    };
+};
+export default tachyonDom;