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

package/dist/config/dev-server.js

@@ -1,126 +0,0 @@
-var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
-    if (typeof path === "string" && /^\.\.?\//.test(path)) {
-        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
-            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
-        });
-    }
-    return path;
-};
-import { NodeRequest, sendNodeResponse } from "srvx/node";
-import { isRunnableDevEnvironment, } from "vite";
-import { VITE_ENVIRONMENTS } from "./constants.js";
-export function devServer() {
-    return [
-        {
-            name: "solid-start-dev-server",
-            configurePreviewServer(server) {
-                return () => {
-                    server.middlewares.use(async (req, res) => {
-                        res.setHeader("content-encoding", "identity");
-                        const webReq = new NodeRequest({ req, res });
-                        const def = await import(__rewriteRelativeImportExtension(process.cwd() + "/dist/server/entry-server.js", true));
-                        sendNodeResponse(res, await def.default.fetch(webReq));
-                    });
-                };
-            },
-            configureServer(viteDevServer) {
-                globalThis.VITE_DEV_SERVER = viteDevServer;
-                return async () => {
-                    if (viteDevServer.config.server.middlewareMode)
-                        return;
-                    const serverEnv = viteDevServer.environments[VITE_ENVIRONMENTS.server];
-                    if (!serverEnv)
-                        throw new Error("Server environment not found");
-                    if (
-                    // do not check via `isFetchableDevEnvironment` since nitro does implement the `FetchableDevEnvironment` interface but not via inheritance (which this helper checks)
-                    "dispatchFetch" in serverEnv)
-                        return;
-                    // another plugin is controlling the dev server
-                    if (!isRunnableDevEnvironment(serverEnv)) {
-                        return;
-                    }
-                    globalThis.USING_SOLID_START_DEV_SERVER = true;
-                    removeHtmlMiddlewares(viteDevServer);
-                    viteDevServer.middlewares.use(async (req, res) => {
-                        if (req.originalUrl) {
-                            req.url = req.originalUrl;
-                        }
-                        const webReq = new NodeRequest({ req, res });
-                        try {
-                            const serverEntry = await serverEnv.runner.import("./src/entry-server.tsx");
-                            const webRes = await serverEntry.default.fetch(webReq);
-                            return sendNodeResponse(res, webRes);
-                        }
-                        catch (e) {
-                            console.error(e);
-                            viteDevServer.ssrFixStacktrace(e);
-                            if (webReq.headers.get("content-type")?.includes("application/json")) {
-                                return sendNodeResponse(res, Response.json({
-                                    status: 500,
-                                    error: "Internal Server Error",
-                                    message: "An unexpected error occurred. Please try again later.",
-                                    timestamp: new Date().toISOString(),
-                                }, {
-                                    status: 500,
-                                    headers: {
-                                        "Content-Type": "application/json",
-                                    },
-                                }));
-                            }
-                            return sendNodeResponse(res, new Response(`
-                    <!DOCTYPE html>
-                    <html lang="en">
-                      <head>
-                        <meta charset="UTF-8" />
-                        <title>Error</title>
-                        <script type="module">
-                          import { ErrorOverlay } from '/@vite/client'
-                          document.body.appendChild(new ErrorOverlay(${JSON.stringify(prepareError(req, e)).replace(/</g, "\\u003c")}))
-                        </script>
-                      </head>
-                      <body>
-                      </body>
-                    </html>
-                  `, {
-                                status: 500,
-                                headers: { "Content-Type": "text/html" },
-                            }));
-                        }
-                    });
-                };
-            },
-        },
-    ];
-}
-/**
- * Removes Vite internal middleware
- *
- * @param server
- */
-function removeHtmlMiddlewares(server) {
-    const html_middlewares = [
-        "viteIndexHtmlMiddleware",
-        "vite404Middleware",
-        "viteSpaFallbackMiddleware",
-    ];
-    for (let i = server.middlewares.stack.length - 1; i > 0; i--) {
-        if (html_middlewares.includes(
-        // @ts-expect-error
-        server.middlewares.stack[i].handle.name)) {
-            server.middlewares.stack.splice(i, 1);
-        }
-    }
-}
-/**
- * Formats error for SSR message in error overlay
- * @param req
- * @param error
- * @returns
- */
-function prepareError(req, error) {
-    const e = error;
-    return {
-        message: `An error occured while server rendering ${req.url}:\n\n\t${typeof e === "string" ? e : e.message} `,
-        stack: typeof e === "string" ? "" : e.stack,
-    };
-}

package/dist/config/env.d.ts

@@ -1,19 +0,0 @@
-import { type Plugin } from "vite";
-declare const LOADERS: {
-    node: string;
-    "cloudflare-workers": string;
-    "netlify-edge": string;
-};
-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;
-    };
-}
-export declare function envPlugin(options?: EnvPluginOptions): Plugin;
-export {};

package/dist/config/env.js

@@ -1,81 +0,0 @@
-import { loadEnv } 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);`,
-};
-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) {
-    let result = "";
-    for (const key in object) {
-        result += `export const ${key} = ${JSON.stringify(object[key])};`;
-    }
-    return result;
-}
-export function envPlugin(options) {
-    const currentOptions = options ?? {};
-    let env;
-    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] : 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/dist/config/fs-router.d.ts

@@ -1,37 +0,0 @@
-import { BaseFileSystemRouter, type FileSystemRouterConfig } from "./fs-routes/router.ts";
-export declare class SolidStartClientFileRouter extends BaseFileSystemRouter {
-    toPath(src: string): string;
-    toRoute(src: string): {
-        page: boolean;
-        $component: {
-            src: string;
-            pick: string[];
-        };
-        $$route: {
-            src: string;
-            pick: string[];
-        } | undefined;
-        path: string;
-    } | undefined;
-}
-export declare class SolidStartServerFileRouter extends BaseFileSystemRouter {
-    config: FileSystemRouterConfig & {
-        dataOnly?: boolean;
-    };
-    constructor(config: FileSystemRouterConfig & {
-        dataOnly?: boolean;
-    });
-    toPath(src: string): string;
-    toRoute(src: string): {
-        path: string;
-        page: boolean;
-        $component: {
-            src: string;
-            pick: string[];
-        } | undefined;
-        $$route: {
-            src: string;
-            pick: string[];
-        } | undefined;
-    } | undefined;
-}

package/dist/config/fs-router.js

@@ -1,141 +0,0 @@
-import { analyzeModule, BaseFileSystemRouter, cleanPath, } from "./fs-routes/router.js";
-export class SolidStartClientFileRouter extends BaseFileSystemRouter {
-    toPath(src) {
-        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) {
-        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, exports) {
-    const handlers = {};
-    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 {
-    constructor(config) {
-        super(config);
-    }
-    toPath(src) {
-        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) {
-        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/dist/config/fs-routes/fs-watcher.d.ts

@@ -1,3 +0,0 @@
-import type { PluginOption } from "vite";
-import type { BaseFileSystemRouter } from "./router.ts";
-export declare const fileSystemWatcher: (routers: Record<"client" | "ssr", BaseFileSystemRouter>) => PluginOption;

package/dist/config/fs-routes/fs-watcher.js

@@ -1,43 +0,0 @@
-import { VITE_ENVIRONMENTS } from "../constants.js";
-import { moduleId } from "./index.js";
-function setupWatcher(watcher, routes) {
-    watcher.on("unlink", path => routes.removeRoute(path));
-    watcher.on("add", path => routes.addRoute(path));
-    watcher.on("change", path => routes.updateRoute(path));
-}
-function createRoutesReloader(server, routes, environment) {
-    routes.addEventListener("reload", handleRoutesReload);
-    return () => routes.removeEventListener("reload", handleRoutesReload);
-    function handleRoutesReload() {
-        const envName = environment === "ssr" ? VITE_ENVIRONMENTS.server : VITE_ENVIRONMENTS.client;
-        const devEnv = server.environments[envName];
-        if (!devEnv?.moduleGraph)
-            return;
-        const mod = devEnv.moduleGraph.getModuleById(moduleId);
-        if (mod) {
-            const seen = new Set();
-            devEnv.moduleGraph.invalidateModule(mod, seen);
-        }
-        if (environment !== "ssr") {
-            if (mod) {
-                devEnv.reloadModule(mod);
-            }
-            else if (devEnv.hot) {
-                devEnv.hot.send({ type: "full-reload" });
-            }
-        }
-    }
-}
-export const fileSystemWatcher = (routers) => {
-    const plugin = {
-        name: "fs-watcher",
-        async configureServer(server) {
-            Object.keys(routers).forEach(environment => {
-                const router = globalThis.ROUTERS[environment];
-                setupWatcher(server.watcher, router);
-                createRoutesReloader(server, router, environment);
-            });
-        },
-    };
-    return plugin;
-};

package/dist/config/fs-routes/index.d.ts

@@ -1,7 +0,0 @@
-import { type PluginOption } from "vite";
-import type { BaseFileSystemRouter } from "./router.ts";
-export declare const moduleId = "solid-start:routes";
-export interface FsRoutesArgs {
-    routers: Record<"client" | "ssr", BaseFileSystemRouter>;
-}
-export declare function fsRoutes({ routers }: FsRoutesArgs): Array<PluginOption>;

package/dist/config/fs-routes/index.js

@@ -1,107 +0,0 @@
-import { relative } from "node:path";
-import { fileSystemWatcher } from "./fs-watcher.js";
-import { treeShake } from "./tree-shake.js";
-export const moduleId = "solid-start:routes";
-export function fsRoutes({ routers }) {
-    globalThis.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.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) => `pick=${p}`).join("&")}`;
-                        /**
-                         * @type {{ [key: string]: string }}
-                         */
-                        const refs = {};
-                        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) => `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) {
-        let id = imports.get(p);
-        if (!id) {
-            id = {};
-            imports.set(p, id);
-        }
-        const d = "routeData" + vars++;
-        id["default"] = d;
-        return d;
-    }
-    function addNamedImport(name, p) {
-        let id = imports.get(p);
-        if (!id) {
-            id = {};
-            imports.set(p, id);
-        }
-        const d = "routeData" + vars++;
-        id[name] = d;
-        return d;
-    }
-    const getNamedExport = (p) => {
-        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/dist/config/fs-routes/router.d.ts

@@ -1,37 +0,0 @@
-import { pathToRegexp } from "path-to-regexp";
-export { pathToRegexp };
-export declare const glob: (path: string) => string[];
-export type FileSystemRouterConfig = {
-    dir: string;
-    extensions: string[];
-};
-type Route = {
-    path: string;
-} & Record<string, any>;
-export declare function cleanPath(src: string, config: FileSystemRouterConfig): string;
-export declare function analyzeModule(src: string): readonly [imports: readonly import("es-module-lexer").ImportSpecifier[], exports: readonly import("es-module-lexer").ExportSpecifier[], facade: boolean, hasModuleSyntax: boolean];
-export declare class BaseFileSystemRouter extends EventTarget {
-    routes: Route[];
-    config: FileSystemRouterConfig;
-    /**
-     *
-     * @param {} config
-     */
-    constructor(config: FileSystemRouterConfig);
-    glob(): string;
-    buildRoutes(): Promise<any[]>;
-    isRoute(src: string): boolean;
-    toPath(src: string): void;
-    toRoute(src: string): Route | undefined;
-    /**
-     * To be attached by vite plugin to the vite dev server
-     */
-    update: undefined;
-    _addRoute(route: Route): void;
-    addRoute(src: string): Promise<void>;
-    reload(route: string): void;
-    updateRoute(src: string): Promise<void>;
-    removeRoute(src: string): void;
-    buildRoutesPromise?: Promise<any[]>;
-    getRoutes(): Promise<Route[]>;
-}