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

package/src/directives/compile.ts

@@ -1,54 +0,0 @@
-import * as babel from "@babel/core";
-import path from "node:path";
-import { directivesPlugin, type StateContext } from "./plugin.ts";
-import xxHash32 from "./xxhash32.ts";
-
-export interface CompileResult {
-  valid: boolean;
-  code: string;
-  map: babel.BabelFileResult["map"];
-}
-
-export type CompileOptions = Omit<StateContext, "count" | "hash" | "imports" | "valid">;
-
-export async function compile(
-  id: string,
-  code: string,
-  options: CompileOptions,
-): Promise<CompileResult> {
-  const context: StateContext = {
-    ...options,
-    valid: false,
-    hash: xxHash32(id).toString(16),
-    count: 0,
-    imports: new Map(),
-  };
-  const pluginOption = [directivesPlugin, context];
-  const plugins: NonNullable<NonNullable<babel.TransformOptions["parserOpts"]>["plugins"]> = [
-    "jsx",
-  ];
-  if (/\.[mc]?tsx?$/i.test(id)) {
-    plugins.push("typescript");
-  }
-  const result = await babel.transformAsync(code, {
-    plugins: [pluginOption],
-    parserOpts: {
-      plugins,
-    },
-    filename: path.basename(id),
-    ast: false,
-    sourceMaps: true,
-    configFile: false,
-    babelrc: false,
-    sourceFileName: id,
-  });
-
-  if (result) {
-    return {
-      valid: context.valid,
-      code: result.code || "",
-      map: result.map,
-    };
-  }
-  throw new Error("invariant");
-}

package/src/directives/generate-unique-name.ts

@@ -1,22 +0,0 @@
-import type * as babel from "@babel/core";
-import * as t from "@babel/types";
-
-export function generateUniqueName(path: babel.NodePath, name: string): t.Identifier {
-  let uid: string;
-  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/src/directives/get-descriptive-name.ts

@@ -1,39 +0,0 @@
-import type { NodePath } from "@babel/core";
-
-export function getDescriptiveName(path: NodePath, defaultName: string): string {
-  let current: NodePath | null = 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/src/directives/get-import-identifier.ts

@@ -1,34 +0,0 @@
-import type * as babel from "@babel/core";
-import * as t from "@babel/types";
-import { generateUniqueName } from "./generate-unique-name.ts";
-import type { ImportDefinition } from "./types.ts";
-
-export function getImportIdentifier(
-  imports: Map<string, t.Identifier>,
-  path: babel.NodePath,
-  registration: ImportDefinition,
-): t.Identifier {
-  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 as babel.NodePath<t.Program>).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/src/directives/get-root-statement-path.ts

@@ -1,14 +0,0 @@
-import type * as babel from "@babel/core";
-import * as t from "@babel/types";
-
-export function getRootStatementPath(path: babel.NodePath): babel.NodePath {
-  let current = path.parentPath;
-  while (current) {
-    const next = current.parentPath;
-    if (next && t.isProgram(next.node)) {
-      return current;
-    }
-    current = next;
-  }
-  return path;
-}

package/src/directives/index.ts

@@ -1,233 +0,0 @@
-import {
-  createFilter,
-  type EnvironmentModuleGraph,
-  type FilterPattern,
-  type Plugin,
-  type ViteDevServer,
-} from "vite";
-import { compile, type CompileOptions } from "./compile.ts";
-
-export interface ServerFunctionsFilter {
-  include?: FilterPattern;
-  exclude?: FilterPattern;
-}
-
-export interface ServerFunctionsOptions {
-  manifest: string;
-  runtime: {
-    server: string;
-    client: string;
-  };
-  filter?: ServerFunctionsFilter;
-}
-
-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";
-
-type Manifest = Record<CompileOptions["mode"], Set<string>>;
-
-function createManifest(): Manifest {
-  return {
-    server: new Set(),
-    client: new Set(),
-  };
-}
-
-interface DeferredPromise<T> {
-  reference: Promise<T>;
-  resolve: (value: T) => void;
-  reject: (value: any) => void;
-}
-
-function createDeferredPromise<T>(): DeferredPromise<T> {
-  let resolve: DeferredPromise<T>["resolve"];
-  let reject: DeferredPromise<T>["reject"];
-
-  return {
-    reference: new Promise((res, rej) => {
-      resolve = res;
-      reject = rej;
-    }),
-    resolve(value) {
-      resolve(value);
-    },
-    reject(value) {
-      reject(value);
-    },
-  };
-}
-
-class Debouncer<T> {
-  promise: DeferredPromise<T>;
-
-  private timeout: ReturnType<typeof setTimeout> | undefined;
-
-  constructor(private source: () => T) {
-    this.promise = createDeferredPromise();
-    this.defer();
-  }
-
-  defer(): void {
-    if (this.timeout) {
-      clearTimeout(this.timeout);
-      this.timeout = undefined;
-    }
-    this.timeout = setTimeout(() => {
-      this.promise.resolve(this.source());
-    }, 1000);
-  }
-}
-
-function mergeManifestRecord(
-  source: Set<string>,
-  target: Set<string>,
-): { invalidPreload: boolean; invalidated: string[] } {
-  const current = source.size;
-  for (const entry of target) {
-    source.add(entry);
-  }
-  return {
-    invalidPreload: current !== source.size,
-    invalidated: [...source],
-  };
-}
-
-function invalidateModule(moduleGraph: EnvironmentModuleGraph, path: string) {
-  const target = moduleGraph.getModuleById(path);
-  if (target) {
-    moduleGraph.invalidateModule(target);
-  }
-}
-
-function invalidateModules(
-  server: ViteDevServer | undefined,
-  result: ReturnType<typeof mergeManifestRecord>,
-  manifest: string,
-): void {
-  if (server) {
-    if (result.invalidPreload) {
-      invalidateModule(server.environments.client.moduleGraph, manifest);
-      invalidateModule(server.environments.ssr.moduleGraph, manifest);
-    }
-  }
-}
-
-
-export function serverFunctionsPlugin(options: ServerFunctionsOptions): Plugin[] {
-  const filter = createFilter(
-    options.filter?.include || DEFAULT_INCLUDE,
-    options.filter?.exclude || DEFAULT_EXCLUDE,
-  );
-
-  let env: CompileOptions["env"];
-
-  const manifest = createManifest();
-
-  const preload: Record<CompileOptions["mode"], Debouncer<string> | undefined> = {
-    server: undefined,
-    client: undefined,
-  };
-  let currentServer: ViteDevServer;
-
-  const clientOptions: Pick<CompileOptions, "directive" | "definitions"> = {
-    directive: DIRECTIVE,
-    definitions: {
-      register: {
-        kind: "named",
-        name: "createServerReference",
-        source: options.runtime.client,
-      },
-      clone: {
-        kind: "named",
-        name: "cloneServerReference",
-        source: options.runtime.client,
-      },
-    },
-  };
-  const serverOptions: Pick<CompileOptions, "directive" | "definitions"> = {
-    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/src/directives/is-statement-top-level.ts

@@ -1,13 +0,0 @@
-import type * as babel from "@babel/core";
-import type * as t from "@babel/types";
-
-export function isStatementTopLevel(path: babel.NodePath<t.Statement>): boolean {
-  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/src/directives/paths.ts

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