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

package/dist/directives/index.js

@@ -0,0 +1,202 @@
+import { createFilter, } from "vite";
+import fg from "fast-glob";
+import { compile } from "./compile.js";
+import xxHash32 from "./xxhash32.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";
+// Dev-only virtual module used by fns/handler.ts to lazily resolve a server
+// function id back to its owning module when the function was never evaluated
+// in the server environment (e.g. its route was only client-side navigated to).
+const LOOKUP_ID = "solid-start:server-fn-lookup";
+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) {
+            // Environments are not limited to "client"/"ssr": plugins like nitro
+            // render in their own environment (e.g. "nitro"), so invalidate everywhere.
+            for (const environment of Object.values(server.environments)) {
+                invalidateModule(environment.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 };
+                }
+                if (source.startsWith(LOOKUP_ID)) {
+                    return { id: source, moduleSideEffects: true };
+                }
+                return null;
+            },
+            async load(id) {
+                const mode = this.environment.config.consumer;
+                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;
+                }
+                if (id.startsWith(LOOKUP_ID)) {
+                    if (this.environment.mode !== "dev") {
+                        throw new Error(`${LOOKUP_ID} is only available in dev`);
+                    }
+                    const functionId = new URLSearchParams(id.slice(LOOKUP_ID.length + 1)).get("id");
+                    // dev function ids are `${xxHash32(file)}-${count}-${name}`
+                    const hash = functionId?.split("-")[0];
+                    if (!hash)
+                        return "export {};";
+                    // Look through the files already discovered by the transform first;
+                    // fall back to scanning the project so a function is found even when
+                    // the browser kept a chunk from before a dev server restart.
+                    let files = [...manifest.server].filter(file => xxHash32(file).toString(16) === hash);
+                    if (files.length === 0) {
+                        files = fg
+                            .sync(DEFAULT_INCLUDE, { cwd: this.environment.config.root, absolute: true })
+                            .filter(file => filter(file) && xxHash32(file).toString(16) === hash);
+                    }
+                    return files.map(file => `import ${JSON.stringify(file)};`).join("\n") || "export {};";
+                }
+                return null;
+            },
+        },
+        {
+            name: "solid-start:server-functions/compiler",
+            enforce: "pre",
+            async transform(code, fileId) {
+                const mode = this.environment.config.consumer;
+                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 {};

package/dist/directives/plugin.js

@@ -0,0 +1,302 @@
+import * as t from "@babel/types";
+import { bubbleFunctionDeclaration } from "./bubble-function-declaration.js";
+import { generateUniqueName } from "./generate-unique-name.js";
+import { getDescriptiveName } from "./get-descriptive-name.js";
+import { getImportIdentifier } from "./get-import-identifier.js";
+import { getRootStatementPath } from "./get-root-statement-path.js";
+import { isStatementTopLevel } from "./is-statement-top-level.js";
+import { isPathValid, unwrapPath } from "./paths.js";
+import { removeUnusedVariables } from "./remove-unused-variables.js";
+function isValidFunction(node) {
+    return t.isArrowFunctionExpression(node) || t.isFunctionExpression(node);
+}
+function isDirectiveValid(ctx, directives) {
+    for (let i = 0, len = directives.length; i < len; i++) {
+        if (directives[i].value.value === ctx.directive) {
+            return true;
+        }
+    }
+    return false;
+}
+function cleanDirectives(path, target) {
+    const newDirectives = [];
+    for (let i = 0, len = path.node.directives.length; i < len; i++) {
+        const current = path.node.directives[i];
+        if (current.value.value !== target) {
+            newDirectives.push(current);
+        }
+    }
+    path.node.directives = newDirectives;
+}
+function cleanFunctionDirectives(ctx, path) {
+    const body = path.get("body");
+    if (isPathValid(body, t.isBlockStatement)) {
+        cleanDirectives(body, ctx.directive);
+    }
+}
+function isFunctionDirectiveValid(ctx, path) {
+    const body = path.get("body");
+    if (isPathValid(body, t.isBlockStatement)) {
+        return isDirectiveValid(ctx, body.node.directives);
+    }
+    return false;
+}
+function createID(ctx, name) {
+    const base = `${ctx.hash}-${ctx.count++}`;
+    if (ctx.env === "development") {
+        return `${base}-${name}`;
+    }
+    return base;
+}
+function transformFunction(ctx, path, direct) {
+    if (!direct) {
+        if (!isFunctionDirectiveValid(ctx, path)) {
+            return;
+        }
+        cleanFunctionDirectives(ctx, path);
+    }
+    // First, get root statement
+    const rootStatement = getRootStatementPath(path);
+    // Create a unique ID for the function
+    const fnID = createID(ctx, getDescriptiveName(path, "anonymous"));
+    if (ctx.mode === "server") {
+        // Create a "source" function on the root-level
+        const sourceReference = t.callExpression(getImportIdentifier(ctx.imports, path, ctx.definitions.register), [t.stringLiteral(fnID), path.node]);
+        const sourceID = generateUniqueName(path, "serverFn");
+        rootStatement.insertBefore(t.variableDeclaration("const", [t.variableDeclarator(sourceID, sourceReference)]));
+        // Clone the source function to replace the server function
+        path.replaceWith(t.callExpression(getImportIdentifier(ctx.imports, path, ctx.definitions.clone), [sourceID]));
+    }
+    else {
+        // Otherwise, clone the function based on its ID
+        path.replaceWith(t.callExpression(getImportIdentifier(ctx.imports, path, ctx.definitions.clone), [
+            t.stringLiteral(fnID),
+        ]));
+    }
+    path.scope.crawl();
+}
+function traceBinding(path, name) {
+    const current = path.scope.getBinding(name);
+    if (!current) {
+        return undefined;
+    }
+    switch (current.kind) {
+        case "const":
+        case "let":
+        case "var": {
+            if (isPathValid(current.path, t.isVariableDeclarator)) {
+                // Check if left is identifier
+                const left = unwrapPath(current.path.get("id"), t.isIdentifier);
+                if (left) {
+                    const right = unwrapPath(current.path.get("init"), t.isIdentifier);
+                    if (right) {
+                        return traceBinding(path, right.node.name);
+                    }
+                    // Only valid for functions
+                    const func = unwrapPath(current.path.get("init"), isValidFunction);
+                    if (func) {
+                        return current;
+                    }
+                }
+            }
+            return undefined;
+        }
+        case "hoisted":
+        case "local":
+        case "module":
+        case "param":
+        case "unknown":
+            return undefined;
+    }
+}
+function transformBindingForServer(ctx, binding) {
+    if (isPathValid(binding.path, t.isVariableDeclarator)) {
+        const right = unwrapPath(binding.path.get("init"), isValidFunction);
+        if (right) {
+            transformFunction(ctx, right, true);
+        }
+    }
+}
+function transformModuleLevelDirective(ctx, program) {
+    cleanDirectives(program, ctx.directive);
+    program.traverse({
+        FunctionDeclaration(child) {
+            // We only need to move top-level functions
+            if (isStatementTopLevel(child)) {
+                bubbleFunctionDeclaration(child);
+            }
+        },
+    });
+    program.scope.crawl();
+    if (ctx.mode === "server") {
+        // Trace bindings
+        const bindings = new Set();
+        program.traverse({
+            ExportDefaultDeclaration(path) {
+                const id = unwrapPath(path.get("declaration"), t.isIdentifier);
+                if (id) {
+                    const binding = traceBinding(path, id.node.name);
+                    if (binding) {
+                        bindings.add(binding);
+                    }
+                }
+            },
+            ExportNamedDeclaration(path) {
+                if (path.node.source || path.node.exportKind === "type") {
+                    return;
+                }
+                for (const specifier of path.get("specifiers")) {
+                    if (isPathValid(specifier, t.isExportSpecifier)) {
+                        const binding = traceBinding(specifier, specifier.node.local.name);
+                        if (binding) {
+                            bindings.add(binding);
+                        }
+                    }
+                }
+                const declarations = path.get("declaration");
+                if (isPathValid(declarations, t.isVariableDeclaration)) {
+                    for (const declaration of declarations.get("declarations")) {
+                        // Check if left is identifier
+                        const left = unwrapPath(declaration.get("id"), t.isIdentifier);
+                        if (left) {
+                            const binding = traceBinding(left, left.node.name);
+                            if (binding) {
+                                bindings.add(binding);
+                            }
+                        }
+                    }
+                }
+            },
+        });
+        for (const binding of bindings) {
+            transformBindingForServer(ctx, binding);
+        }
+    }
+    else {
+        // Trace bindings
+        const uniqueBindings = new Set();
+        const exportedBindings = new Map();
+        program.traverse({
+            ExportDefaultDeclaration(path) {
+                const id = unwrapPath(path.get("declaration"), t.isIdentifier);
+                if (id) {
+                    const binding = traceBinding(path, id.node.name);
+                    if (binding) {
+                        uniqueBindings.add(binding);
+                        exportedBindings.set("default", binding);
+                    }
+                }
+            },
+            ExportNamedDeclaration(path) {
+                if (path.node.source || path.node.exportKind === "type") {
+                    return;
+                }
+                for (const specifier of path.get("specifiers")) {
+                    if (isPathValid(specifier, t.isExportSpecifier)) {
+                        const binding = traceBinding(specifier, specifier.node.local.name);
+                        if (binding) {
+                            const key = t.isIdentifier(specifier.node.exported)
+                                ? specifier.node.exported.name
+                                : specifier.node.exported.value;
+                            uniqueBindings.add(binding);
+                            exportedBindings.set(key, binding);
+                        }
+                    }
+                }
+                const declarations = path.get("declaration");
+                if (isPathValid(declarations, t.isVariableDeclaration)) {
+                    for (const declaration of declarations.get("declarations")) {
+                        // Check if left is identifier
+                        const left = unwrapPath(declaration.get("id"), t.isIdentifier);
+                        if (left) {
+                            const binding = traceBinding(left, left.node.name);
+                            if (binding) {
+                                uniqueBindings.add(binding);
+                                exportedBindings.set(left.node.name, binding);
+                            }
+                        }
+                    }
+                }
+            },
+        });
+        // generate ids for each unique binding
+        const sourceIDs = new Map();
+        for (const binding of uniqueBindings) {
+            if (isPathValid(binding.path, t.isVariableDeclarator)) {
+                const init = unwrapPath(binding.path.get("init"), isValidFunction);
+                if (init) {
+                    sourceIDs.set(binding, createID(ctx, getDescriptiveName(init, "anonymous")));
+                }
+            }
+        }
+        // clear body
+        program.node.body = [];
+        const declarations = [];
+        const specifiers = [];
+        const declarationMap = new Map();
+        // Declare all client functions
+        for (const [exported, binding] of exportedBindings) {
+            let currentIdentifier = declarationMap.get(binding);
+            if (!currentIdentifier) {
+                currentIdentifier = generateUniqueName(program, "fn");
+                const fnID = sourceIDs.get(binding);
+                if (fnID) {
+                    declarations.push(t.variableDeclarator(currentIdentifier, t.callExpression(getImportIdentifier(ctx.imports, program, ctx.definitions.clone), [
+                        t.stringLiteral(fnID),
+                    ])));
+                    declarationMap.set(binding, currentIdentifier);
+                }
+            }
+            if (currentIdentifier) {
+                specifiers.push(t.exportSpecifier(currentIdentifier, t.stringLiteral(exported)));
+            }
+        }
+        const body = [];
+        if (declarations.length > 0) {
+            body.push(t.variableDeclaration("const", declarations));
+        }
+        if (specifiers.length > 0) {
+            body.push(t.exportNamedDeclaration(null, specifiers, null));
+        }
+        program.pushContainer("body", body);
+    }
+}
+export function directivesPlugin() {
+    return {
+        name: "solid-start:directives",
+        visitor: {
+            Program(program, ctx) {
+                const isModuleLevel = isDirectiveValid(ctx.opts, program.node.directives);
+                if (isModuleLevel) {
+                    transformModuleLevelDirective(ctx.opts, program);
+                    ctx.opts.valid = true;
+                }
+                else {
+                    // First, bubble up function declarations
+                    program.traverse({
+                        FunctionDeclaration(child) {
+                            // if (isFunctionDirectiveValid(ctx.opts, child)) {
+                            bubbleFunctionDeclaration(child);
+                            // }
+                        },
+                    });
+                    program.scope.crawl();
+                    // Now we transform each function
+                    program.traverse({
+                        ArrowFunctionExpression(path) {
+                            transformFunction(ctx.opts, path, false);
+                        },
+                        FunctionExpression(path) {
+                            transformFunction(ctx.opts, path, false);
+                        },
+                    });
+                    program.scope.crawl();
+                    if (ctx.opts.count > 0) {
+                        ctx.opts.valid = true;
+                        removeUnusedVariables(program);
+                    }
+                }
+            },
+        },
+    };
+}

package/dist/directives/remove-unused-variables.d.ts

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

package/dist/directives/remove-unused-variables.js

@@ -0,0 +1,66 @@
+import * as t from "@babel/types";
+import { isPathValid } from "./paths.js";
+function isInvalidForRemoval(path) {
+    if (isPathValid(path, t.isCatchClause)) {
+        // This case is for `catch (error)` blocks
+        return true;
+    }
+    // This one is for destructured variables
+    let target = path;
+    if (isPathValid(path, t.isVariableDeclarator)) {
+        target = path.get('id');
+    }
+    return isPathValid(target, t.isObjectPattern) || isPathValid(target, t.isArrayPattern);
+}
+export function removeUnusedVariables(program) {
+    // TODO(Alexis):
+    // This implementation is simple but slow
+    // We repeat removing unused variables from each pass
+    // until no potential unused variables are left.
+    // There might be a simpler implementation.
+    let dirty = true;
+    while (dirty) {
+        dirty = false;
+        program.traverse({
+            BindingIdentifier(path) {
+                const binding = path.scope.getBinding(path.node.name);
+                if (binding) {
+                    switch (binding.kind) {
+                        case "const":
+                        case "let":
+                        case "var":
+                        case "hoisted":
+                        case "module":
+                            if (binding.references === 0 && !binding.path.removed) {
+                                const parent = binding.path.parentPath;
+                                if (isPathValid(parent, t.isImportDeclaration)) {
+                                    if (parent.node.specifiers.length === 1) {
+                                        parent.remove();
+                                    }
+                                    else {
+                                        binding.path.remove();
+                                    }
+                                    dirty = true;
+                                }
+                                else if (!(isInvalidForRemoval(binding.path))) {
+                                    binding.path.remove();
+                                    dirty = true;
+                                }
+                            }
+                            break;
+                        case "local":
+                        case "param":
+                        case "unknown":
+                            break;
+                    }
+                }
+            },
+            VariableDeclaration(path) {
+                if (path.node.declarations.length === 0) {
+                    path.remove();
+                }
+            },
+        });
+        program.scope.crawl();
+    }
+}

package/{src/directives/types.ts → dist/directives/types.d.ts}

@@ -1,12 +1,10 @@
 export interface NamedImportDefinition {
-  kind: "named";
-  name: string;
-  source: string;
+    kind: "named";
+    name: string;
+    source: string;
 }
-
 export interface DefaultImportDefinition {
-  kind: "default";
-  source: string;
+    kind: "default";
+    source: string;
 }
-
 export type ImportDefinition = DefaultImportDefinition | NamedImportDefinition;

package/dist/directives/types.js

@@ -0,0 +1 @@
+export {};

package/dist/directives/xxhash32.d.ts

@@ -0,0 +1,6 @@
+/**
+ *
+ * @param buffer - byte array or string
+ * @param seed - optional seed (32-bit unsigned);
+ */
+export default function xxHash32(buffer: Uint8Array | string, seed?: number): number;