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

package/CHANGELOG.md

@@ -1,5 +1,38 @@
 # @solidjs/start
 
+## 2.0.0-alpha.3
+
+### Minor Changes
+
+- 798b285: Updated dependencies.
+- f6f0452: seroval json mode
+- d4be1b6: Add new directives plugin with shorter function IDs and inner declaration support
+- b9c4ade: feat: add `env:*` runtime environment variables support
+
+### Patch Changes
+
+- ff9607c: import DevEnvironment and Rollup as type from vite
+- 6da636b: The server function directives runtime is now internally accessed via package.json exports instead of relative paths, fixing inconsistencies in the file resolution. Also the server functions file inclusion/exclusion patterns can now be configured in the start plugin options via `serverFunctions`.
+- 2885905: fix: clone request headers in single-flight to avoid mutating immutable headers
+- abe3979: reload ssr server when new route files are created in dev
+- 7c288f6: Sanitize Location header value in streaming redirect script
+- 6c83886: update seroval to 1.5.4
+- 9d5d783: Add support for Vite 8 asset manifest loading
+
+## 2.0.0-alpha.2
+
+### Minor Changes
+
+- 10bf932: Fix path resolution on Windows
+- 40d5a27: fix onBeforeResponse
+- 9201e71: fix text/html missing when ssr is false
+- a9cd2cc: add `vite preview` support
+
+### Patch Changes
+
+- 7077a49: Fixed CSS from shared chunks not being collected via the chunk name.
+- a620eeb: Fixed virtual module CSS not being collected in vite dev.
+
 ## 2.0.0-alpha.1
 
 ### Patch Changes

package/dist/config/constants.d.ts

@@ -5,7 +5,7 @@ export declare const VIRTUAL_MODULES: {
     readonly getClientManifest: "solid-start:get-client-manifest";
     readonly getManifest: "solid-start:get-manifest";
     readonly middleware: "solid-start:middleware";
-    readonly serverFnManifest: "solidstart:server-fn-manifest";
+    readonly serverFnManifest: "solid-start:server-fn-manifest";
     readonly clientEntry: "solid-start:client-entry";
     readonly serverEntry: "solid-start:server-entry";
     readonly app: "solid-start:app";

package/dist/config/constants.js

@@ -5,7 +5,7 @@ export const VIRTUAL_MODULES = {
     getClientManifest: "solid-start:get-client-manifest",
     getManifest: "solid-start:get-manifest",
     middleware: "solid-start:middleware",
-    serverFnManifest: "solidstart:server-fn-manifest",
+    serverFnManifest: "solid-start:server-fn-manifest",
     clientEntry: "solid-start:client-entry",
     serverEntry: "solid-start:server-entry",
     app: "solid-start:app",

package/dist/config/dev-server.js

@@ -1,3 +1,11 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
 import { NodeRequest, sendNodeResponse } from "srvx/node";
 import { isRunnableDevEnvironment, } from "vite";
 import { VITE_ENVIRONMENTS } from "./constants.js";
@@ -5,6 +13,16 @@ export function devServer() {
     return [
         {
             name: "solid-start-dev-server",
+            configurePreviewServer(server) {
+                return () => {
+                    server.middlewares.use(async (req, res) => {
+                        res.setHeader("content-encoding", "identity");
+                        const webReq = new NodeRequest({ req, res });
+                        const def = await import(__rewriteRelativeImportExtension(process.cwd() + "/dist/server/entry-server.js", true));
+                        sendNodeResponse(res, await def.default.fetch(webReq));
+                    });
+                };
+            },
             configureServer(viteDevServer) {
                 globalThis.VITE_DEV_SERVER = viteDevServer;
                 return async () => {

package/dist/config/env.d.ts

@@ -0,0 +1,19 @@
+import { type Plugin } from "vite";
+declare const LOADERS: {
+    node: string;
+    "cloudflare-workers": string;
+    "netlify-edge": string;
+};
+export interface EnvPluginOptions {
+    server?: {
+        runtime?: keyof typeof LOADERS | (string & {});
+        load?: (mode: string) => Record<string, string>;
+        prefix?: string;
+    };
+    client?: {
+        load?: (mode: string) => Record<string, string>;
+        prefix?: string;
+    };
+}
+export declare function envPlugin(options?: EnvPluginOptions): Plugin;
+export {};

package/dist/config/env.js

@@ -0,0 +1,81 @@
+import { loadEnv } from "vite";
+const LOADERS = {
+    node: `export default key => process.env[key];`,
+    "cloudflare-workers": `import { env } from 'cloudflare:workers';export default key => env[key];`,
+    "netlify-edge": `export default key => Netlify.env.get(key);`,
+};
+const SERVER_ENV = "env:server";
+const CLIENT_ENV = "env:client";
+const SERVER_RUNTIME_ENV = `${SERVER_ENV}/runtime`;
+const SERVER_RUNTIME_LOADER = `${SERVER_RUNTIME_ENV}/loader`;
+const DEFAULT_SERVER_PREFIX = "SERVER_";
+const DEFAULT_CLIENT_PREFIX = "CLIENT_";
+const SERVER_ONLY_MODULE = `throw new Error('Attempt to load server-only environment variables in client runtime.');`;
+const SERVER_RUNTIME_CODE = `import load from '${SERVER_RUNTIME_LOADER}';
+
+export default new Proxy({}, {
+  get(_, key) {
+    return load(key);
+  },
+})`;
+function convertObjectToModule(object) {
+    let result = "";
+    for (const key in object) {
+        result += `export const ${key} = ${JSON.stringify(object[key])};`;
+    }
+    return result;
+}
+export function envPlugin(options) {
+    const currentOptions = options ?? {};
+    let env;
+    const serverPrefix = currentOptions.server?.prefix ?? DEFAULT_SERVER_PREFIX;
+    const clientPrefix = currentOptions.client?.prefix ?? DEFAULT_CLIENT_PREFIX;
+    const runtime = options?.server?.runtime ?? "node";
+    const runtimeCode = runtime in LOADERS ? LOADERS[runtime] : runtime;
+    return {
+        name: "solid-start:env",
+        enforce: "pre",
+        configResolved(config) {
+            env = config.mode !== "production" ? "development" : "production";
+        },
+        resolveId(id) {
+            if (id === SERVER_ENV ||
+                id === CLIENT_ENV ||
+                id === SERVER_RUNTIME_ENV ||
+                id === SERVER_RUNTIME_LOADER) {
+                return id;
+            }
+            return undefined;
+        },
+        load(id, opts) {
+            if (id === SERVER_ENV) {
+                if (!opts?.ssr) {
+                    return SERVER_ONLY_MODULE;
+                }
+                const vars = currentOptions.server?.load
+                    ? currentOptions.server.load(env)
+                    : loadEnv(env, '.', serverPrefix);
+                return convertObjectToModule(vars);
+            }
+            if (id === CLIENT_ENV) {
+                const vars = currentOptions.client?.load
+                    ? currentOptions.client.load(env)
+                    : loadEnv(env, '.', clientPrefix);
+                return convertObjectToModule(vars);
+            }
+            if (id === SERVER_RUNTIME_LOADER) {
+                if (!opts?.ssr) {
+                    return SERVER_ONLY_MODULE;
+                }
+                return runtimeCode;
+            }
+            if (id === SERVER_RUNTIME_ENV) {
+                if (!opts?.ssr) {
+                    return SERVER_ONLY_MODULE;
+                }
+                return SERVER_RUNTIME_CODE;
+            }
+            return undefined;
+        },
+    };
+}

package/dist/config/fs-routes/fs-watcher.js

@@ -1,3 +1,4 @@
+import { VITE_ENVIRONMENTS } from "../constants.js";
 import { moduleId } from "./index.js";
 function setupWatcher(watcher, routes) {
     watcher.on("unlink", path => routes.removeRoute(path));
@@ -8,29 +9,22 @@ function createRoutesReloader(server, routes, environment) {
     routes.addEventListener("reload", handleRoutesReload);
     return () => routes.removeEventListener("reload", handleRoutesReload);
     function handleRoutesReload() {
-        if (environment === "ssr") {
-            // Handle server environment HMR reload
-            const serverEnv = server.environments.server;
-            if (serverEnv && serverEnv.moduleGraph) {
-                const mod = serverEnv.moduleGraph.getModuleById(moduleId);
-                if (mod) {
-                    const seen = new Set();
-                    serverEnv.moduleGraph.invalidateModule(mod, seen);
-                }
-            }
+        const envName = environment === "ssr" ? VITE_ENVIRONMENTS.server : VITE_ENVIRONMENTS.client;
+        const devEnv = server.environments[envName];
+        if (!devEnv?.moduleGraph)
+            return;
+        const mod = devEnv.moduleGraph.getModuleById(moduleId);
+        if (mod) {
+            const seen = new Set();
+            devEnv.moduleGraph.invalidateModule(mod, seen);
         }
-        else {
-            // Handle client environment HMR reload
-            const { moduleGraph } = server;
-            const mod = moduleGraph.getModuleById(moduleId);
+        if (environment !== "ssr") {
             if (mod) {
-                const seen = new Set();
-                moduleGraph.invalidateModule(mod, seen);
-                server.reloadModule(mod);
+                devEnv.reloadModule(mod);
+            }
+            else if (devEnv.hot) {
+                devEnv.hot.send({ type: "full-reload" });
             }
-        }
-        if (!server.hot) {
-            server.ws.send({ type: "full-reload" });
         }
     }
 }

package/dist/config/fs-routes/index.js

@@ -43,8 +43,8 @@ export function fsRoutes({ routers }) {
                         const buildId = `${v.src}?${v.pick.map((p) => `pick=${p}`).join("&")}`;
                         return {
                             src: relative(root, buildId),
-                            build: isBuild ? `_$() => import(/* @vite-ignore */ '${buildId}')$_` : undefined,
-                            import: `_$() => import(/* @vite-ignore */ '${buildId}')$_`,
+                            build: isBuild ? `_$() => import('${buildId}')$_` : undefined,
+                            import: `_$() => import('${buildId}')$_`,
                         };
                     }
                     return v;

package/dist/config/fs-routes/router.js

@@ -1,12 +1,11 @@
-import { init } from "es-module-lexer";
-import { parse } from "es-module-lexer";
+import { init, parse } from "es-module-lexer";
 import esbuild from "esbuild";
 import fg from "fast-glob";
-import fs from "fs";
+import fs from "node:fs";
 import micromatch from "micromatch";
-import { posix } from "path";
+import { posix } from "node:path";
 import { pathToRegexp } from "path-to-regexp";
-import { normalize } from "node:path";
+import { normalizePath } from "vite";
 export { pathToRegexp };
 export const glob = (path) => fg.sync(path, { absolute: true });
 export function cleanPath(src, config) {
@@ -76,7 +75,7 @@ export class BaseFileSystemRouter extends EventTarget {
         this.routes.push(route);
     }
     async addRoute(src) {
-        src = normalize(src);
+        src = normalizePath(src);
         if (this.isRoute(src)) {
             try {
                 const route = this.toRoute(src);
@@ -99,7 +98,7 @@ export class BaseFileSystemRouter extends EventTarget {
         }));
     }
     async updateRoute(src) {
-        src = normalize(src);
+        src = normalizePath(src);
         if (this.isRoute(src)) {
             try {
                 const route = this.toRoute(src);
@@ -115,7 +114,7 @@ export class BaseFileSystemRouter extends EventTarget {
         }
     }
     removeRoute(src) {
-        src = normalize(src);
+        src = normalizePath(src);
         if (this.isRoute(src)) {
             const path = this.toPath(src);
             if (path === undefined) {

package/dist/config/index.d.ts

@@ -1,10 +1,25 @@
-import { type PluginOption } from "vite";
+import type { PluginOption } from "vite";
 import { type Options as SolidOptions } from "vite-plugin-solid";
+import { type ServerFunctionsOptions } from "../directives/index.ts";
+import { type EnvPluginOptions } from "./env.ts";
 export interface SolidStartOptions {
     solid?: Partial<SolidOptions>;
     ssr?: boolean;
     routeDir?: string;
     extensions?: string[];
     middleware?: string;
+    serialization?: {
+        /**
+         * The serialization mode to use for server functions/actions.
+         * The "js" mode uses a custom binary format that is more efficient than JSON, but requires a custom deserializer (with `eval()`) on the client.
+         * A strong CSP should block `eval()` executions, which would prevent the "js" mode from working.
+         * The "json" mode uses JSON for serialization, which is less efficient but can be deserialized with `JSON.parse` on the client.
+         *
+         * @default "json"
+         */
+        mode?: "js" | "json";
+    };
+    env?: EnvPluginOptions;
+    serverFunctions?: Pick<ServerFunctionsOptions, "filter">;
 }
 export declare function solidStart(options?: SolidStartOptions): Array<PluginOption>;

package/dist/config/index.js

@@ -1,11 +1,11 @@
-import { TanStackServerFnPlugin } from "@tanstack/server-functions-plugin";
 import { defu } from "defu";
 import { globSync } from "node:fs";
-import { extname, isAbsolute, join, normalize } from "node:path";
-import { fileURLToPath } from "node:url";
+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";
@@ -66,6 +66,16 @@ export function solidStart(options) {
                 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",
@@ -108,13 +118,19 @@ export function solidStart(options) {
                                 }
                                 : {}),
                         },
+                        // Depending on the package manager and dependency structure Vite externalizes @solidjs/start
+                        // This makes sure that @solidjs/start goes through the Vite build process
+                        noExternal: ["@solidjs/start"],
                     },
                     define: {
                         "import.meta.env.MANIFEST": `globalThis.MANIFEST`,
                         "import.meta.env.START_SSR": JSON.stringify(start.ssr),
-                        "import.meta.env.START_APP_ENTRY": `"${appEntryPath}"`,
-                        "import.meta.env.START_CLIENT_ENTRY": `"${handlers.client}"`,
+                        // 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,
@@ -149,32 +165,16 @@ export function solidStart(options) {
             },
         }),
         lazy(),
+        envPlugin(options?.env),
         // Must be placed after fsRoutes, as treeShake will remove the
         // server fn exports added in by this plugin
-        TanStackServerFnPlugin({
-            // This is the ID that will be available to look up and import
-            // our server function manifest and resolve its module
-            manifestVirtualImportId: VIRTUAL_MODULES.serverFnManifest,
-            directive: "use server",
-            callers: [
-                {
-                    envConsumer: "client",
-                    envName: VITE_ENVIRONMENTS.client,
-                    getRuntimeCode: () => `import { createServerReference } from "${normalize(fileURLToPath(new URL("../server/server-runtime", import.meta.url)))}"`,
-                    replacer: opts => `createServerReference('${opts.functionId}')`,
-                },
-                {
-                    envConsumer: "server",
-                    envName: VITE_ENVIRONMENTS.server,
-                    getRuntimeCode: () => `import { createServerReference } from '${normalize(fileURLToPath(new URL("../server/server-fns-runtime", import.meta.url)))}'`,
-                    replacer: opts => `createServerReference(${opts.fn}, '${opts.functionId}')`,
-                },
-            ],
-            provider: {
-                envName: VITE_ENVIRONMENTS.server,
-                getRuntimeCode: () => `import { createServerReference } from '${normalize(fileURLToPath(new URL("../server/server-fns-runtime", import.meta.url)))}'`,
-                replacer: opts => `createServerReference(${opts.fn}, '${opts.functionId}')`,
+        serverFunctionsPlugin({
+            manifest: VIRTUAL_MODULES.serverFnManifest,
+            runtime: {
+                server: '@solidjs/start/fns/server',
+                client: '@solidjs/start/fns/client',
             },
+            filter: options?.serverFunctions?.filter,
         }),
         {
             name: "solid-start:virtual-modules",
@@ -200,8 +200,9 @@ export function solidStart(options) {
         {
             name: "solid-start:capture-client-bundle",
             enforce: "post",
-            generateBundle(_options, bundle) {
+            generateBundle(options, bundle) {
                 globalThis.START_CLIENT_BUNDLE = bundle;
+                globalThis.START_CLIENT_OUT_DIR = options.dir;
             },
         },
         devServer(),

package/dist/config/lazy.js

@@ -1,7 +1,7 @@
 import babel from "@babel/core";
 import * as t from "@babel/types";
-import { sep as osSep } from "path";
-import { basename, relative, sep } from "path/posix";
+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 {
@@ -35,13 +35,42 @@ const importTransform = () => {
 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",
-        applyToEnvironment(env) {
-            return env.name === VITE_ENVIRONMENTS.server;
+        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
@@ -52,7 +81,8 @@ const lazy = () => {
             const hasDefaultExport = src.indexOf("export default") !== -1;
             if (hasDefaultExport) {
                 const localId = relative(cwd, id);
-                plugins.push(idTransform(localId));
+                const chunkName = sharedChunkNames[id];
+                plugins.push(idTransform(chunkName ?? localId));
             }
             const hasLazy = src.indexOf("lazy(") !== -1;
             if (hasLazy)

package/dist/config/manifest.js

@@ -1,5 +1,9 @@
+import fs from "node:fs";
+import path from "node:path";
+import { version as viteVersion } from "vite";
 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 {
@@ -34,7 +38,37 @@ export function manifest(start) {
                     const entry = Object.values(globalThis.START_CLIENT_BUNDLE).find(v => "isEntry" in v && v.isEntry);
                     if (!entry)
                         throw new Error("No client entry found");
-                    clientViteManifest = JSON.parse(globalThis.START_CLIENT_BUNDLE[".vite/manifest.json"].source);
+                    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)};`;
             }
@@ -43,12 +77,12 @@ export function manifest(start) {
             else if (id.startsWith("/@manifest")) {
                 if (this.environment.mode !== "dev")
                     throw new Error("@manifest queries are only allowed in dev");
-                const [path, query] = id.split("?");
+                const [urlPath, query] = id.split("?");
                 const target = id.split("/")[2];
                 const params = new URLSearchParams(query);
-                if (!path || !query)
+                if (!urlPath || !query)
                     return;
-                if (path.endsWith("assets")) {
+                if (urlPath.endsWith("assets")) {
                     const id = params.get("id");
                     if (!id) {
                         throw new Error("Missing id to get assets.");
@@ -61,10 +95,10 @@ export function manifest(start) {
 						tag: "style",
 						attrs: {
 							type: "text/css",
-							"data-vite-dev-id": "${key}",
+							"data-vite-dev-id": "${wrapId(key)}",
 							"data-vite-ref": "0",
 						},
-						children: () => import("${value}?inline").then(mod => mod.default),
+						children: () => import("${wrapId(value)}?inline").then(mod => mod.default),
 					}`);
                     return `export default [${cssAssets.join(",")}]`;
                 }

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

@@ -1,9 +1,14 @@
-import { DevEnvironment, Rollup } from "vite";
+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;

package/dist/config/vite-utils.js

@@ -7,6 +7,7 @@ export function cleanUrl(url) {
 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;
@@ -38,10 +39,13 @@ export function normalizeResolvedIdToUrl(environment, url, resolved) {
     }
     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.startsWith(VALID_ID_PREFIX)
-        ? id
-        : VALID_ID_PREFIX + id.replace("\0", NULL_BYTE_PLACEHOLDER);
+    return id.replace(NULL_BYTE_REGEX, `${VALID_ID_PREFIX}${NULL_BYTE_PLACEHOLDER}`);
 }
 export function unwrapId(id) {
     return id.startsWith(VALID_ID_PREFIX)

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>;