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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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