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

package/dist/config/index.js

@@ -1,215 +0,0 @@
-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 [
-        {
-            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
-                        noExternal: ["@solidjs/start"],
-                    },
-                    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),
-        // 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: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

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

package/dist/config/lazy.js

@@ -1,112 +0,0 @@
-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;
-            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

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

package/dist/config/manifest.js

@@ -1,108 +0,0 @@
-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 {
-        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(new URL("../server/manifest/client-manifest", import.meta.url).pathname);
-            if (id === VIRTUAL_MODULES.getManifest) {
-                return this.environment.config.consumer === "client"
-                    ? this.resolve(new URL("../server/manifest/client-manifest", import.meta.url).pathname)
-                    : this.resolve(new URL("../server/manifest/ssr-manifest", import.meta.url).pathname);
-            }
-            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

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

package/dist/config/utils.js

@@ -1,6 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,85 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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

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

package/dist/directives/generate-unique-name.js

@@ -1,16 +0,0 @@
-import * as t from "@babel/types";
-export function generateUniqueName(path, name) {
-    let uid;
-    let i = 1;
-    do {
-        uid = name + "_" + i;
-        i++;
-    } while (path.scope.hasLabel(uid) ||
-        path.scope.hasBinding(uid) ||
-        path.scope.hasGlobal(uid) ||
-        path.scope.hasReference(uid));
-    const program = path.scope.getProgramParent();
-    program.references[uid] = true;
-    program.uids[uid] = true;
-    return t.identifier(uid);
-}