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

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @solidjs/start
 
+## 2.0.0-beta.3
+
+### Patch Changes
+
+- 12dc2d3: Bundle `h3` and `cookie-es` into server builds to avoid resolving incompatible hoisted versions
+
+## 2.0.0-beta.2
+
+### Patch Changes
+
+- 3e961e0: Require Vite 8
+- 11907a2: Fix published package missing `dist/`: pnpm 11 respects `.gitignore` when packing a package without a `files` field, so `2.0.0-beta.1` was published without its build output. Add an explicit `files` field.
+
 ## 2.0.0-beta.1
 
 ### Patch Changes

package/dist/client/StartClient.d.ts

@@ -0,0 +1,7 @@
+import type { JSX } from "solid-js";
+/**
+ *
+ * Read more: https://docs.solidjs.com/solid-start/reference/client/start-client
+ */
+export declare function StartClient(): JSX.Element;
+export declare function StartClientTanstack(): JSX.Element;

package/{src/client/StartClient.tsx → dist/client/StartClient.jsx}

@@ -1,34 +1,26 @@
 // @refresh skip
 import App from "solid-start:app";
-import type { JSX } from "solid-js";
-import { ErrorBoundary } from "../shared/ErrorBoundary.tsx";
-
-function Dummy(props: { children: JSX.Element }) {
-  return props.children;
+import { ErrorBoundary } from "../shared/ErrorBoundary.jsx";
+function Dummy(props) {
+    return props.children;
 }
-
 /**
  *
  * Read more: https://docs.solidjs.com/solid-start/reference/client/start-client
  */
 export function StartClient() {
-  return (
-    <Dummy>
+    return (<Dummy>
       <Dummy>
         <ErrorBoundary>
           <App />
         </ErrorBoundary>
       </Dummy>
-    </Dummy>
-  );
+    </Dummy>);
 }
-
 export function StartClientTanstack() {
-  return (
-    <Dummy>
+    return (<Dummy>
       <ErrorBoundary>
         <App />
       </ErrorBoundary>
-    </Dummy>
-  );
+    </Dummy>);
 }

package/dist/client/index.jsx

@@ -0,0 +1,2 @@
+export { mount } from "./mount.js";
+export { StartClient, StartClientTanstack } from "./StartClient.jsx";

package/dist/client/mount.d.ts

@@ -0,0 +1 @@
+export { hydrate as mount } from "solid-js/web";

package/dist/client/mount.js

@@ -0,0 +1 @@
+export { hydrate as mount } from "solid-js/web";

package/dist/client/spa/index.d.ts

@@ -0,0 +1,4 @@
+import type { JSX } from "solid-js";
+import { type MountableElement } from "solid-js/web";
+export declare function mount(fn: () => JSX.Element, el: MountableElement): void;
+export { StartClient } from "../StartClient.tsx";

package/dist/client/spa/index.jsx

@@ -0,0 +1,5 @@
+import { render } from "solid-js/web";
+export function mount(fn, el) {
+    render(fn, el);
+}
+export { StartClient } from "../StartClient.jsx";

package/dist/config/constants.d.ts

@@ -0,0 +1,16 @@
+export declare const DEFAULT_EXTENSIONS: string[];
+export declare const CLIENT_BASE_PATH = "_build";
+export declare const VIRTUAL_MODULES: {
+    readonly clientViteManifest: "solid-start:client-vite-manifest";
+    readonly getClientManifest: "solid-start:get-client-manifest";
+    readonly getManifest: "solid-start:get-manifest";
+    readonly middleware: "solid-start:middleware";
+    readonly serverFnManifest: "solid-start:server-fn-manifest";
+    readonly clientEntry: "solid-start:client-entry";
+    readonly serverEntry: "solid-start:server-entry";
+    readonly app: "solid-start:app";
+};
+export declare const VITE_ENVIRONMENTS: {
+    client: "client";
+    server: "ssr";
+};

package/dist/config/constants.js

@@ -0,0 +1,16 @@
+export const DEFAULT_EXTENSIONS = ["js", "jsx", "ts", "tsx"];
+export const CLIENT_BASE_PATH = "_build";
+export const VIRTUAL_MODULES = {
+    clientViteManifest: "solid-start:client-vite-manifest",
+    getClientManifest: "solid-start:get-client-manifest",
+    getManifest: "solid-start:get-manifest",
+    middleware: "solid-start:middleware",
+    serverFnManifest: "solid-start:server-fn-manifest",
+    clientEntry: "solid-start:client-entry",
+    serverEntry: "solid-start:server-entry",
+    app: "solid-start:app",
+};
+export const VITE_ENVIRONMENTS = {
+    client: "client",
+    server: "ssr",
+};

package/dist/config/dev-server.d.ts

@@ -0,0 +1,2 @@
+import { type PluginOption } from "vite";
+export declare function devServer(): Array<PluginOption>;

package/dist/config/dev-server.js

@@ -0,0 +1,128 @@
+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 { join } from "node:path";
+import { pathToFileURL } from "node:url";
+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(pathToFileURL(join(process.cwd(), "dist/server/entry-server.js")).href, 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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,81 @@
+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

@@ -0,0 +1,37 @@
+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): {
+        page: boolean;
+        $component: {
+            src: string;
+            pick: string[];
+        } | undefined;
+        $$route: {
+            src: string;
+            pick: string[];
+        } | undefined;
+        path: string;
+    } | undefined;
+}

package/dist/config/fs-router.js

@@ -0,0 +1,141 @@
+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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,53 @@
+import { debounce } from "../../utils/debounce.js";
+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) {
+    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) => {
+        devEnv.moduleGraph.invalidateModule(mod);
+    }, 0);
+    /**
+     * Long debounce timeout for expensive reloads
+     */
+    const reloadModule = debounce((mod) => {
+        devEnv.reloadModule(mod);
+    }, 200);
+    return routes.on("reload", function handleRoutesReload(evt) {
+        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) => {
+    const plugin = {
+        name: "fs-watcher",
+        async configureServer(server) {
+            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/dist/config/fs-routes/index.d.ts

@@ -0,0 +1,7 @@
+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>;