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

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;

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

@@ -0,0 +1,16 @@
+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);
+}

package/dist/directives/get-descriptive-name.d.ts

@@ -0,0 +1,2 @@
+import type { NodePath } from "@babel/core";
+export declare function getDescriptiveName(path: NodePath, defaultName: string): string;

package/dist/directives/get-descriptive-name.js

@@ -0,0 +1,37 @@
+export function getDescriptiveName(path, defaultName) {
+    let current = path;
+    while (current) {
+        switch (current.node.type) {
+            case "FunctionDeclaration":
+            case "FunctionExpression": {
+                if (current.node.id) {
+                    return current.node.id.name;
+                }
+                break;
+            }
+            case "VariableDeclarator": {
+                if (current.node.id.type === "Identifier") {
+                    return current.node.id.name;
+                }
+                break;
+            }
+            case "ClassPrivateMethod":
+            case "ClassMethod":
+            case "ObjectMethod": {
+                switch (current.node.key.type) {
+                    case "Identifier":
+                        return current.node.key.name;
+                    case "PrivateName":
+                        return current.node.key.id.name;
+                    default:
+                        break;
+                }
+                break;
+            }
+            default:
+                break;
+        }
+        current = current.parentPath;
+    }
+    return defaultName;
+}

package/dist/directives/get-import-identifier.d.ts

@@ -0,0 +1,4 @@
+import type * as babel from "@babel/core";
+import * as t from "@babel/types";
+import type { ImportDefinition } from "./types.ts";
+export declare function getImportIdentifier(imports: Map<string, t.Identifier>, path: babel.NodePath, registration: ImportDefinition): t.Identifier;

package/dist/directives/get-import-identifier.js

@@ -0,0 +1,19 @@
+import * as t from "@babel/types";
+import { generateUniqueName } from "./generate-unique-name.js";
+export function getImportIdentifier(imports, path, registration) {
+    const name = registration.kind === "named" ? registration.name : "default";
+    const target = `${registration.source}[${name}]`;
+    const current = imports.get(target);
+    if (current) {
+        return current;
+    }
+    const programParent = path.scope.getProgramParent();
+    const uid = generateUniqueName(programParent.path, name);
+    programParent.registerDeclaration(programParent.path.unshiftContainer("body", t.importDeclaration([
+        registration.kind === "named"
+            ? t.importSpecifier(uid, t.identifier(registration.name))
+            : t.importDefaultSpecifier(uid),
+    ], t.stringLiteral(registration.source)))[0]);
+    imports.set(target, uid);
+    return uid;
+}

package/dist/directives/get-root-statement-path.d.ts

@@ -0,0 +1,2 @@
+import type * as babel from "@babel/core";
+export declare function getRootStatementPath(path: babel.NodePath): babel.NodePath;

package/dist/directives/get-root-statement-path.js

@@ -0,0 +1,12 @@
+import * as t from "@babel/types";
+export function getRootStatementPath(path) {
+    let current = path.parentPath;
+    while (current) {
+        const next = current.parentPath;
+        if (next && t.isProgram(next.node)) {
+            return current;
+        }
+        current = next;
+    }
+    return path;
+}

package/dist/directives/index.d.ts

@@ -0,0 +1,14 @@
+import { type FilterPattern, type Plugin } from "vite";
+export interface ServerFunctionsFilter {
+    include?: FilterPattern;
+    exclude?: FilterPattern;
+}
+export interface ServerFunctionsOptions {
+    manifest: string;
+    runtime: {
+        server: string;
+        client: string;
+    };
+    filter?: ServerFunctionsFilter;
+}
+export declare function serverFunctionsPlugin(options: ServerFunctionsOptions): Plugin[];