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

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/dist/directives/types.d.ts

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

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;

package/dist/directives/xxhash32.js

@@ -0,0 +1,193 @@
+// @ts-nocheck
+/**
+ * Copyright (c) 2019 Jason Dent
+ * https://github.com/Jason3S/xxhash
+ */
+const PRIME32_1 = 2654435761;
+const PRIME32_2 = 2246822519;
+const PRIME32_3 = 3266489917;
+const PRIME32_4 = 668265263;
+const PRIME32_5 = 374761393;
+function toUtf8(text) {
+    const bytes = [];
+    for (let i = 0, n = text.length; i < n; ++i) {
+        const c = text.charCodeAt(i);
+        if (c < 0x80) {
+            bytes.push(c);
+        }
+        else if (c < 0x800) {
+            bytes.push(0xc0 | (c >> 6), 0x80 | (c & 0x3f));
+        }
+        else if (c < 0xd800 || c >= 0xe000) {
+            bytes.push(0xe0 | (c >> 12), 0x80 | ((c >> 6) & 0x3f), 0x80 | (c & 0x3f));
+        }
+        else {
+            const cp = 0x10000 + (((c & 0x3ff) << 10) | (text.charCodeAt(++i) & 0x3ff));
+            bytes.push(0xf0 | ((cp >> 18) & 0x7), 0x80 | ((cp >> 12) & 0x3f), 0x80 | ((cp >> 6) & 0x3f), 0x80 | (cp & 0x3f));
+        }
+    }
+    return new Uint8Array(bytes);
+}
+/**
+ *
+ * @param buffer - byte array or string
+ * @param seed - optional seed (32-bit unsigned);
+ */
+export default function xxHash32(buffer, seed = 0) {
+    buffer = typeof buffer === 'string' ? toUtf8(buffer) : buffer;
+    const b = buffer;
+    /*
+      Step 1. Initialize internal accumulators
+      Each accumulator gets an initial value based on optional seed input.
+      Since the seed is optional, it can be 0.
+      ```
+        u32 acc1 = seed + PRIME32_1 + PRIME32_2;
+        u32 acc2 = seed + PRIME32_2;
+        u32 acc3 = seed + 0;
+        u32 acc4 = seed - PRIME32_1;
+      ```
+      Special case : input is less than 16 bytes
+      When input is too small (< 16 bytes), the algorithm will not process any stripe.
+      Consequently, it will not make use of parallel accumulators.
+      In which case, a simplified initialization is performed, using a single accumulator :
+      u32 acc  = seed + PRIME32_5;
+      The algorithm then proceeds directly to step 4.
+    */
+    let acc = (seed + PRIME32_5) & 0xffffffff;
+    let offset = 0;
+    if (b.length >= 16) {
+        const accN = [
+            (seed + PRIME32_1 + PRIME32_2) & 0xffffffff,
+            (seed + PRIME32_2) & 0xffffffff,
+            (seed + 0) & 0xffffffff,
+            (seed - PRIME32_1) & 0xffffffff,
+        ];
+        /*
+          Step 2. Process stripes
+          A stripe is a contiguous segment of 16 bytes. It is evenly divided into 4 lanes,
+          of 4 bytes each. The first lane is used to update accumulator 1, the second lane
+          is used to update accumulator 2, and so on. Each lane read its associated 32-bit
+          value using little-endian convention. For each {lane, accumulator}, the update
+          process is called a round, and applies the following formula :
+          ```
+          accN = accN + (laneN * PRIME32_2);
+          accN = accN <<< 13;
+          accN = accN * PRIME32_1;
+          ```
+          This shuffles the bits so that any bit from input lane impacts several bits in
+          output accumulator. All operations are performed modulo 2^32.
+          Input is consumed one full stripe at a time. Step 2 is looped as many times as
+          necessary to consume the whole input, except the last remaining bytes which cannot
+          form a stripe (< 16 bytes). When that happens, move to step 3.
+        */
+        const b = buffer;
+        const limit = b.length - 16;
+        let lane = 0;
+        for (offset = 0; (offset & 0xfffffff0) <= limit; offset += 4) {
+            const i = offset;
+            const laneN0 = b[i + 0] + (b[i + 1] << 8);
+            const laneN1 = b[i + 2] + (b[i + 3] << 8);
+            const laneNP = laneN0 * PRIME32_2 + ((laneN1 * PRIME32_2) << 16);
+            let acc = (accN[lane] + laneNP) & 0xffffffff;
+            acc = (acc << 13) | (acc >>> 19);
+            const acc0 = acc & 0xffff;
+            const acc1 = acc >>> 16;
+            accN[lane] = (acc0 * PRIME32_1 + ((acc1 * PRIME32_1) << 16)) & 0xffffffff;
+            lane = (lane + 1) & 0x3;
+        }
+        /*
+          Step 3. Accumulator convergence
+          All 4 lane accumulators from previous steps are merged to produce a
+          single remaining accumulator
+          of same width (32-bit). The associated formula is as follows :
+          ```
+          acc = (acc1 <<< 1) + (acc2 <<< 7) + (acc3 <<< 12) + (acc4 <<< 18);
+          ```
+        */
+        acc =
+            (((accN[0] << 1) | (accN[0] >>> 31)) +
+                ((accN[1] << 7) | (accN[1] >>> 25)) +
+                ((accN[2] << 12) | (accN[2] >>> 20)) +
+                ((accN[3] << 18) | (accN[3] >>> 14))) &
+                0xffffffff;
+    }
+    /*
+      Step 4. Add input length
+      The input total length is presumed known at this stage.
+      This step is just about adding the length to
+      accumulator, so that it participates to final mixing.
+      ```
+      acc = acc + (u32)inputLength;
+      ```
+    */
+    acc = (acc + buffer.length) & 0xffffffff;
+    /*
+      Step 5. Consume remaining input
+      There may be up to 15 bytes remaining to consume from the input.
+      The final stage will digest them according
+      to following pseudo-code :
+      ```
+      while (remainingLength >= 4) {
+          lane = read_32bit_little_endian(input_ptr);
+          acc = acc + lane * PRIME32_3;
+          acc = (acc <<< 17) * PRIME32_4;
+          input_ptr += 4; remainingLength -= 4;
+      }
+      ```
+      This process ensures that all input bytes are present in the final mix.
+    */
+    const limit = buffer.length - 4;
+    for (; offset <= limit; offset += 4) {
+        const i = offset;
+        const laneN0 = b[i + 0] + (b[i + 1] << 8);
+        const laneN1 = b[i + 2] + (b[i + 3] << 8);
+        const laneP = laneN0 * PRIME32_3 + ((laneN1 * PRIME32_3) << 16);
+        acc = (acc + laneP) & 0xffffffff;
+        acc = (acc << 17) | (acc >>> 15);
+        acc =
+            ((acc & 0xffff) * PRIME32_4 + (((acc >>> 16) * PRIME32_4) << 16)) &
+                0xffffffff;
+    }
+    /*
+          ```
+          while (remainingLength >= 1) {
+              lane = read_byte(input_ptr);
+              acc = acc + lane * PRIME32_5;
+              acc = (acc <<< 11) * PRIME32_1;
+              input_ptr += 1; remainingLength -= 1;
+          }
+          ```
+      */
+    for (; offset < b.length; ++offset) {
+        const lane = b[offset];
+        acc += lane * PRIME32_5;
+        acc = (acc << 11) | (acc >>> 21);
+        acc =
+            ((acc & 0xffff) * PRIME32_1 + (((acc >>> 16) * PRIME32_1) << 16)) &
+                0xffffffff;
+    }
+    /*
+          Step 6. Final mix (avalanche)
+          The final mix ensures that all input bits have a chance to impact any bit in
+          the output digest, resulting in an unbiased distribution. This is also called
+          avalanche effect.
+          ```
+          acc = acc xor (acc >> 15);
+          acc = acc * PRIME32_2;
+          acc = acc xor (acc >> 13);
+          acc = acc * PRIME32_3;
+          acc = acc xor (acc >> 16);
+          ```
+      */
+    acc ^= acc >>> 15;
+    acc =
+        (((acc & 0xffff) * PRIME32_2) & 0xffffffff) +
+            (((acc >>> 16) * PRIME32_2) << 16);
+    acc ^= acc >>> 13;
+    acc =
+        (((acc & 0xffff) * PRIME32_3) & 0xffffffff) +
+            (((acc >>> 16) * PRIME32_3) << 16);
+    acc ^= acc >>> 16;
+    // turn any negatives back into a positive number;
+    return acc < 0 ? acc + 4294967296 : acc;
+}

package/dist/{server/server-runtime.d.ts → fns/client.d.ts}

@@ -1,3 +1,3 @@
 import { type Component } from "solid-js";
-export declare function createServerReference(id: string): (...args: any[]) => Promise<any>;
+export declare function cloneServerReference(id: string): (...args: any[]) => Promise<unknown>;
 export declare function createClientReference(Component: Component<any>, id: string): Component<any>;