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

package/src/config/env.ts

@@ -1,105 +0,0 @@
-import { loadEnv, type Plugin } from "vite";
-
-const LOADERS = {
-  node: `export default key => process.env[key];`,
-  "cloudflare-workers": `import { env } from 'cloudflare:workers';export default key => env[key];`,
-  "netlify-edge": `export default key => Netlify.env.get(key);`,
-};
-
-export interface EnvPluginOptions {
-  server?: {
-    runtime?: keyof typeof LOADERS | (string & {});
-    load?: (mode: string) => Record<string, string>;
-    prefix?: string;
-  };
-  client?: {
-    load?: (mode: string) => Record<string, string>;
-    prefix?: string;
-  };
-}
-
-const SERVER_ENV = "env:server";
-const CLIENT_ENV = "env:client";
-
-const SERVER_RUNTIME_ENV = `${SERVER_ENV}/runtime`;
-
-const SERVER_RUNTIME_LOADER = `${SERVER_RUNTIME_ENV}/loader`;
-
-const DEFAULT_SERVER_PREFIX = "SERVER_";
-const DEFAULT_CLIENT_PREFIX = "CLIENT_";
-
-const SERVER_ONLY_MODULE = `throw new Error('Attempt to load server-only environment variables in client runtime.');`;
-
-const SERVER_RUNTIME_CODE = `import load from '${SERVER_RUNTIME_LOADER}';
-
-export default new Proxy({}, {
-  get(_, key) {
-    return load(key);
-  },
-})`;
-
-function convertObjectToModule(object: Record<string, string>): string {
-  let result = "";
-  for (const key in object) {
-    result += `export const ${key} = ${JSON.stringify(object[key])};`;
-  }
-  return result;
-}
-
-export function envPlugin(options?: EnvPluginOptions): Plugin {
-  const currentOptions = options ?? {};
-  let env: string;
-  const serverPrefix = currentOptions.server?.prefix ?? DEFAULT_SERVER_PREFIX;
-  const clientPrefix = currentOptions.client?.prefix ?? DEFAULT_CLIENT_PREFIX;
-  const runtime = options?.server?.runtime ?? "node";
-  const runtimeCode = runtime in LOADERS ? LOADERS[runtime as keyof typeof LOADERS] : runtime;
-
-  return {
-    name: "solid-start:env",
-    enforce: "pre",
-    configResolved(config) {
-      env = config.mode !== "production" ? "development" : "production";
-    },
-    resolveId(id) {
-      if (
-        id === SERVER_ENV ||
-        id === CLIENT_ENV ||
-        id === SERVER_RUNTIME_ENV ||
-        id === SERVER_RUNTIME_LOADER
-      ) {
-        return id;
-      }
-      return undefined;
-    },
-    load(id, opts) {
-      if (id === SERVER_ENV) {
-        if (!opts?.ssr) {
-          return SERVER_ONLY_MODULE;
-        }
-        const vars = currentOptions.server?.load
-          ? currentOptions.server.load(env)
-          : loadEnv(env, '.', serverPrefix);
-        return convertObjectToModule(vars);
-      }
-      if (id === CLIENT_ENV) {
-        const vars = currentOptions.client?.load
-          ? currentOptions.client.load(env)
-          : loadEnv(env, '.', clientPrefix);
-        return convertObjectToModule(vars);
-      }
-      if (id === SERVER_RUNTIME_LOADER) {
-        if (!opts?.ssr) {
-          return SERVER_ONLY_MODULE;
-        }
-        return runtimeCode;
-      }
-      if (id === SERVER_RUNTIME_ENV) {
-        if (!opts?.ssr) {
-          return SERVER_ONLY_MODULE;
-        }
-        return SERVER_RUNTIME_CODE;
-      }
-      return undefined;
-    },
-  };
-}

package/src/config/fs-router.ts

@@ -1,162 +0,0 @@
-import type { ExportSpecifier } from "es-module-lexer";
-import {
-  analyzeModule,
-  BaseFileSystemRouter,
-  cleanPath,
-  type FileSystemRouterConfig,
-} from "./fs-routes/router.ts";
-
-export class SolidStartClientFileRouter extends BaseFileSystemRouter {
-  toPath(src: string) {
-    const routePath = cleanPath(src, this.config)
-      // remove the initial slash
-      .slice(1)
-      .replace(/index$/, "")
-      .replace(/\[([^/]+)\]/g, (_, m) => {
-        if (m.length > 3 && m.startsWith("...")) {
-          return `*${m.slice(3)}`;
-        }
-        if (m.length > 2 && m.startsWith("[") && m.endsWith("]")) {
-          return `:${m.slice(1, -1)}?`;
-        }
-        return `:${m}`;
-      });
-
-    return routePath?.length > 0 ? `/${routePath}` : "/";
-  }
-
-  toRoute(src: string) {
-    const path = this.toPath(src);
-
-    if (src.endsWith(".md") || src.endsWith(".mdx")) {
-      return {
-        page: true,
-        $component: {
-          src: src,
-          pick: ["$css"],
-        },
-        $$route: undefined,
-        path,
-        // filePath: src
-      };
-    }
-
-    const [_, exports] = analyzeModule(src);
-    const hasDefault = !!exports.find(e => e.n === "default");
-    const hasRouteConfig = !!exports.find(e => e.n === "route");
-    if (hasDefault) {
-      return {
-        page: true,
-        $component: {
-          src: src,
-          pick: [
-            ...exports.filter(e => e.n === e.ln && e.n !== "route").map(e => e.n),
-            "default",
-            "$css",
-          ],
-        },
-        $$route: hasRouteConfig
-          ? {
-              src: src,
-              pick: ["route"],
-            }
-          : undefined,
-        path,
-        // filePath: src
-      };
-    }
-  }
-}
-
-const HTTP_METHODS = ["HEAD", "GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"];
-function createHTTPHandlers(src: string, exports: readonly ExportSpecifier[]) {
-  const handlers: Record<string, any> = {};
-  for (const exp of exports) {
-    if (HTTP_METHODS.includes(exp.n)) {
-      handlers[`$${exp.n}`] = {
-        src: src,
-        pick: [exp.n],
-      };
-      if (exp.n === "GET" && !exports.find(exp => exp.n === "HEAD")) {
-        handlers.$HEAD = {
-          src: src,
-          pick: [exp.n],
-        };
-      }
-    }
-  }
-
-  return handlers;
-}
-
-export class SolidStartServerFileRouter extends BaseFileSystemRouter {
-  declare config: FileSystemRouterConfig & { dataOnly?: boolean };
-
-  constructor(config: FileSystemRouterConfig & { dataOnly?: boolean }) {
-    super(config);
-  }
-
-  toPath(src: string) {
-    const routePath = cleanPath(src, this.config)
-      // remove the initial slash
-      .slice(1)
-      .replace(/index$/, "")
-      .replace(/\[([^/]+)\]/g, (_, m) => {
-        if (m.length > 3 && m.startsWith("...")) {
-          return `*${m.slice(3)}`;
-        }
-        if (m.length > 2 && m.startsWith("[") && m.endsWith("]")) {
-          return `:${m.slice(1, -1)}?`;
-        }
-        return `:${m}`;
-      });
-
-    return routePath?.length > 0 ? `/${routePath}` : "/";
-  }
-
-  toRoute(src: string) {
-    const path = this.toPath(src);
-    if (src.endsWith(".md") || src.endsWith(".mdx")) {
-      return {
-        page: true,
-        $component: {
-          src: src,
-          pick: ["$css"],
-        },
-        $$route: undefined,
-        path,
-      };
-    }
-
-    const [_, exports] = analyzeModule(src);
-    const hasRouteConfig = exports.find(e => e.n === "route");
-    const hasDefault = !!exports.find(e => e.n === "default");
-    const hasAPIRoutes = !!exports.find(exp => HTTP_METHODS.includes(exp.n));
-    if (hasDefault || hasAPIRoutes) {
-      return {
-        page: hasDefault,
-        $component:
-          !this.config.dataOnly && hasDefault
-            ? {
-                src: src,
-                pick: [
-                  ...exports
-                    .filter(e => e.n === e.ln && e.n !== "route" && !HTTP_METHODS.includes(e.n))
-                    .map(e => e.n),
-                  "default",
-                  "$css",
-                ],
-              }
-            : undefined,
-        $$route: hasRouteConfig
-          ? {
-              src: src,
-              pick: ["route"],
-            }
-          : undefined,
-        ...createHTTPHandlers(src, exports),
-        path,
-      };
-    }
-  }
-}

package/src/config/fs-routes/fs-watcher.ts

@@ -1,66 +0,0 @@
-import type { EnvironmentModuleNode, FSWatcher, PluginOption, ViteDevServer } from "vite";
-import { debounce } from "../../utils/debounce.ts";
-import { VITE_ENVIRONMENTS } from "../constants.ts";
-import { moduleId } from "./index.ts";
-import type { BaseFileSystemRouter } from "./router.ts";
-
-function setupWatcher(watcher: FSWatcher, routes: BaseFileSystemRouter): void {
-  watcher.on("unlink", path => routes.removeRoute(path));
-  watcher.on("add", path => routes.addRoute(path));
-  watcher.on("change", path => routes.updateRoute(path));
-}
-
-function createRoutesReloader(
-  server: ViteDevServer,
-  routes: BaseFileSystemRouter,
-  environment: "client" | "ssr",
-) {
-  const devEnv = server.environments[environment]!;
-  if (!devEnv?.moduleGraph) return;
-
-  /**
-   * Debounce catches multiple route changes in a row
-   * Short timeout for inexpensive invalidations
-   */
-  const invalidateModule = debounce((mod: EnvironmentModuleNode) => {
-    devEnv.moduleGraph.invalidateModule(mod);
-  }, 0);
-
-  /**
-   * Long debounce timeout for expensive reloads
-   */
-  const reloadModule = debounce((mod: EnvironmentModuleNode) => {
-    devEnv.reloadModule(mod);
-  }, 200);
-
-  return routes.on("reload", function handleRoutesReload(evt): void {
-    const mod = devEnv.moduleGraph.getModuleById(moduleId)!;
-    if (!mod) {
-      devEnv.hot.send({ type: "full-reload" });
-      return;
-    }
-
-    if (environment === VITE_ENVIRONMENTS.client && evt.detail.type !== "update") {
-      // Client has to be reloaded when routes are added or removed
-      reloadModule(mod);
-    } else {
-      invalidateModule(mod);
-    }
-  });
-}
-
-export const fileSystemWatcher = (
-  routers: Record<"client" | "ssr", BaseFileSystemRouter>,
-): PluginOption => {
-  const plugin: PluginOption = {
-    name: "fs-watcher",
-    async configureServer(server: ViteDevServer) {
-      for (const environment of [VITE_ENVIRONMENTS.server, VITE_ENVIRONMENTS.client]) {
-        const router = routers[environment];
-        setupWatcher(server.watcher, router);
-        createRoutesReloader(server, router, environment);
-      }
-    },
-  };
-  return plugin;
-};

package/src/config/fs-routes/index.ts

@@ -1,136 +0,0 @@
-import { relative } from "node:path";
-import { type PluginOption } from "vite";
-
-import { fileSystemWatcher } from "./fs-watcher.ts";
-import type { BaseFileSystemRouter } from "./router.ts";
-import { treeShake } from "./tree-shake.ts";
-
-export const moduleId = "solid-start:routes";
-
-export interface FsRoutesArgs {
-  routers: Record<"client" | "ssr", BaseFileSystemRouter>;
-}
-
-export function fsRoutes({ routers }: FsRoutesArgs): Array<PluginOption> {
-  (globalThis as any).ROUTERS = routers;
-
-  return [
-    {
-      name: "solid-start-fs-routes",
-      enforce: "pre",
-      resolveId(id) {
-        if (id === moduleId) return id;
-      },
-      async load(id) {
-        const root = this.environment.config.root;
-        const isBuild = this.environment.mode === "build";
-
-        if (id !== moduleId) return;
-        const js = jsCode();
-
-        const router = (globalThis as any).ROUTERS[this.environment.name];
-
-        const routes = await router.getRoutes();
-
-        let routesCode = JSON.stringify(routes ?? [], (k, v) => {
-          if (v === undefined) return undefined;
-
-          if (k.startsWith("$$")) {
-            const buildId = `${v.src}?${v.pick.map((p: any) => `pick=${p}`).join("&")}`;
-
-            /**
-             * @type {{ [key: string]: string }}
-             */
-            const refs: Record<string, string> = {};
-            for (var pick of v.pick) {
-              refs[pick] = js.addNamedImport(pick, buildId);
-            }
-            return {
-              require: `_$() => ({ ${Object.entries(refs)
-                .map(([pick, namedImport]) => `'${pick}': ${namedImport}`)
-                .join(", ")} })$_`,
-              // src: isBuild ? relative(root, buildId) : buildId
-            };
-          } else if (k.startsWith("$")) {
-            const buildId = `${v.src}?${v.pick.map((p: any) => `pick=${p}`).join("&")}`;
-            return {
-              src: relative(root, buildId),
-              build: isBuild ? `_$() => import('${buildId}')$_` : undefined,
-              import: `_$() => import('${buildId}')$_`,
-            };
-          }
-          return v;
-        });
-
-        routesCode = routesCode.replaceAll('"_$(', "(").replaceAll(')$_"', ")");
-
-        const code = `
-${js.getImportStatements()}
-export default ${routesCode}`;
-        return code;
-      },
-    },
-    treeShake(),
-    fileSystemWatcher(routers),
-  ];
-}
-
-function jsCode() {
-  const imports = new Map();
-  let vars = 0;
-
-  function addImport(p: any) {
-    let id = imports.get(p);
-    if (!id) {
-      id = {};
-      imports.set(p, id);
-    }
-
-    const d = "routeData" + vars++;
-    id["default"] = d;
-    return d;
-  }
-
-  function addNamedImport(name: string | number, p: any) {
-    let id = imports.get(p);
-    if (!id) {
-      id = {};
-      imports.set(p, id);
-    }
-
-    const d = "routeData" + vars++;
-    id[name] = d;
-    return d;
-  }
-
-  const getNamedExport = (p: any) => {
-    const id = imports.get(p);
-
-    delete id["default"];
-
-    return Object.keys(id).length > 0
-      ? `{ ${Object.keys(id)
-          .map(k => `${k} as ${id[k]}`)
-          .join(", ")} }`
-      : "";
-  };
-
-  const getImportStatements = () => {
-    return `${[...imports.keys()]
-      .map(
-        i =>
-          `import ${
-            imports.get(i).default
-              ? `${imports.get(i).default}${Object.keys(imports.get(i)).length > 1 ? ", " : ""}`
-              : ""
-          } ${getNamedExport(i)} from '${i}';`,
-      )
-      .join("\n")}`;
-  };
-
-  return {
-    addImport,
-    addNamedImport,
-    getImportStatements,
-  };
-}

package/src/config/fs-routes/router.ts

@@ -1,184 +0,0 @@
-import { init, parse } from "es-module-lexer";
-import esbuild from "esbuild";
-import fg from "fast-glob";
-import fs from "node:fs";
-import micromatch from "micromatch";
-import { posix } from "node:path";
-import { pathToRegexp } from "path-to-regexp";
-
-import { normalizePath } from "vite";
-
-export { pathToRegexp };
-
-export const glob = (path: string) => fg.sync(path, { absolute: true });
-
-export type FileSystemRouterConfig = { dir: string; extensions: string[] };
-type Route = { path: string } & Record<string, any>;
-
-export function cleanPath(src: string, config: FileSystemRouterConfig) {
-  return src
-    .slice(config.dir.length)
-    .replace(new RegExp(`\.(${(config.extensions ?? []).join("|")})$`), "");
-}
-
-export function analyzeModule(src: string) {
-  return parse(
-    esbuild.transformSync(fs.readFileSync(src, "utf-8"), {
-      jsx: "transform",
-      format: "esm",
-      loader: "tsx",
-    }).code,
-    src,
-  );
-}
-
-type RouterEvent = CustomEvent<{ route: string; type: "update" | "remove" | "add" }>;
-
-export class BaseFileSystemRouter extends EventTarget {
-  routes: Route[];
-
-  config: FileSystemRouterConfig;
-
-  /**
-   *
-   * @param {} config
-   */
-  constructor(config: FileSystemRouterConfig) {
-    super();
-    this.routes = [];
-    this.config = config;
-  }
-
-  glob() {
-    return (
-      posix.join(fg.convertPathToPattern(this.config.dir), "**/*") +
-      `.{${this.config.extensions.join(",")}}`
-    );
-  }
-
-  async buildRoutes(): Promise<any[]> {
-    await init;
-    for (var src of glob(this.glob())) {
-      await this.addRoute(src);
-    }
-
-    return this.routes;
-  }
-
-  isRoute(src: string) {
-    return Boolean(micromatch(src as any, this.glob())?.length);
-  }
-
-  toPath(src: string) {
-    throw new Error("Not implemented");
-  }
-
-  toRoute(src: string): Route | undefined {
-    let path = this.toPath(src);
-
-    if (path === undefined) return;
-
-    const [_, exports] = analyzeModule(src);
-
-    if (!exports.find(e => e.n === "default")) {
-      console.warn("No default export", src);
-    }
-
-    return {
-      $component: {
-        src: src,
-        pick: ["default", "$css"],
-      },
-      path,
-      // filePath: src
-    };
-  }
-
-  /**
-   * To be attached by vite plugin to the vite dev server
-   */
-  update = undefined;
-
-  _addRoute(route: Route) {
-    const idx = this.routes.findIndex(r => r.path === route.path);
-    if (idx >= 0) this.routes.splice(idx, 1);
-    this.routes.push(route);
-
-    return idx >= 0;
-  }
-
-  async addRoute(src: string) {
-    src = normalizePath(src);
-    if (this.isRoute(src)) {
-      try {
-        const route = this.toRoute(src);
-        if (route) {
-          this._addRoute(route);
-          this.reload(route.path, "add");
-        }
-      } catch (e) {
-        console.error(e);
-      }
-    }
-  }
-
-  reload(route: string, type: "update" | "remove" | "add") {
-    this.dispatchEvent(
-      new CustomEvent("reload", {
-        detail: {
-          route,
-          type,
-        },
-      }),
-    );
-  }
-
-  async updateRoute(src_: string) {
-    const src = normalizePath(src_);
-    if (this.isRoute(src)) {
-      try {
-        const route = this.toRoute(src);
-        if (route) {
-          const updated = this._addRoute(route);
-          this.reload(route.path, updated ? "update" : "add");
-        } else {
-          this.removeRoute(src_);
-        }
-      } catch (e) {
-        console.error(e);
-      }
-      // this.update?.();
-    }
-  }
-
-  removeRoute(src: string) {
-    src = normalizePath(src);
-    if (this.isRoute(src)) {
-      const path = this.toPath(src);
-      if (path === undefined) {
-        return;
-      }
-
-      const idx = this.routes.findIndex(r => r.path === path);
-      if (idx === -1) return;
-
-      this.routes.splice(idx, 1);
-      this.reload(path, "remove");
-    }
-  }
-
-  on(type: string, cb: (evt: RouterEvent) => void) {
-    this.addEventListener(type, cb as any);
-    return () => this.removeEventListener(type, cb as any);
-  }
-
-  buildRoutesPromise?: Promise<any[]>;
-
-  async getRoutes() {
-    if (!this.buildRoutesPromise) {
-      this.buildRoutesPromise = this.buildRoutes();
-    }
-    await this.buildRoutesPromise;
-    return this.routes;
-  }
-}