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

package/src/directives/plugin.ts

@@ -1,389 +0,0 @@
-import type * as babel from "@babel/core";
-import type { Binding } from "@babel/traverse";
-import * as t from "@babel/types";
-import { bubbleFunctionDeclaration } from "./bubble-function-declaration.ts";
-import { generateUniqueName } from "./generate-unique-name.ts";
-import { getDescriptiveName } from "./get-descriptive-name.ts";
-import { getImportIdentifier } from "./get-import-identifier.ts";
-import { getRootStatementPath } from "./get-root-statement-path.ts";
-import { isStatementTopLevel } from "./is-statement-top-level.ts";
-import { isPathValid, unwrapPath } from "./paths.ts";
-import { removeUnusedVariables } from "./remove-unused-variables.ts";
-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;
-  };
-}
-
-type ValidFunction = t.ArrowFunctionExpression | t.FunctionExpression;
-
-function isValidFunction(node: t.Node): node is ValidFunction {
-  return t.isArrowFunctionExpression(node) || t.isFunctionExpression(node);
-}
-
-function isDirectiveValid(ctx: StateContext, directives: t.Directive[]) {
-  for (let i = 0, len = directives.length; i < len; i++) {
-    if (directives[i]!.value.value === ctx.directive) {
-      return true;
-    }
-  }
-  return false;
-}
-
-function cleanDirectives(path: babel.NodePath<t.BlockStatement | t.Program>, target: string): void {
-  const newDirectives: t.Directive[] = [];
-  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: StateContext,
-  path: babel.NodePath<t.FunctionDeclaration | ValidFunction>,
-) {
-  const body = path.get("body");
-
-  if (isPathValid(body, t.isBlockStatement)) {
-    cleanDirectives(body, ctx.directive);
-  }
-}
-
-function isFunctionDirectiveValid(
-  ctx: StateContext,
-  path: babel.NodePath<t.FunctionDeclaration | ValidFunction>,
-) {
-  const body = path.get("body");
-
-  if (isPathValid(body, t.isBlockStatement)) {
-    return isDirectiveValid(ctx, body.node.directives);
-  }
-
-  return false;
-}
-
-function createID(ctx: StateContext, name: string) {
-  const base = `${ctx.hash}-${ctx.count++}`;
-  if (ctx.env === "development") {
-    return `${base}-${name}`;
-  }
-  return base;
-}
-
-function transformFunction(
-  ctx: StateContext,
-  path: babel.NodePath<ValidFunction>,
-  direct: boolean,
-) {
-  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: babel.NodePath, name: string): Binding | undefined {
-  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: StateContext, binding: Binding) {
-  if (isPathValid(binding.path, t.isVariableDeclarator)) {
-    const right = unwrapPath(binding.path.get("init"), isValidFunction);
-    if (right) {
-      transformFunction(ctx, right, true);
-    }
-  }
-}
-
-interface State extends babel.PluginPass {
-  opts: StateContext;
-}
-
-function transformModuleLevelDirective(ctx: StateContext, program: babel.NodePath<t.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<Binding>();
-
-    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<Binding>();
-    const exportedBindings = new Map<string, Binding>();
-
-    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<Binding, string>();
-    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: t.VariableDeclarator[] = [];
-    const specifiers: t.ExportSpecifier[] = [];
-
-    const declarationMap = new Map<Binding, t.Identifier>();
-
-    // 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: t.Statement[] = [];
-
-    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(): babel.PluginObj<State> {
-  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/src/directives/remove-unused-variables.ts

@@ -1,70 +0,0 @@
-import type * as babel from "@babel/core";
-import * as t from "@babel/types";
-import { isPathValid } from "./paths.ts";
-
-function isInvalidForRemoval(path: babel.NodePath) {
-  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: babel.NodePath<t.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/xxhash32.ts

@@ -1,214 +0,0 @@
-// @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: string): Uint8Array {
-  const bytes: number[] = [];
-  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: Uint8Array | string,
-  seed = 0,
-): number {
-  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/src/env.d.ts

@@ -1,17 +0,0 @@
-// This file contains global type definitions that are internal to SolidStart and are not exported
-
-declare module "solid-start:server-fn-manifest" {
-  type ServerFn = (...args: Array<any>) => Promise<any>;
-  export function getServerFnById(id: string): Promise<ServerFn>;
-}
-
-interface ImportMetaEnv extends SolidStartMetaEnv {}
-
-interface SolidStartMetaEnv {
-  START_SSR: boolean;
-  START_APP_ENTRY: string;
-  START_CLIENT_ENTRY: string;
-  START_ISLANDS: boolean;
-  // START_DEV_OVERLAY: boolean;
-  // SERVER_BASE_URL: string;
-}