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

package/src/config/manifest.ts

@@ -1,120 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { type PluginOption, type ViteDevServer, version as viteVersion } from "vite";
-import { fileURLToPath } from "node:url";
-
-import { findStylesInModuleGraph } from "../server/collect-styles.ts";
-import { VIRTUAL_MODULES } from "./constants.ts";
-import { type SolidStartOptions } from "./index.ts";
-import { wrapId } from "./vite-utils.ts";
-
-export function manifest(start: SolidStartOptions): PluginOption {
-  let devServer: ViteDevServer = undefined!;
-  return {
-    name: "solid-start:manifest-plugin",
-    enforce: "pre",
-    configureServer(server) {
-      devServer = server;
-    },
-    async resolveId(id) {
-      if (id === VIRTUAL_MODULES.clientViteManifest)
-        return `\0${VIRTUAL_MODULES.clientViteManifest}`;
-      if (id === VIRTUAL_MODULES.getClientManifest)
-        return this.resolve(
-          fileURLToPath(new URL("../server/manifest/client-manifest", import.meta.url)),
-        );
-      if (id === VIRTUAL_MODULES.getManifest) {
-        return this.environment.config.consumer === "client"
-          ? this.resolve(
-              fileURLToPath(new URL("../server/manifest/client-manifest", import.meta.url)),
-            )
-          : this.resolve(
-              fileURLToPath(new URL("../server/manifest/ssr-manifest", import.meta.url)),
-            );
-      }
-      if (id === VIRTUAL_MODULES.middleware) {
-        if (start.middleware) return await this.resolve(start.middleware);
-        return `\0${VIRTUAL_MODULES.middleware}`;
-      }
-    },
-    async load(id) {
-      if (id === `\0${VIRTUAL_MODULES.clientViteManifest}`) {
-        let clientViteManifest: Record<string, Record<string, any>>;
-        if (this.environment.config.command === "serve") {
-          clientViteManifest = {};
-        } else {
-          const entry = Object.values(globalThis.START_CLIENT_BUNDLE).find(
-            v => "isEntry" in v && v.isEntry,
-          );
-          if (!entry) throw new Error("No client entry found");
-          let rawManifest: string | undefined;
-
-          const viteMajor = parseInt(viteVersion.split('.')[0]!, 10);
-
-          const manifestKey = Object.keys(globalThis.START_CLIENT_BUNDLE).find(k => k.endsWith("manifest.json"));
-          if (manifestKey && viteMajor < 8) {
-            const manifestAsset = globalThis.START_CLIENT_BUNDLE[manifestKey] as any;
-            rawManifest = manifestAsset.source as string;
-          } else {
-             try {
-               const appRoot = (start as any).appRoot || "./src";
-               let outDir = ".solid-start/client";
-               if (devServer?.environments?.client?.config?.build?.outDir) {
-                 outDir = devServer.environments.client.config.build.outDir;
-               } else if (this.environment?.config?.build?.outDir && this.environment?.config?.consumer === "client") {
-                 outDir = this.environment.config.build.outDir;
-               } else if ((globalThis as any).START_CLIENT_OUT_DIR) {
-                 outDir = (globalThis as any).START_CLIENT_OUT_DIR;
-               }
-               const manifestPath = path.resolve(appRoot, "..", outDir, ".vite/manifest.json");
-               rawManifest = fs.readFileSync(manifestPath, "utf-8");
-             } catch (e) {
-               throw new Error(`Manifest asset not found in bundle and could not be read from disk. Keys: ${Object.keys(globalThis.START_CLIENT_BUNDLE).join(", ")}. Error: ${e}`);
-             }
-          }
-
-          if (!rawManifest) {
-            throw new Error("Failed to extract or read raw manifest.");
-          }
-
-          clientViteManifest = JSON.parse(rawManifest);
-        }
-        return `export const clientViteManifest = ${JSON.stringify(clientViteManifest)};`;
-      } else if (id === `\0${VIRTUAL_MODULES.middleware}`) return "export default {};";
-      else if (id.startsWith("/@manifest")) {
-        if (this.environment.mode !== "dev")
-          throw new Error("@manifest queries are only allowed in dev");
-
-        const [urlPath, query] = id.split("?");
-        const target = id.split("/")[2]!;
-        const params = new URLSearchParams(query);
-        if (!urlPath || !query) return;
-        if (urlPath.endsWith("assets")) {
-          const id = params.get("id");
-          if (!id) {
-            throw new Error("Missing id to get assets.");
-          }
-
-          // Client env does not have css dependencies in mod.transformResult
-          // Aalways use ssr env instead, to prevent hydration mismatches
-          const env = devServer.environments["ssr"];
-          const styles = await findStylesInModuleGraph(env, id);
-
-          const cssAssets = Object.entries(styles).map(
-            ([key, value]) => `{
-						tag: "style",
-						attrs: {
-							type: "text/css",
-							"data-vite-dev-id": "${wrapId(key)}",
-							"data-vite-ref": "0",
-						},
-						children: () => import("${wrapId(value)}?inline").then(mod => mod.default),
-					}`,
-          );
-
-          return `export default [${cssAssets.join(",")}]`;
-        }
-      }
-    },
-  };
-}

package/src/config/utils.ts

@@ -1,5 +0,0 @@
-export function parseIdQuery(id: string) {
-  if (!id.includes("?")) return { filename: id, query: new URLSearchParams() };
-  const [filename, rawQuery] = id.split(`?`, 2) as [string, string];
-  return { filename, query: new URLSearchParams(rawQuery) };
-}

package/src/config/vite-utils.ts

@@ -1,113 +0,0 @@
-import type { DevEnvironment, Rollup } from "vite";
-import fs from "node:fs";
-import path from "node:path";
-
-const postfixRE = /[?#].*$/;
-export function cleanUrl(url: string): string {
-  return url.replace(postfixRE, "");
-}
-
-export const FS_PREFIX = `/@fs/`;
-
-export const VALID_ID_PREFIX = `/@id/`;
-
-export const NULL_BYTE_PLACEHOLDER = `__x00__`;
-const NULL_BYTE_REGEX = /^\0/;
-
-export function normalizeResolvedIdToUrl(
-  environment: DevEnvironment,
-  url: string,
-  resolved: Rollup.PartialResolvedId,
-): string {
-  const root = environment.config.root;
-  const depsOptimizer = environment.depsOptimizer;
-
-  // normalize all imports into resolved URLs
-  // e.g. `import 'foo'` -> `import '/@fs/.../node_modules/foo/index.js'`
-  if (resolved.id.startsWith(withTrailingSlash(root))) {
-    // in root: infer short absolute path from root
-    url = resolved.id.slice(root.length);
-  } else if (
-    depsOptimizer?.isOptimizedDepFile(resolved.id) ||
-    // vite-plugin-react isn't following the leading \0 virtual module convention.
-    // This is a temporary hack to avoid expensive fs checks for React apps.
-    // We'll remove this as soon we're able to fix the react plugins.
-    (resolved.id !== "/@react-refresh" &&
-      path.isAbsolute(resolved.id) &&
-      fs.existsSync(cleanUrl(resolved.id)))
-  ) {
-    // an optimized deps may not yet exists in the filesystem, or
-    // a regular file exists but is out of root: rewrite to absolute /@fs/ paths
-    url = path.posix.join(FS_PREFIX, resolved.id);
-  } else {
-    url = resolved.id;
-  }
-
-  // if the resolved id is not a valid browser import specifier,
-  // prefix it to make it valid. We will strip this before feeding it
-  // back into the transform pipeline
-  if (url[0] !== "." && url[0] !== "/") {
-    url = wrapId(resolved.id);
-  }
-
-  return url;
-}
-
-/**
- * Inspired by:
- * https://github.com/withastro/astro/blob/fddde5fad81007795eb263c7fd0cea096b8e2cba/packages/astro/src/core/util.ts#L115
- * https://github.com/vitejs/vite/blob/130e7181a55c524383c63bbfb1749d0ff7185cad/packages/vite/src/shared/utils.ts#L11
- */
-export function wrapId(id: string): string {
-  return id.replace(NULL_BYTE_REGEX, `${VALID_ID_PREFIX}${NULL_BYTE_PLACEHOLDER}`);
-}
-
-export function unwrapId(id: string): string {
-  return id.startsWith(VALID_ID_PREFIX)
-    ? id.slice(VALID_ID_PREFIX.length).replace(NULL_BYTE_PLACEHOLDER, "\0")
-    : id;
-}
-
-export function normalizeViteImportAnalysisUrl(environment: DevEnvironment, id: string): string {
-  let url = normalizeResolvedIdToUrl(environment, id, { id });
-
-  // https://github.com/vitejs/vite/blob/c18ce868c4d70873406e9f7d1b2d0a03264d2168/packages/vite/src/node/plugins/importAnalysis.ts#L416
-  if (environment.config.consumer === "client") {
-    const mod = environment.moduleGraph.getModuleById(id);
-    if (mod && mod.lastHMRTimestamp > 0) {
-      url = injectQuery(url, `t=${mod.lastHMRTimestamp}`);
-    }
-  }
-
-  return url;
-}
-
-export function withTrailingSlash(path: string): string {
-  if (path[path.length - 1] !== "/") {
-    return `${path}/`;
-  }
-  return path;
-}
-
-export function splitFileAndPostfix(path: string): {
-  file: string;
-  postfix: string;
-} {
-  const file = cleanUrl(path);
-  return { file, postfix: path.slice(file.length) };
-}
-
-const windowsSlashRE = /\\/g;
-export function slash(p: string): string {
-  return p.replace(windowsSlashRE, "/");
-}
-
-const isWindows = typeof process !== "undefined" && process.platform === "win32";
-
-export function injectQuery(url: string, queryToInject: string): string {
-  const { file, postfix } = splitFileAndPostfix(url);
-  const normalizedFile = isWindows ? slash(file) : file;
-  return `${normalizedFile}?${queryToInject}${
-    postfix[0] === "?" ? `&${postfix.slice(1)}` : /* hash only */ postfix
-  }`;
-}

package/src/directives/bubble-function-declaration.ts

@@ -1,33 +0,0 @@
-import type * as babel from "@babel/core";
-import * as t from "@babel/types";
-
-export function bubbleFunctionDeclaration(path: babel.NodePath<t.FunctionDeclaration>): void {
-  const decl = path.node;
-  // Check if declaration is FunctionDeclaration
-  if (decl.id) {
-    const block = (path.findParent(current => current.isBlockStatement()) ||
-      path.scope.getProgramParent().path) as babel.NodePath<t.BlockStatement>;
-
-    if (path.parentPath.isExportNamedDeclaration()) {
-      path.parentPath.replaceWith(
-        t.exportNamedDeclaration(undefined, [t.exportSpecifier(decl.id, decl.id)]),
-      );
-    } else if (path.parentPath.isExportDefaultDeclaration()) {
-      path.replaceWith(decl.id);
-    } else {
-      path.remove();
-    }
-
-    const [tmp] = block.unshiftContainer(
-      "body",
-      t.variableDeclaration("const", [
-        t.variableDeclarator(
-          decl.id,
-          t.functionExpression(decl.id, decl.params, decl.body, decl.generator, decl.async),
-        ),
-      ]),
-    );
-    block.scope.registerDeclaration(tmp);
-    tmp.skip();
-  }
-}

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