@solidjs/start 2.0.0-alpha.2 → 2.0.0-beta.0

package/dist/config/manifest.js

@@ -1,3 +1,7 @@
+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";
@@ -13,11 +17,11 @@ export function manifest(start) {
             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);
+                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(new URL("../server/manifest/client-manifest", import.meta.url).pathname)
-                    : this.resolve(new URL("../server/manifest/ssr-manifest", import.meta.url).pathname);
+                    ? 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)
@@ -35,7 +39,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)};`;
             }
@@ -44,12 +78,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.");

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

@@ -1,4 +1,4 @@
-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/";

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

package/dist/directives/index.js

@@ -0,0 +1,170 @@
+import { createFilter, } from "vite";
+import { compile } from "./compile.js";
+const DEFAULT_INCLUDE = "src/**/*.{jsx,tsx,ts,js,mjs,cjs}";
+const DEFAULT_EXCLUDE = "node_modules/**/*.{jsx,tsx,ts,js,mjs,cjs}";
+const DIRECTIVE = "use server";
+function createManifest() {
+    return {
+        server: new Set(),
+        client: new Set(),
+    };
+}
+function createDeferredPromise() {
+    let resolve;
+    let reject;
+    return {
+        reference: new Promise((res, rej) => {
+            resolve = res;
+            reject = rej;
+        }),
+        resolve(value) {
+            resolve(value);
+        },
+        reject(value) {
+            reject(value);
+        },
+    };
+}
+class Debouncer {
+    source;
+    promise;
+    timeout;
+    constructor(source) {
+        this.source = source;
+        this.promise = createDeferredPromise();
+        this.defer();
+    }
+    defer() {
+        if (this.timeout) {
+            clearTimeout(this.timeout);
+            this.timeout = undefined;
+        }
+        this.timeout = setTimeout(() => {
+            this.promise.resolve(this.source());
+        }, 1000);
+    }
+}
+function mergeManifestRecord(source, target) {
+    const current = source.size;
+    for (const entry of target) {
+        source.add(entry);
+    }
+    return {
+        invalidPreload: current !== source.size,
+        invalidated: [...source],
+    };
+}
+function invalidateModule(moduleGraph, path) {
+    const target = moduleGraph.getModuleById(path);
+    if (target) {
+        moduleGraph.invalidateModule(target);
+    }
+}
+function invalidateModules(server, result, manifest) {
+    if (server) {
+        if (result.invalidPreload) {
+            invalidateModule(server.environments.client.moduleGraph, manifest);
+            invalidateModule(server.environments.ssr.moduleGraph, manifest);
+        }
+    }
+}
+export function serverFunctionsPlugin(options) {
+    const filter = createFilter(options.filter?.include || DEFAULT_INCLUDE, options.filter?.exclude || DEFAULT_EXCLUDE);
+    let env;
+    const manifest = createManifest();
+    const preload = {
+        server: undefined,
+        client: undefined,
+    };
+    let currentServer;
+    const clientOptions = {
+        directive: DIRECTIVE,
+        definitions: {
+            register: {
+                kind: "named",
+                name: "createServerReference",
+                source: options.runtime.client,
+            },
+            clone: {
+                kind: "named",
+                name: "cloneServerReference",
+                source: options.runtime.client,
+            },
+        },
+    };
+    const serverOptions = {
+        directive: DIRECTIVE,
+        definitions: {
+            register: {
+                kind: "named",
+                name: "createServerReference",
+                source: options.runtime.server,
+            },
+            clone: {
+                kind: "named",
+                name: "cloneServerReference",
+                source: options.runtime.server,
+            },
+        },
+    };
+    return [
+        {
+            name: "solid-start:server-functions/setup",
+            enforce: "pre",
+            configResolved(config) {
+                env = config.mode !== "production" ? "development" : "production";
+            },
+            configureServer(server) {
+                currentServer = server;
+            },
+        },
+        {
+            name: "solid-start:server-functions/preload",
+            enforce: "pre",
+            resolveId(source) {
+                if (source === options.manifest) {
+                    return { id: options.manifest, moduleSideEffects: true };
+                }
+                return null;
+            },
+            async load(id, opts) {
+                const mode = opts?.ssr ? "server" : "client";
+                if (id === options.manifest) {
+                    const current = new Debouncer(() => [...manifest[mode]].map(entry => `import "${entry}";`).join("\n"));
+                    preload[mode] = current;
+                    const result = await current.promise.reference;
+                    return result;
+                }
+                return null;
+            },
+        },
+        {
+            name: "solid-start:server-functions/compiler",
+            enforce: 'pre',
+            async transform(code, fileId, opts) {
+                const mode = opts?.ssr ? "server" : "client";
+                const [id] = fileId.split("?");
+                if (!filter(id)) {
+                    return null;
+                }
+                const result = await compile(id, code, {
+                    ...(mode === "server" ? serverOptions : clientOptions),
+                    mode,
+                    env,
+                });
+                if (result.valid) {
+                    const preloader = preload[mode];
+                    if (preloader) {
+                        preloader.defer();
+                    }
+                    invalidateModules(currentServer, mergeManifestRecord(manifest.server, new Set([id])), options.manifest);
+                    return {
+                        code: result.code || "",
+                        map: result.map,
+                    };
+                }
+                return null;
+            },
+        },
+    ];
+}

package/dist/directives/is-statement-top-level.d.ts

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

package/dist/directives/is-statement-top-level.js

@@ -0,0 +1,9 @@
+export function isStatementTopLevel(path) {
+    let blockParent = path.scope.getBlockParent();
+    const programParent = path.scope.getProgramParent();
+    // a FunctionDeclaration binding refers to itself as the block parent
+    if (blockParent.path === path) {
+        blockParent = blockParent.parent;
+    }
+    return programParent === blockParent;
+}

package/dist/directives/paths.d.ts

@@ -0,0 +1,9 @@
+import type * as t from "@babel/types";
+type TypeFilter<V extends t.Node> = (node: t.Node) => node is V;
+export declare function isPathValid<V extends t.Node>(path: unknown, key: TypeFilter<V>): path is babel.NodePath<V>;
+export type NestedExpression = t.ParenthesizedExpression | t.TypeCastExpression | t.TSAsExpression | t.TSSatisfiesExpression | t.TSNonNullExpression | t.TSInstantiationExpression | t.TSTypeAssertion;
+export declare function isNestedExpression(node: t.Node): node is NestedExpression;
+type TypeCheck<K> = K extends TypeFilter<infer U> ? U : never;
+export declare function unwrapNode<K extends (value: t.Node) => boolean>(node: t.Node, key: K): TypeCheck<K> | undefined;
+export declare function unwrapPath<V extends t.Node>(path: unknown, key: TypeFilter<V>): babel.NodePath<V> | undefined;
+export {};

package/dist/directives/paths.js

@@ -0,0 +1,36 @@
+export function isPathValid(path, key) {
+    const node = path.node;
+    return node ? key(node) : false;
+}
+export function isNestedExpression(node) {
+    switch (node.type) {
+        case "ParenthesizedExpression":
+        case "TypeCastExpression":
+        case "TSAsExpression":
+        case "TSSatisfiesExpression":
+        case "TSNonNullExpression":
+        case "TSTypeAssertion":
+        case "TSInstantiationExpression":
+            return true;
+        default:
+            return false;
+    }
+}
+export function unwrapNode(node, key) {
+    if (key(node)) {
+        return node;
+    }
+    if (isNestedExpression(node)) {
+        return unwrapNode(node.expression, key);
+    }
+    return undefined;
+}
+export function unwrapPath(path, key) {
+    if (isPathValid(path, key)) {
+        return path;
+    }
+    if (isPathValid(path, isNestedExpression)) {
+        return unwrapPath(path.get("expression"), key);
+    }
+    return undefined;
+}

package/dist/directives/plugin.d.ts

@@ -0,0 +1,21 @@
+import type * as babel from "@babel/core";
+import * as t from "@babel/types";
+import type { ImportDefinition } from "./types.ts";
+export interface StateContext {
+    env: "production" | "development";
+    mode: "server" | "client";
+    directive: string;
+    hash: string;
+    count: number;
+    imports: Map<string, t.Identifier>;
+    valid: boolean;
+    definitions: {
+        register: ImportDefinition;
+        clone: ImportDefinition;
+    };
+}
+interface State extends babel.PluginPass {
+    opts: StateContext;
+}
+export declare function directivesPlugin(): babel.PluginObj<State>;
+export {};