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

package/CHANGELOG.md

@@ -1,5 +1,69 @@
 # @solidjs/start
 
+## 2.0.0-beta.10
+
+### Patch Changes
+
+- 8af6304: Support for Vite 8.1 Experimental Bundled Dev Mode
+- 9d91484: fix: don't crash when a server function throws an error whose message contains non-latin1 characters. 
+- 068b64c: Return a cancellation-safe web `ReadableStream` for streaming SSR in development. Returning Solid's
+  raw stream only rendered on Node; Bun and Deno coerced it to `[object Object]`.
+
+## 2.0.0-beta.9
+
+### Minor Changes
+
+- f3e84ec: Add support for `server-only` and `client-only` modules
+
+### Patch Changes
+
+- a8a2328: fix: mark `@solidjs/start/http` and `@solidjs/start/middleware` as `server-only` so importing them from client-reachable code fails loudly at dev/build time, instead of silently shipping them to the browser where they crashed hydration and broke unrelated actions/forms with no diagnostic (#2068)
+
+## 2.0.0-beta.8
+
+### Patch Changes
+
+- ecc02be: fix: resolve server functions in dev when their route was reached through client-side navigation before its module was evaluated on the server
+- 85b24b2: Use per-environment Vite plugin hook APIs for forward compatibility with Vite 9.
+
+## 2.0.0-beta.7
+
+### Patch Changes
+
+- d2f0621: Support JavaScript projects whose app and client/server entries use `.jsx`.
+
+## 2.0.0-beta.6
+
+### Patch Changes
+
+- 25769f2: Fix Vite preview for non-HTML responses and projects whose server build uses an `.mjs`
+  entry.
+
+## 2.0.0-beta.5
+
+### Patch Changes
+
+- eb73dd5: Use `oxc-parser` to analyze filesystem route exports.
+
+## 2.0.0-beta.4
+
+### Patch Changes
+
+- 21fdb2c: Update `h3` to `2.0.1-rc.25`.
+
+## 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/boundary-modules.d.ts

@@ -0,0 +1,14 @@
+import type { Plugin } from "vite";
+/**
+ * Supports `server-only` and `client-only` marker modules (#2162): importing
+ * `server-only` from a client module (or `client-only` from a server module)
+ * fails at resolve time; in the allowed environment the marker resolves to an
+ * empty module.
+ *
+ * Start's own server-only entry points (`@solidjs/start/http`,
+ * `@solidjs/start/middleware`) import `server-only` themselves, so pulling
+ * them into the client bundle fails loudly instead of shipping server code to
+ * the browser, where it crashed hydration and broke unrelated actions/forms
+ * with no diagnostic (https://github.com/solidjs/solid-start/issues/2068).
+ */
+export declare function boundaryModules(): Plugin;

package/dist/config/boundary-modules.js

@@ -0,0 +1,41 @@
+const VIRTUAL_ID = "\0solid-start:boundary-modules:id";
+/**
+ * Supports `server-only` and `client-only` marker modules (#2162): importing
+ * `server-only` from a client module (or `client-only` from a server module)
+ * fails at resolve time; in the allowed environment the marker resolves to an
+ * empty module.
+ *
+ * Start's own server-only entry points (`@solidjs/start/http`,
+ * `@solidjs/start/middleware`) import `server-only` themselves, so pulling
+ * them into the client bundle fails loudly instead of shipping server code to
+ * the browser, where it crashed hydration and broke unrelated actions/forms
+ * with no diagnostic (https://github.com/solidjs/solid-start/issues/2068).
+ */
+export function boundaryModules() {
+    return {
+        name: "solid-start:boundary-modules",
+        enforce: "pre",
+        resolveId(id, importer, { ssr }) {
+            if (id === "server-only") {
+                if (!ssr)
+                    this.error(`Attempt to import 'server-only' in a client module: ${importer}. ` +
+                        `Code that uses this module must run only on the server: mark it with ` +
+                        `"use server", or make sure it is only imported by server code.`);
+            }
+            else if (id === "client-only") {
+                if (ssr)
+                    this.error(`Attempt to import 'client-only' in a server module: ${importer}. ` +
+                        `Code that uses this module must run only in the browser: make sure it ` +
+                        `is only imported by client code (e.g. wrap components with clientOnly()).`);
+            }
+            else {
+                return null;
+            }
+            return VIRTUAL_ID;
+        },
+        load(id) {
+            if (id === VIRTUAL_ID)
+                return "export {}";
+        },
+    };
+}

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,4 @@
+import { type PluginOption } from "vite";
+export declare function devServer(serverEntryPath: string): Array<PluginOption>;
+export declare function resolvePreviewServerEntry(root: string): string;
+export declare function isHtmlResponse(response: Response): boolean;

package/dist/config/dev-server.js

@@ -0,0 +1,146 @@
+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 { existsSync } from "node:fs";
+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(serverEntryPath) {
+    return [
+        {
+            name: "solid-start-dev-server",
+            configurePreviewServer(server) {
+                const serverEntryUrl = pathToFileURL(resolvePreviewServerEntry(server.config.root)).href;
+                return () => {
+                    server.middlewares.use(async (req, res) => {
+                        const webReq = new NodeRequest({ req, res });
+                        const def = await import(__rewriteRelativeImportExtension(serverEntryUrl, true));
+                        const webRes = await def.default.fetch(webReq);
+                        if (isHtmlResponse(webRes)) {
+                            res.setHeader("content-encoding", "identity");
+                        }
+                        sendNodeResponse(res, webRes);
+                    });
+                };
+            },
+            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(serverEntryPath);
+                            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" },
+                            }));
+                        }
+                    });
+                };
+            },
+        },
+    ];
+}
+export function resolvePreviewServerEntry(root) {
+    const serverDirectory = join(root, "dist/server");
+    const serverEntry = ["js", "mjs"]
+        .map(extension => join(serverDirectory, `entry-server.${extension}`))
+        .find(existsSync);
+    if (!serverEntry) {
+        throw new Error(`Could not find the SolidStart server entry in ${serverDirectory}`);
+    }
+    return serverEntry;
+}
+export function isHtmlResponse(response) {
+    return response.headers.get("content-type")?.startsWith("text/html") ?? false;
+}
+/**
+ * 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,85 @@
+import { loadEnv } from "vite";
+import { parseIdQuery } from "./utils.js";
+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) {
+            const { filename } = parseIdQuery(id);
+            if (filename === SERVER_ENV ||
+                filename === CLIENT_ENV ||
+                filename === SERVER_RUNTIME_ENV ||
+                filename === SERVER_RUNTIME_LOADER) {
+                return id;
+            }
+            return undefined;
+        },
+        load(id) {
+            const { filename } = parseIdQuery(id);
+            const isServer = this.environment.config.consumer === "server";
+            if (filename === SERVER_ENV) {
+                if (!isServer) {
+                    return SERVER_ONLY_MODULE;
+                }
+                const vars = currentOptions.server?.load
+                    ? currentOptions.server.load(env)
+                    : loadEnv(env, '.', serverPrefix);
+                return convertObjectToModule(vars);
+            }
+            if (filename === CLIENT_ENV) {
+                const vars = currentOptions.client?.load
+                    ? currentOptions.client.load(env)
+                    : loadEnv(env, '.', clientPrefix);
+                return convertObjectToModule(vars);
+            }
+            if (filename === SERVER_RUNTIME_LOADER) {
+                if (!isServer) {
+                    return SERVER_ONLY_MODULE;
+                }
+                return runtimeCode;
+            }
+            if (filename === SERVER_RUNTIME_ENV) {
+                if (!isServer) {
+                    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;
+}