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

package/src/config/index.ts

@@ -1,239 +0,0 @@
-import { defu } from "defu";
-import { globSync } from "node:fs";
-import { extname, isAbsolute, join } from "node:path";
-import type { PluginOption } from "vite";
-import solid, { type Options as SolidOptions } from "vite-plugin-solid";
-import { type ServerFunctionsOptions, serverFunctionsPlugin } from "../directives/index.ts";
-import { DEFAULT_EXTENSIONS, VIRTUAL_MODULES, VITE_ENVIRONMENTS } from "./constants.ts";
-import { devServer } from "./dev-server.ts";
-import { envPlugin, type EnvPluginOptions } from "./env.ts";
-import { SolidStartClientFileRouter, SolidStartServerFileRouter } from "./fs-router.ts";
-import { fsRoutes } from "./fs-routes/index.ts";
-import type { BaseFileSystemRouter } from "./fs-routes/router.ts";
-import lazy from "./lazy.ts";
-import { manifest } from "./manifest.ts";
-import { parseIdQuery } from "./utils.ts";
-
-export interface SolidStartOptions {
-  solid?: Partial<SolidOptions>;
-  ssr?: boolean;
-  routeDir?: string;
-  extensions?: string[];
-  middleware?: string;
-  serialization?: {
-    /**
-     * The serialization mode to use for server functions/actions.
-     * The "js" mode uses a custom binary format that is more efficient than JSON, but requires a custom deserializer (with `eval()`) on the client.
-     * A strong CSP should block `eval()` executions, which would prevent the "js" mode from working.
-     * The "json" mode uses JSON for serialization, which is less efficient but can be deserialized with `JSON.parse` on the client.
-     *
-     * @default "json"
-     */
-    mode?: "js" | "json";
-  };
-  env?: EnvPluginOptions;
-  serverFunctions?: Pick<ServerFunctionsOptions, "filter">;
-}
-
-const absolute = (path: string, root: string) =>
-  path ? (isAbsolute(path) ? path : join(root, path)) : path;
-
-export function solidStart(options?: SolidStartOptions): Array<PluginOption> {
-  const start = defu(options ?? {}, {
-    appRoot: "./src",
-    routeDir: "./routes",
-    ssr: true,
-    devOverlay: true,
-    experimental: {
-      islands: false,
-    },
-    solid: {},
-    extensions: [],
-  });
-  const extensions = [...DEFAULT_EXTENSIONS, ...(start.extensions || [])];
-  const routeDir = join(start.appRoot, start.routeDir);
-  const root = process.cwd();
-  const appEntryPath = globSync(join(root, start.appRoot, "app.{j,t}sx"))[0];
-  if (!appEntryPath) {
-    throw new Error(`Could not find an app jsx/tsx entry in ${start.appRoot}.`);
-  }
-  const entryExtension = extname(appEntryPath);
-  const handlers = {
-    client: `${start.appRoot}/entry-client${entryExtension}`,
-    server: `${start.appRoot}/entry-server${entryExtension}`,
-  };
-  return [
-    // TODO (Alexis): check if the comment below is still relevant
-    //
-    // Must be placed after fsRoutes, as treeShake will remove the
-    // server fn exports added in by this plugin
-    serverFunctionsPlugin({
-      manifest: VIRTUAL_MODULES.serverFnManifest,
-      runtime: {
-        server: '@solidjs/start/fns/server',
-        client: '@solidjs/start/fns/client',
-      },
-      filter: options?.serverFunctions?.filter,
-    }),
-    {
-      name: "solid-start:config",
-      enforce: "pre",
-      configEnvironment(name) {
-        return {
-          resolve: {
-            // remove when https://github.com/solidjs/vite-plugin-solid/pull/228 is released
-            externalConditions: ["solid", "node"],
-          },
-        };
-      },
-      async config(_, env) {
-        const clientInput = [handlers.client];
-        if (env.command === "build") {
-          const clientRouter: BaseFileSystemRouter = (globalThis as any).ROUTERS.client;
-          for (const route of await clientRouter.getRoutes()) {
-            for (const [key, value] of Object.entries(route)) {
-              if (value && key.startsWith("$") && !key.startsWith("$$")) {
-                function toRouteId(route: any) {
-                  return `${route.src}?${route.pick.map((p: string) => `pick=${p}`).join("&")}`;
-                }
-                clientInput.push(toRouteId(value));
-              }
-            }
-          }
-        }
-        return {
-          appType: "custom",
-          build: { assetsDir: "_build/assets" },
-          optimizeDeps: {
-            // Suppress TS errors from Vite 7 types when configuring Vite 8's Rolldown
-            ...({
-              rolldownOptions: {
-                transform: {
-                  jsx: "react",
-                },
-              },
-            } as any),
-          },
-          environments: {
-            [VITE_ENVIRONMENTS.client]: {
-              consumer: "client",
-              build: {
-                write: true,
-                manifest: true,
-                outDir: "dist/client",
-                rollupOptions: {
-                  input: clientInput,
-                  treeshake: true,
-                  preserveEntrySignatures: "exports-only",
-                },
-              },
-            },
-            [VITE_ENVIRONMENTS.server]: {
-              consumer: "server",
-              build: {
-                ssr: true,
-                write: true,
-                manifest: true,
-                copyPublicDir: false,
-                rollupOptions: {
-                  input: "~/entry-server.tsx",
-                },
-                outDir: "dist/server",
-                commonjsOptions: {
-                  include: [/node_modules/],
-                },
-              },
-            },
-          },
-          resolve: {
-            alias: {
-              "@solidjs/start/server/entry": handlers.server,
-              "~": join(process.cwd(), start.appRoot),
-              ...(!start.ssr
-                ? {
-                    "@solidjs/start/server": "@solidjs/start/server/spa",
-                    "@solidjs/start/client": "@solidjs/start/client/spa",
-                  }
-                : {}),
-            },
-            // Depending on the package manager and dependency structure Vite externalizes @solidjs/start
-            // This makes sure that @solidjs/start goes through the Vite build process
-            noExternal: ["@solidjs/start"],
-          },
-          define: {
-            "import.meta.env.MANIFEST": `globalThis.MANIFEST`,
-            "import.meta.env.START_SSR": JSON.stringify(start.ssr),
-            // Use JSON.stringify so backslashes on Windows are escaped and
-            // esbuild receives a valid JS string literal for the define value
-            "import.meta.env.START_APP_ENTRY": JSON.stringify(appEntryPath),
-            "import.meta.env.START_CLIENT_ENTRY": JSON.stringify(handlers.client),
-            "import.meta.env.START_DEV_OVERLAY": JSON.stringify(start.devOverlay),
-            "import.meta.env.SEROVAL_MODE": JSON.stringify(start.serialization?.mode || "json"),
-          },
-          builder: {
-            sharedPlugins: true,
-            async buildApp(builder) {
-              const client = builder.environments[VITE_ENVIRONMENTS.client];
-              const server = builder.environments[VITE_ENVIRONMENTS.server];
-
-              if (!client) throw new Error("Client environment not found");
-              if (!server) throw new Error("SSR environment not found");
-
-              if (!client.isBuilt) await builder.build(client);
-              if (!server.isBuilt) await builder.build(server);
-            },
-          },
-        };
-      },
-    },
-    manifest(start),
-    fsRoutes({
-      routers: {
-        client: new SolidStartClientFileRouter({
-          dir: absolute(routeDir, root),
-          extensions,
-        }),
-        ssr: new SolidStartServerFileRouter({
-          dir: absolute(routeDir, root),
-          extensions,
-          dataOnly: !start.ssr,
-        }),
-      },
-    }),
-    lazy(),
-    envPlugin(options?.env),
-    {
-      name: "solid-start:virtual-modules",
-      async resolveId(id) {
-        const { filename, query } = parseIdQuery(id);
-
-        let base;
-        if (filename === VIRTUAL_MODULES.clientEntry) base = handlers.client;
-        if (filename === VIRTUAL_MODULES.serverEntry) base = handlers.server;
-        if (filename === VIRTUAL_MODULES.app) base = appEntryPath;
-
-        if (base) {
-          let id = (await this.resolve(base))?.id;
-          if (!id) return;
-
-          if (query.size > 0) id += `?${query.toString()}`;
-          return id;
-        }
-      },
-    },
-    {
-      name: "solid-start:capture-client-bundle",
-      enforce: "post",
-      generateBundle(options, bundle) {
-        globalThis.START_CLIENT_BUNDLE = bundle;
-        (globalThis as any).START_CLIENT_OUT_DIR = options.dir;
-      },
-    },
-    devServer(),
-    solid({
-      ...start.solid,
-      ssr: true,
-      extensions: extensions.map(ext => `.${ext}`),
-    }),
-  ];
-}

package/src/config/lazy.ts

@@ -1,132 +0,0 @@
-import type { PluginItem } from "@babel/core";
-import babel from "@babel/core";
-import * as t from "@babel/types";
-import { sep as osSep } from "node:path";
-import { basename, relative, sep } from "node:path/posix";
-import type { PluginOption } from "vite";
-import { VITE_ENVIRONMENTS } from "./constants.ts";
-
-const idTransform = (id: string): PluginItem => {
-  return {
-    visitor: {
-      Program(path) {
-        path.node.body.unshift(
-          t.exportNamedDeclaration(
-            t.variableDeclaration("const", [
-              t.variableDeclarator(t.identifier("id$$"), t.stringLiteral(id)),
-            ]),
-          ),
-        );
-      },
-    },
-  };
-};
-
-const importTransform = (): PluginItem => {
-  return {
-    visitor: {
-      ImportDeclaration(path) {
-        if (path.node.source.value !== "solid-js") return;
-        path.traverse({
-          ImportSpecifier(subPath) {
-            if (subPath.node.local.name !== "lazy") return;
-            subPath.remove();
-            path.insertAfter(
-              t.importDeclaration(
-                [t.importSpecifier(t.identifier("lazy"), t.identifier("lazy"))],
-                t.stringLiteral("@solidjs/start/server"),
-              ),
-            );
-          },
-        });
-      },
-    },
-  };
-};
-
-const fileEndingRegex = /(ts|js)x(\?.*)?$/;
-
-const lazy = (): PluginOption => {
-  const cwd = process.cwd().replaceAll(osSep, sep);
-
-  /**
-   * Maps module ids to their client-specific shared chunk names.
-   * Modules in shared chunks need to find their assets via the chunk name, instead of their module id.
-   *
-   * Vite includes assets of such modules in the manifest via the chunk name:
-   * https://github.com/vitejs/vite/blob/4be37a8389c67873880f826b01fe40137e1c29a7/packages/vite/src/node/plugins/manifest.ts#L179
-   * https://github.com/vitejs/vite/blob/4be37a8389c67873880f826b01fe40137e1c29a7/packages/vite/src/node/plugins/manifest.ts#L319
-   *
-   * Rollup occassionally creates shared chunks automatically,
-   * but they can also be manually created by the user via:
-   * https://rollupjs.org/configuration-options/#output-manualchunks
-   *
-   * More infos on Rollup's logic:
-   * https://github.com/rollup/rollup/issues/3772#issuecomment-689955168
-   */
-  const sharedChunkNames: Record<string, string> = {};
-
-  return {
-    name: "solid-lazy-css",
-    enforce: "pre",
-    generateBundle(_, bundle) {
-      if (this.environment.name !== VITE_ENVIRONMENTS.client) return;
-
-      for (const chunk of Object.values(bundle)) {
-        if (chunk.type !== "chunk" || !chunk.isDynamicEntry || chunk.facadeModuleId) continue;
-
-        // Has to follow Vites implementation:
-        // https://github.com/vitejs/vite/blob/4be37a8389c67873880f826b01fe40137e1c29a7/packages/vite/src/node/plugins/manifest.ts#L179
-        const chunkName = `_${basename(chunk.fileName)}`;
-        for (const id of chunk.moduleIds) {
-          sharedChunkNames[id] = chunkName;
-        }
-      }
-    },
-    async transform(src, id) {
-      if (this.environment.name !== VITE_ENVIRONMENTS.server) return;
-      if (!id.match(fileEndingRegex)) return;
-
-      // The transformed files either import "lazy" or css files
-      // Therefore we skip, if the src doesn't have any import
-      if (src.indexOf("import") === -1) return;
-      if (id.includes("entry-server")) return;
-
-      const plugins: PluginItem[] = [];
-
-      const hasDefaultExport = src.indexOf("export default") !== -1;
-      if (hasDefaultExport) {
-        const localId = relative(cwd, id);
-        const chunkName = sharedChunkNames[id];
-        plugins.push(idTransform(chunkName ?? localId));
-      }
-
-      const hasLazy = src.indexOf("lazy(") !== -1;
-      if (hasLazy) plugins.push(importTransform());
-
-      if (!plugins.length) {
-        return;
-      }
-
-      const transformed = await babel.transformAsync(src, {
-        plugins,
-        parserOpts: {
-          plugins: ["jsx", "typescript"],
-        },
-        filename: basename(id),
-        ast: false,
-        sourceMaps: true,
-        configFile: false,
-        babelrc: false,
-        sourceFileName: id,
-      });
-
-      if (!transformed?.code) return;
-
-      const { code, map } = transformed;
-      return { code, map };
-    },
-  };
-};
-
-export default lazy;

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