@solidjs/start 2.0.0-beta.1 → 2.0.0-beta.3

package/dist/config/index.js

@@ -0,0 +1,224 @@
+import { defu } from "defu";
+import { globSync } from "node:fs";
+import { extname, isAbsolute, join } from "node:path";
+import solid from "vite-plugin-solid";
+import { serverFunctionsPlugin } from "../directives/index.js";
+import { DEFAULT_EXTENSIONS, VIRTUAL_MODULES, VITE_ENVIRONMENTS } from "./constants.js";
+import { devServer } from "./dev-server.js";
+import { envPlugin } from "./env.js";
+import { SolidStartClientFileRouter, SolidStartServerFileRouter } from "./fs-router.js";
+import { fsRoutes } from "./fs-routes/index.js";
+import lazy from "./lazy.js";
+import { manifest } from "./manifest.js";
+import { parseIdQuery } from "./utils.js";
+const absolute = (path, root) => path ? (isAbsolute(path) ? path : join(root, path)) : path;
+export function solidStart(options) {
+    const start = defu(options ?? {}, {
+        appRoot: "./src",
+        routeDir: "./routes",
+        ssr: true,
+        devOverlay: true,
+        experimental: {
+            islands: false,
+        },
+        solid: {},
+        extensions: [],
+    });
+    const extensions = [...DEFAULT_EXTENSIONS, ...(start.extensions || [])];
+    const routeDir = join(start.appRoot, start.routeDir);
+    const root = process.cwd();
+    const appEntryPath = globSync(join(root, start.appRoot, "app.{j,t}sx"))[0];
+    if (!appEntryPath) {
+        throw new Error(`Could not find an app jsx/tsx entry in ${start.appRoot}.`);
+    }
+    const entryExtension = extname(appEntryPath);
+    const handlers = {
+        client: `${start.appRoot}/entry-client${entryExtension}`,
+        server: `${start.appRoot}/entry-server${entryExtension}`,
+    };
+    return [
+        // TODO (Alexis): check if the comment below is still relevant
+        //
+        // Must be placed after fsRoutes, as treeShake will remove the
+        // server fn exports added in by this plugin
+        serverFunctionsPlugin({
+            manifest: VIRTUAL_MODULES.serverFnManifest,
+            runtime: {
+                server: '@solidjs/start/fns/server',
+                client: '@solidjs/start/fns/client',
+            },
+            filter: options?.serverFunctions?.filter,
+        }),
+        {
+            name: "solid-start:config",
+            enforce: "pre",
+            configEnvironment(name) {
+                return {
+                    resolve: {
+                        // remove when https://github.com/solidjs/vite-plugin-solid/pull/228 is released
+                        externalConditions: ["solid", "node"],
+                    },
+                };
+            },
+            async config(_, env) {
+                const clientInput = [handlers.client];
+                if (env.command === "build") {
+                    const clientRouter = globalThis.ROUTERS.client;
+                    for (const route of await clientRouter.getRoutes()) {
+                        for (const [key, value] of Object.entries(route)) {
+                            if (value && key.startsWith("$") && !key.startsWith("$$")) {
+                                function toRouteId(route) {
+                                    return `${route.src}?${route.pick.map((p) => `pick=${p}`).join("&")}`;
+                                }
+                                clientInput.push(toRouteId(value));
+                            }
+                        }
+                    }
+                }
+                return {
+                    appType: "custom",
+                    build: { assetsDir: "_build/assets" },
+                    optimizeDeps: {
+                        // Suppress TS errors from Vite 7 types when configuring Vite 8's Rolldown
+                        ...{
+                            rolldownOptions: {
+                                transform: {
+                                    jsx: "react",
+                                },
+                            },
+                        },
+                    },
+                    environments: {
+                        [VITE_ENVIRONMENTS.client]: {
+                            consumer: "client",
+                            build: {
+                                write: true,
+                                manifest: true,
+                                outDir: "dist/client",
+                                rollupOptions: {
+                                    input: clientInput,
+                                    treeshake: true,
+                                    preserveEntrySignatures: "exports-only",
+                                },
+                            },
+                        },
+                        [VITE_ENVIRONMENTS.server]: {
+                            consumer: "server",
+                            build: {
+                                ssr: true,
+                                write: true,
+                                manifest: true,
+                                copyPublicDir: false,
+                                rollupOptions: {
+                                    input: "~/entry-server.tsx",
+                                },
+                                outDir: "dist/server",
+                                commonjsOptions: {
+                                    include: [/node_modules/],
+                                },
+                            },
+                        },
+                    },
+                    resolve: {
+                        alias: {
+                            "@solidjs/start/server/entry": handlers.server,
+                            "~": join(process.cwd(), start.appRoot),
+                            ...(!start.ssr
+                                ? {
+                                    "@solidjs/start/server": "@solidjs/start/server/spa",
+                                    "@solidjs/start/client": "@solidjs/start/client/spa",
+                                }
+                                : {}),
+                        },
+                        // Depending on the package manager and dependency structure Vite externalizes @solidjs/start
+                        // This makes sure that @solidjs/start goes through the Vite build process
+                        //
+                        // h3 and cookie-es must be bundled as well: if they stay external, the server build
+                        // emits bare imports that nitro later re-resolves from the project root, where package
+                        // managers like yarn may have hoisted the older major versions required by nitropack
+                        // and unstorage (h3 v1 / cookie-es v1) instead of the versions @solidjs/start needs
+                        // (see https://github.com/solidjs/solid-start/issues/2101
+                        // and https://github.com/solidjs/solid-start/issues/2178)
+                        noExternal: ["@solidjs/start", "h3", "cookie-es"],
+                    },
+                    define: {
+                        "import.meta.env.MANIFEST": `globalThis.MANIFEST`,
+                        "import.meta.env.START_SSR": JSON.stringify(start.ssr),
+                        // Use JSON.stringify so backslashes on Windows are escaped and
+                        // esbuild receives a valid JS string literal for the define value
+                        "import.meta.env.START_APP_ENTRY": JSON.stringify(appEntryPath),
+                        "import.meta.env.START_CLIENT_ENTRY": JSON.stringify(handlers.client),
+                        "import.meta.env.START_DEV_OVERLAY": JSON.stringify(start.devOverlay),
+                        "import.meta.env.SEROVAL_MODE": JSON.stringify(start.serialization?.mode || "json"),
+                    },
+                    builder: {
+                        sharedPlugins: true,
+                        async buildApp(builder) {
+                            const client = builder.environments[VITE_ENVIRONMENTS.client];
+                            const server = builder.environments[VITE_ENVIRONMENTS.server];
+                            if (!client)
+                                throw new Error("Client environment not found");
+                            if (!server)
+                                throw new Error("SSR environment not found");
+                            if (!client.isBuilt)
+                                await builder.build(client);
+                            if (!server.isBuilt)
+                                await builder.build(server);
+                        },
+                    },
+                };
+            },
+        },
+        manifest(start),
+        fsRoutes({
+            routers: {
+                client: new SolidStartClientFileRouter({
+                    dir: absolute(routeDir, root),
+                    extensions,
+                }),
+                ssr: new SolidStartServerFileRouter({
+                    dir: absolute(routeDir, root),
+                    extensions,
+                    dataOnly: !start.ssr,
+                }),
+            },
+        }),
+        lazy(),
+        envPlugin(options?.env),
+        {
+            name: "solid-start:virtual-modules",
+            async resolveId(id) {
+                const { filename, query } = parseIdQuery(id);
+                let base;
+                if (filename === VIRTUAL_MODULES.clientEntry)
+                    base = handlers.client;
+                if (filename === VIRTUAL_MODULES.serverEntry)
+                    base = handlers.server;
+                if (filename === VIRTUAL_MODULES.app)
+                    base = appEntryPath;
+                if (base) {
+                    let id = (await this.resolve(base))?.id;
+                    if (!id)
+                        return;
+                    if (query.size > 0)
+                        id += `?${query.toString()}`;
+                    return id;
+                }
+            },
+        },
+        {
+            name: "solid-start:capture-client-bundle",
+            enforce: "post",
+            generateBundle(options, bundle) {
+                globalThis.START_CLIENT_BUNDLE = bundle;
+                globalThis.START_CLIENT_OUT_DIR = options.dir;
+            },
+        },
+        devServer(),
+        solid({
+            ...start.solid,
+            ssr: true,
+            extensions: extensions.map(ext => `.${ext}`),
+        }),
+    ];
+}

package/dist/config/lazy.d.ts

@@ -0,0 +1,3 @@
+import type { PluginOption } from "vite";
+declare const lazy: () => PluginOption;
+export default lazy;

package/dist/config/lazy.js

@@ -0,0 +1,114 @@
+import babel from "@babel/core";
+import * as t from "@babel/types";
+import { sep as osSep } from "node:path";
+import { basename, relative, sep } from "node:path/posix";
+import { VITE_ENVIRONMENTS } from "./constants.js";
+const idTransform = (id) => {
+    return {
+        visitor: {
+            Program(path) {
+                path.node.body.unshift(t.exportNamedDeclaration(t.variableDeclaration("const", [
+                    t.variableDeclarator(t.identifier("id$$"), t.stringLiteral(id)),
+                ])));
+            },
+        },
+    };
+};
+const importTransform = () => {
+    return {
+        visitor: {
+            ImportDeclaration(path) {
+                if (path.node.source.value !== "solid-js")
+                    return;
+                path.traverse({
+                    ImportSpecifier(subPath) {
+                        if (subPath.node.local.name !== "lazy")
+                            return;
+                        subPath.remove();
+                        path.insertAfter(t.importDeclaration([t.importSpecifier(t.identifier("lazy"), t.identifier("lazy"))], t.stringLiteral("@solidjs/start/server")));
+                    },
+                });
+            },
+        },
+    };
+};
+const fileEndingRegex = /(ts|js)x(\?.*)?$/;
+const lazy = () => {
+    const cwd = process.cwd().replaceAll(osSep, sep);
+    /**
+     * Maps module ids to their client-specific shared chunk names.
+     * Modules in shared chunks need to find their assets via the chunk name, instead of their module id.
+     *
+     * Vite includes assets of such modules in the manifest via the chunk name:
+     * https://github.com/vitejs/vite/blob/4be37a8389c67873880f826b01fe40137e1c29a7/packages/vite/src/node/plugins/manifest.ts#L179
+     * https://github.com/vitejs/vite/blob/4be37a8389c67873880f826b01fe40137e1c29a7/packages/vite/src/node/plugins/manifest.ts#L319
+     *
+     * Rollup occassionally creates shared chunks automatically,
+     * but they can also be manually created by the user via:
+     * https://rollupjs.org/configuration-options/#output-manualchunks
+     *
+     * More infos on Rollup's logic:
+     * https://github.com/rollup/rollup/issues/3772#issuecomment-689955168
+     */
+    const sharedChunkNames = {};
+    return {
+        name: "solid-lazy-css",
+        enforce: "pre",
+        generateBundle(_, bundle) {
+            if (this.environment.name !== VITE_ENVIRONMENTS.client)
+                return;
+            for (const chunk of Object.values(bundle)) {
+                if (chunk.type !== "chunk" || !chunk.isDynamicEntry || chunk.facadeModuleId)
+                    continue;
+                // Has to follow Vites implementation:
+                // https://github.com/vitejs/vite/blob/4be37a8389c67873880f826b01fe40137e1c29a7/packages/vite/src/node/plugins/manifest.ts#L179
+                const chunkName = `_${basename(chunk.fileName)}`;
+                for (const id of chunk.moduleIds) {
+                    sharedChunkNames[id] = chunkName;
+                }
+            }
+        },
+        async transform(src, id) {
+            if (this.environment.name !== VITE_ENVIRONMENTS.server)
+                return;
+            if (!id.match(fileEndingRegex))
+                return;
+            // The transformed files either import "lazy" or css files
+            // Therefore we skip, if the src doesn't have any import
+            if (src.indexOf("import") === -1)
+                return;
+            if (id.includes("entry-server"))
+                return;
+            const plugins = [];
+            const hasDefaultExport = src.indexOf("export default") !== -1;
+            if (hasDefaultExport) {
+                const localId = relative(cwd, id);
+                const chunkName = sharedChunkNames[id];
+                plugins.push(idTransform(chunkName ?? localId));
+            }
+            const hasLazy = src.indexOf("lazy(") !== -1;
+            if (hasLazy)
+                plugins.push(importTransform());
+            if (!plugins.length) {
+                return;
+            }
+            const transformed = await babel.transformAsync(src, {
+                plugins,
+                parserOpts: {
+                    plugins: ["jsx", "typescript"],
+                },
+                filename: basename(id),
+                ast: false,
+                sourceMaps: true,
+                configFile: false,
+                babelrc: false,
+                sourceFileName: id,
+            });
+            if (!transformed?.code)
+                return;
+            const { code, map } = transformed;
+            return { code, map };
+        },
+    };
+};
+export default lazy;

package/dist/config/manifest.d.ts

@@ -0,0 +1,3 @@
+import { type PluginOption } from "vite";
+import { type SolidStartOptions } from "./index.ts";
+export declare function manifest(start: SolidStartOptions): PluginOption;

package/dist/config/manifest.js

@@ -0,0 +1,109 @@
+import fs from "node:fs";
+import path from "node:path";
+import { version as viteVersion } from "vite";
+import { fileURLToPath } from "node:url";
+import { findStylesInModuleGraph } from "../server/collect-styles.js";
+import { VIRTUAL_MODULES } from "./constants.js";
+import { wrapId } from "./vite-utils.js";
+export function manifest(start) {
+    let devServer = undefined;
+    return {
+        name: "solid-start:manifest-plugin",
+        enforce: "pre",
+        configureServer(server) {
+            devServer = server;
+        },
+        async resolveId(id) {
+            if (id === VIRTUAL_MODULES.clientViteManifest)
+                return `\0${VIRTUAL_MODULES.clientViteManifest}`;
+            if (id === VIRTUAL_MODULES.getClientManifest)
+                return this.resolve(fileURLToPath(new URL("../server/manifest/client-manifest", import.meta.url)));
+            if (id === VIRTUAL_MODULES.getManifest) {
+                return this.environment.config.consumer === "client"
+                    ? this.resolve(fileURLToPath(new URL("../server/manifest/client-manifest", import.meta.url)))
+                    : this.resolve(fileURLToPath(new URL("../server/manifest/ssr-manifest", import.meta.url)));
+            }
+            if (id === VIRTUAL_MODULES.middleware) {
+                if (start.middleware)
+                    return await this.resolve(start.middleware);
+                return `\0${VIRTUAL_MODULES.middleware}`;
+            }
+        },
+        async load(id) {
+            if (id === `\0${VIRTUAL_MODULES.clientViteManifest}`) {
+                let clientViteManifest;
+                if (this.environment.config.command === "serve") {
+                    clientViteManifest = {};
+                }
+                else {
+                    const entry = Object.values(globalThis.START_CLIENT_BUNDLE).find(v => "isEntry" in v && v.isEntry);
+                    if (!entry)
+                        throw new Error("No client entry found");
+                    let rawManifest;
+                    const viteMajor = parseInt(viteVersion.split('.')[0], 10);
+                    const manifestKey = Object.keys(globalThis.START_CLIENT_BUNDLE).find(k => k.endsWith("manifest.json"));
+                    if (manifestKey && viteMajor < 8) {
+                        const manifestAsset = globalThis.START_CLIENT_BUNDLE[manifestKey];
+                        rawManifest = manifestAsset.source;
+                    }
+                    else {
+                        try {
+                            const appRoot = start.appRoot || "./src";
+                            let outDir = ".solid-start/client";
+                            if (devServer?.environments?.client?.config?.build?.outDir) {
+                                outDir = devServer.environments.client.config.build.outDir;
+                            }
+                            else if (this.environment?.config?.build?.outDir && this.environment?.config?.consumer === "client") {
+                                outDir = this.environment.config.build.outDir;
+                            }
+                            else if (globalThis.START_CLIENT_OUT_DIR) {
+                                outDir = globalThis.START_CLIENT_OUT_DIR;
+                            }
+                            const manifestPath = path.resolve(appRoot, "..", outDir, ".vite/manifest.json");
+                            rawManifest = fs.readFileSync(manifestPath, "utf-8");
+                        }
+                        catch (e) {
+                            throw new Error(`Manifest asset not found in bundle and could not be read from disk. Keys: ${Object.keys(globalThis.START_CLIENT_BUNDLE).join(", ")}. Error: ${e}`);
+                        }
+                    }
+                    if (!rawManifest) {
+                        throw new Error("Failed to extract or read raw manifest.");
+                    }
+                    clientViteManifest = JSON.parse(rawManifest);
+                }
+                return `export const clientViteManifest = ${JSON.stringify(clientViteManifest)};`;
+            }
+            else if (id === `\0${VIRTUAL_MODULES.middleware}`)
+                return "export default {};";
+            else if (id.startsWith("/@manifest")) {
+                if (this.environment.mode !== "dev")
+                    throw new Error("@manifest queries are only allowed in dev");
+                const [urlPath, query] = id.split("?");
+                const target = id.split("/")[2];
+                const params = new URLSearchParams(query);
+                if (!urlPath || !query)
+                    return;
+                if (urlPath.endsWith("assets")) {
+                    const id = params.get("id");
+                    if (!id) {
+                        throw new Error("Missing id to get assets.");
+                    }
+                    // Client env does not have css dependencies in mod.transformResult
+                    // Aalways use ssr env instead, to prevent hydration mismatches
+                    const env = devServer.environments["ssr"];
+                    const styles = await findStylesInModuleGraph(env, id);
+                    const cssAssets = Object.entries(styles).map(([key, value]) => `{
+						tag: "style",
+						attrs: {
+							type: "text/css",
+							"data-vite-dev-id": "${wrapId(key)}",
+							"data-vite-ref": "0",
+						},
+						children: () => import("${wrapId(value)}?inline").then(mod => mod.default),
+					}`);
+                    return `export default [${cssAssets.join(",")}]`;
+                }
+            }
+        },
+    };
+}

package/dist/config/utils.d.ts

@@ -0,0 +1,4 @@
+export declare function parseIdQuery(id: string): {
+    filename: string;
+    query: URLSearchParams;
+};

package/dist/config/utils.js

@@ -0,0 +1,6 @@
+export function parseIdQuery(id) {
+    if (!id.includes("?"))
+        return { filename: id, query: new URLSearchParams() };
+    const [filename, rawQuery] = id.split(`?`, 2);
+    return { filename, query: new URLSearchParams(rawQuery) };
+}

package/dist/config/vite-utils.d.ts

@@ -0,0 +1,21 @@
+import type { DevEnvironment, Rollup } from "vite";
+export declare function cleanUrl(url: string): string;
+export declare const FS_PREFIX = "/@fs/";
+export declare const VALID_ID_PREFIX = "/@id/";
+export declare const NULL_BYTE_PLACEHOLDER = "__x00__";
+export declare function normalizeResolvedIdToUrl(environment: DevEnvironment, url: string, resolved: Rollup.PartialResolvedId): string;
+/**
+ * Inspired by:
+ * https://github.com/withastro/astro/blob/fddde5fad81007795eb263c7fd0cea096b8e2cba/packages/astro/src/core/util.ts#L115
+ * https://github.com/vitejs/vite/blob/130e7181a55c524383c63bbfb1749d0ff7185cad/packages/vite/src/shared/utils.ts#L11
+ */
+export declare function wrapId(id: string): string;
+export declare function unwrapId(id: string): string;
+export declare function normalizeViteImportAnalysisUrl(environment: DevEnvironment, id: string): string;
+export declare function withTrailingSlash(path: string): string;
+export declare function splitFileAndPostfix(path: string): {
+    file: string;
+    postfix: string;
+};
+export declare function slash(p: string): string;
+export declare function injectQuery(url: string, queryToInject: string): string;

package/dist/config/vite-utils.js

@@ -0,0 +1,85 @@
+import fs from "node:fs";
+import path from "node:path";
+const postfixRE = /[?#].*$/;
+export function cleanUrl(url) {
+    return url.replace(postfixRE, "");
+}
+export const FS_PREFIX = `/@fs/`;
+export const VALID_ID_PREFIX = `/@id/`;
+export const NULL_BYTE_PLACEHOLDER = `__x00__`;
+const NULL_BYTE_REGEX = /^\0/;
+export function normalizeResolvedIdToUrl(environment, url, resolved) {
+    const root = environment.config.root;
+    const depsOptimizer = environment.depsOptimizer;
+    // normalize all imports into resolved URLs
+    // e.g. `import 'foo'` -> `import '/@fs/.../node_modules/foo/index.js'`
+    if (resolved.id.startsWith(withTrailingSlash(root))) {
+        // in root: infer short absolute path from root
+        url = resolved.id.slice(root.length);
+    }
+    else if (depsOptimizer?.isOptimizedDepFile(resolved.id) ||
+        // vite-plugin-react isn't following the leading \0 virtual module convention.
+        // This is a temporary hack to avoid expensive fs checks for React apps.
+        // We'll remove this as soon we're able to fix the react plugins.
+        (resolved.id !== "/@react-refresh" &&
+            path.isAbsolute(resolved.id) &&
+            fs.existsSync(cleanUrl(resolved.id)))) {
+        // an optimized deps may not yet exists in the filesystem, or
+        // a regular file exists but is out of root: rewrite to absolute /@fs/ paths
+        url = path.posix.join(FS_PREFIX, resolved.id);
+    }
+    else {
+        url = resolved.id;
+    }
+    // if the resolved id is not a valid browser import specifier,
+    // prefix it to make it valid. We will strip this before feeding it
+    // back into the transform pipeline
+    if (url[0] !== "." && url[0] !== "/") {
+        url = wrapId(resolved.id);
+    }
+    return url;
+}
+/**
+ * Inspired by:
+ * https://github.com/withastro/astro/blob/fddde5fad81007795eb263c7fd0cea096b8e2cba/packages/astro/src/core/util.ts#L115
+ * https://github.com/vitejs/vite/blob/130e7181a55c524383c63bbfb1749d0ff7185cad/packages/vite/src/shared/utils.ts#L11
+ */
+export function wrapId(id) {
+    return id.replace(NULL_BYTE_REGEX, `${VALID_ID_PREFIX}${NULL_BYTE_PLACEHOLDER}`);
+}
+export function unwrapId(id) {
+    return id.startsWith(VALID_ID_PREFIX)
+        ? id.slice(VALID_ID_PREFIX.length).replace(NULL_BYTE_PLACEHOLDER, "\0")
+        : id;
+}
+export function normalizeViteImportAnalysisUrl(environment, id) {
+    let url = normalizeResolvedIdToUrl(environment, id, { id });
+    // https://github.com/vitejs/vite/blob/c18ce868c4d70873406e9f7d1b2d0a03264d2168/packages/vite/src/node/plugins/importAnalysis.ts#L416
+    if (environment.config.consumer === "client") {
+        const mod = environment.moduleGraph.getModuleById(id);
+        if (mod && mod.lastHMRTimestamp > 0) {
+            url = injectQuery(url, `t=${mod.lastHMRTimestamp}`);
+        }
+    }
+    return url;
+}
+export function withTrailingSlash(path) {
+    if (path[path.length - 1] !== "/") {
+        return `${path}/`;
+    }
+    return path;
+}
+export function splitFileAndPostfix(path) {
+    const file = cleanUrl(path);
+    return { file, postfix: path.slice(file.length) };
+}
+const windowsSlashRE = /\\/g;
+export function slash(p) {
+    return p.replace(windowsSlashRE, "/");
+}
+const isWindows = typeof process !== "undefined" && process.platform === "win32";
+export function injectQuery(url, queryToInject) {
+    const { file, postfix } = splitFileAndPostfix(url);
+    const normalizedFile = isWindows ? slash(file) : file;
+    return `${normalizedFile}?${queryToInject}${postfix[0] === "?" ? `&${postfix.slice(1)}` : /* hash only */ postfix}`;
+}

package/dist/directives/bubble-function-declaration.d.ts

@@ -0,0 +1,3 @@
+import type * as babel from "@babel/core";
+import * as t from "@babel/types";
+export declare function bubbleFunctionDeclaration(path: babel.NodePath<t.FunctionDeclaration>): void;

package/dist/directives/bubble-function-declaration.js

@@ -0,0 +1,23 @@
+import * as t from "@babel/types";
+export function bubbleFunctionDeclaration(path) {
+    const decl = path.node;
+    // Check if declaration is FunctionDeclaration
+    if (decl.id) {
+        const block = (path.findParent(current => current.isBlockStatement()) ||
+            path.scope.getProgramParent().path);
+        if (path.parentPath.isExportNamedDeclaration()) {
+            path.parentPath.replaceWith(t.exportNamedDeclaration(undefined, [t.exportSpecifier(decl.id, decl.id)]));
+        }
+        else if (path.parentPath.isExportDefaultDeclaration()) {
+            path.replaceWith(decl.id);
+        }
+        else {
+            path.remove();
+        }
+        const [tmp] = block.unshiftContainer("body", t.variableDeclaration("const", [
+            t.variableDeclarator(decl.id, t.functionExpression(decl.id, decl.params, decl.body, decl.generator, decl.async)),
+        ]));
+        block.scope.registerDeclaration(tmp);
+        tmp.skip();
+    }
+}

package/dist/directives/compile.d.ts

@@ -0,0 +1,9 @@
+import * as babel from "@babel/core";
+import { type StateContext } from "./plugin.ts";
+export interface CompileResult {
+    valid: boolean;
+    code: string;
+    map: babel.BabelFileResult["map"];
+}
+export type CompileOptions = Omit<StateContext, "count" | "hash" | "imports" | "valid">;
+export declare function compile(id: string, code: string, options: CompileOptions): Promise<CompileResult>;

package/dist/directives/compile.js

@@ -0,0 +1,40 @@
+import * as babel from "@babel/core";
+import path from "node:path";
+import { directivesPlugin } from "./plugin.js";
+import xxHash32 from "./xxhash32.js";
+export async function compile(id, code, options) {
+    const context = {
+        ...options,
+        valid: false,
+        hash: xxHash32(id).toString(16),
+        count: 0,
+        imports: new Map(),
+    };
+    const pluginOption = [directivesPlugin, context];
+    const plugins = [
+        "jsx",
+    ];
+    if (/\.[mc]?tsx?$/i.test(id)) {
+        plugins.push("typescript");
+    }
+    const result = await babel.transformAsync(code, {
+        plugins: [pluginOption],
+        parserOpts: {
+            plugins,
+        },
+        filename: path.basename(id),
+        ast: false,
+        sourceMaps: true,
+        configFile: false,
+        babelrc: false,
+        sourceFileName: id,
+    });
+    if (result) {
+        return {
+            valid: context.valid,
+            code: result.code || "",
+            map: result.map,
+        };
+    }
+    throw new Error("invariant");
+}

package/dist/directives/generate-unique-name.d.ts

@@ -0,0 +1,3 @@
+import type * as babel from "@babel/core";
+import * as t from "@babel/types";
+export declare function generateUniqueName(path: babel.NodePath, name: string): t.Identifier;