@solidjs/start 2.0.0-rc.2 → 2.0.0-rc.3

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @solidjs/start
 
+## 2.0.0-rc.3
+
+### Patch Changes
+
+- d9018d6: fix(types): add missing properties to `SolidStartOptions` and expose them via Vite plugin configuration
+- e26cef0: Fix TS2883/TS2742 when emitting declarations for `entry-server.tsx`. `createHandler` now returns `StartHandler`, a type owned by `@solidjs/start`, instead of h3's `H3`, so the inferred type of `export default createHandler(...)` no longer has to be named through a nested `node_modules/@solidjs/start/node_modules/h3` path.
+- 7c8dbe6: keep TypeScript namespace members in route files during production builds
+- b3c7aaf: Update `h3` to `2.0.1-rc.26`.
+- b3c7aaf: Fixed event response status and headers set during server-side rendering with deferred async resources, not being applied on the outgoing response.
+
 ## 2.0.0-rc.2
 
 ### Minor Changes

package/dist/config/fs-routes/tree-shake.js

@@ -133,6 +133,11 @@ function treeShakeTransform({ types: t }) {
                             if (!state.opts.pick) {
                                 return;
                             }
+                            // Only module-level exports are route exports; `export` inside a
+                            // TS namespace/module block is unrelated to the pick list.
+                            if (!exportNamedPath.parentPath.isProgram()) {
+                                return;
+                            }
                             const specifiers = exportNamedPath.get("specifiers");
                             if (specifiers.length) {
                                 specifiers.forEach(s => {

package/dist/config/index.d.ts

@@ -2,24 +2,99 @@ import type { PluginOption } from "vite";
 import { type Options as SolidOptions } from "vite-plugin-solid";
 import { type ServerFunctionsOptions } from "../directives/index.ts";
 import { type EnvPluginOptions } from "./env.ts";
+/**
+ * Configuration options for SolidStart. (previously in `app.config.ts`)
+ *
+ * @see https://docs.solidjs.com/solid-start/v2/migrating-from-v1#move-framework-configuration-into-viteconfigts
+ */
 export interface SolidStartOptions {
+    /**
+     * Path to the root of the application (where `app.tsx` / `app.jsx` lives).
+     *
+     * @default "./src"
+     */
+    appRoot?: string;
+    /**
+     * Options forwarded to `vite-plugin-solid`.
+     *
+     * @see https://github.com/solidjs/vite-plugin-solid#api
+     */
     solid?: Partial<SolidOptions>;
+    /**
+     * Enable or disable server-side rendering.
+     *
+     * - `true` — SSR (default)
+     * - `false` — client-side rendering only (SPA mode)
+     *
+     * @default true
+     */
     ssr?: boolean;
+    /**
+     * Show the SolidStart development overlay (error overlay, etc.) in development.
+     *
+     * @default true
+     */
+    devOverlay?: boolean;
+    /**
+     * Experimental features.
+     */
+    experimental?: {
+        /**
+         * Enable islands architecture mode.
+         *
+         * Currently fixed to `false` (not yet fully supported).
+         *
+         * @default false
+         */
+        islands?: false;
+    };
+    /**
+     * Directory containing file-system routes, relative to {@link appRoot}.
+     *
+     * @default "./routes"
+     */
     routeDir?: string;
+    /**
+     * File extensions that should be treated as routes.
+     *
+     * @default ["js", "jsx", "ts", "tsx"]
+     */
     extensions?: string[];
+    /**
+     * Path to an optional middleware module.
+     *
+     * The module should export a middleware created with `createMiddleware`
+     * from `@solidjs/start/middleware`.
+     *
+     * @example "src/middleware/index.ts"
+     */
     middleware?: string;
+    /**
+     * Serialization settings for server-function / action payloads
+     * that cross the server-client boundary.
+     */
     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.
+         *
+         * - `"js"` — Uses a custom binary format (Seroval) that is more efficient
+         *   than JSON, but requires a custom deserializer (with `eval()`) on the client.
+         *   A strong CSP that blocks `eval()` will prevent this mode from working.
+         * - `"json"` — Uses JSON for serialization. Less efficient / larger payloads,
+         *   but can be deserialized with `JSON.parse` on the client and is CSP-friendly.
          *
          * @default "json"
          */
         mode?: "js" | "json";
     };
+    /**
+     * Configures plugin behavior per build environment
+     */
     env?: EnvPluginOptions;
+    /**
+     * Options controlling which files are processed as server functions
+     * (inclusion / exclusion filters for the `"use server"` transform).
+     */
     serverFunctions?: Pick<ServerFunctionsOptions, "filter">;
 }
 export declare function solidStart(options?: SolidStartOptions): Array<PluginOption>;

package/dist/server/handler.d.ts

@@ -1,6 +1,5 @@
-import { H3 } from "h3/generic";
 import type { JSX } from "solid-js";
-import type { FetchEvent, HandlerOptions, PageEvent } from "./types.ts";
-export declare function createBaseHandler(createPageEvent: (e: FetchEvent) => Promise<PageEvent>, fn: (context: PageEvent) => JSX.Element, options?: HandlerOptions | ((context: PageEvent) => HandlerOptions | Promise<HandlerOptions>), routerLoad?: (event: FetchEvent) => Promise<void>): H3;
-export declare function createHandler(fn: (context: PageEvent) => JSX.Element, options?: HandlerOptions | ((context: PageEvent) => HandlerOptions | Promise<HandlerOptions>), routerLoad?: (event: FetchEvent) => Promise<void>): H3;
+import type { FetchEvent, HandlerOptions, PageEvent, StartHandler } from "./types.ts";
+export declare function createBaseHandler(createPageEvent: (e: FetchEvent) => Promise<PageEvent>, fn: (context: PageEvent) => JSX.Element, options?: HandlerOptions | ((context: PageEvent) => HandlerOptions | Promise<HandlerOptions>), routerLoad?: (event: FetchEvent) => Promise<void>): StartHandler;
+export declare function createHandler(fn: (context: PageEvent) => JSX.Element, options?: HandlerOptions | ((context: PageEvent) => HandlerOptions | Promise<HandlerOptions>), routerLoad?: (event: FetchEvent) => Promise<void>): StartHandler;
 export declare function createPageEvent(ctx: FetchEvent): Promise<PageEvent>;

package/dist/server/handler.js

@@ -1,5 +1,5 @@
 import middleware from "solid-start:middleware";
-import { defineHandler, getCookie, H3, redirect, setCookie } from "h3/generic";
+import { defineHandler, getCookie, H3, iterable, redirect, setCookie, } from "h3/generic";
 import { sharedConfig } from "solid-js";
 import { getRequestEvent, renderToStream, renderToString } from "solid-js/web";
 import { createRoutes } from "../router.jsx";
@@ -19,12 +19,7 @@ export function createBaseHandler(createPageEvent, fn, options = {}, routerLoad)
             const url = new URL(event.request.url);
             const pathname = stripBaseUrl(url.pathname);
             if (pathname.startsWith(SERVER_FN_BASE)) {
-                const serverFnResponse = await handleServerFunction(e);
-                if (serverFnResponse instanceof Response)
-                    return produceResponseWithEventHeaders(serverFnResponse);
-                return new Response(serverFnResponse, {
-                    headers: e.res.headers,
-                });
+                return await handleServerFunction(e);
             }
             const match = matchAPIRoute(pathname, event.request.method);
             if (match) {
@@ -36,8 +31,6 @@ export function createBaseHandler(createPageEvent, fn, options = {}, routerLoad)
                     sharedConfig.context = { event };
                     const res = await fn(event);
                     if (res !== undefined) {
-                        if (res instanceof Response)
-                            return produceResponseWithEventHeaders(res);
                         return res;
                     }
                     if (event.request.method !== "GET") {
@@ -96,10 +89,9 @@ export function createBaseHandler(createPageEvent, fn, options = {}, routerLoad)
             }
             if (mode === "async")
                 return await stream;
-            delete stream.then;
             // h3 expects a standard web ReadableStream across runtimes. The adapter
             // also tolerates cancellation while Solid finishes outstanding work.
-            return toWebReadableStream(stream);
+            return iterable(toWebReadableStream(stream));
         }),
     });
     const app = new H3();
@@ -182,38 +174,6 @@ function handleStreamCompleteRedirect(context) {
         to && write(`<script>window.location=${JSON.stringify(to).replace(/</g, "\\u003c")}</script>`);
     };
 }
-function produceResponseWithEventHeaders(res) {
-    const event = getRequestEvent();
-    let ret = res;
-    // Response.redirect returns an immutable value, so we clone on any redirect just in case
-    if (300 <= res.status && res.status < 400) {
-        const cookies = res.headers.getSetCookie?.() ?? [];
-        const headers = new Headers();
-        res.headers.forEach((value, key) => {
-            if (key.toLowerCase() !== "set-cookie") {
-                headers.set(key, value);
-            }
-        });
-        for (const cookie of cookies) {
-            headers.append("Set-Cookie", cookie);
-        }
-        ret = new Response(res.body, {
-            status: res.status,
-            statusText: res.statusText,
-            headers,
-        });
-    }
-    const eventCookies = event.response.headers.getSetCookie?.() ?? [];
-    for (const cookie of eventCookies) {
-        ret.headers.append("Set-Cookie", cookie);
-    }
-    for (const [name, value] of event.response.headers) {
-        if (name.toLowerCase() !== "set-cookie") {
-            ret.headers.set(name, value);
-        }
-    }
-    return ret;
-}
 function stripBaseUrl(path) {
     const base = import.meta.env.SERVER_BASE_URL || import.meta.env.BASE_URL || "/";
     return stripPathBase(path, base);

package/dist/server/index.d.ts

@@ -3,7 +3,7 @@ export { getServerFunctionMeta } from "../shared/serverFunction.ts";
 export { StartServer } from "./StartServer.tsx";
 export { decorateHandler, decorateMiddleware } from "./fetchEvent.ts";
 export { createHandler } from "./handler.ts";
-export type { APIEvent, APIHandler, Asset, ContextMatches, DocumentComponentProps, FetchEvent, HandlerOptions, PageEvent, ResponseStub, ServerFunctionMeta, } from "./types.ts";
+export type { APIEvent, APIHandler, Asset, ContextMatches, DocumentComponentProps, FetchEvent, HandlerOptions, PageEvent, ResponseStub, ServerFunctionMeta, StartHandler, } from "./types.ts";
 /**
  * Checks if user has set a redirect status in the response.
  * If not, falls back to the 302 (temporary redirect)

package/dist/server/spa/handler.d.ts

@@ -1,8 +1,7 @@
-import type { H3 } from "h3/generic";
 import type { JSX } from "solid-js";
-import type { FetchEvent, HandlerOptions, PageEvent } from "../types.ts";
+import type { FetchEvent, HandlerOptions, PageEvent, StartHandler } from "../types.ts";
 /**
  *
  * Read more: https://docs.solidjs.com/solid-start/reference/server/create-handler
  */
-export declare function createHandler(fn: (context: PageEvent) => JSX.Element, options?: HandlerOptions | ((context: PageEvent) => HandlerOptions), routerLoad?: (event: FetchEvent) => Promise<void>): H3;
+export declare function createHandler(fn: (context: PageEvent) => JSX.Element, options?: HandlerOptions | ((context: PageEvent) => HandlerOptions), routerLoad?: (event: FetchEvent) => Promise<void>): StartHandler;

package/dist/server/types.d.ts

@@ -1,6 +1,17 @@
-import type { H3Event } from "h3";
+import type { H3, H3Event } from "h3";
 import type { JSX } from "solid-js";
 import type { RequestEvent } from "solid-js/web";
+/**
+ * The h3 app instance returned by `createHandler`.
+ *
+ * Structurally identical to h3's `H3`, but declared here so that `export default
+ * createHandler(...)` in `entry-server.tsx` can be named through `@solidjs/start`.
+ * Referring to `H3` directly makes TypeScript emit a reference to h3's internal
+ * `H3$1` class, which is not portable when h3 is nested inside
+ * `node_modules/@solidjs/start/node_modules` (TS2742 / TS2883).
+ */
+export interface StartHandler extends H3 {
+}
 export type DocumentComponentProps = {
     assets?: JSX.Element;
     scripts: JSX.Element;

package/dist/server/web-stream.d.ts

@@ -5,5 +5,5 @@ type PipeableStream = {
     }): void;
 };
 /** Convert Solid's streaming SSR result into a cancellation-safe web stream. */
-export declare function toWebReadableStream(stream: PipeableStream): ReadableStream<Uint8Array>;
+export declare function toWebReadableStream(stream: PipeableStream): ReadableStream<Uint8Array<ArrayBufferLike>>;
 export {};

package/dist/server/web-stream.js

@@ -6,8 +6,11 @@ export function toWebReadableStream(stream) {
         start(controller) {
             stream.pipe({
                 write(payload) {
-                    if (active)
-                        controller.enqueue(encoder.encode(payload));
+                    if (!active)
+                        return;
+                    // Encoding string to Uint8Array makes sure that
+                    // the stream can be consumed as Response body
+                    controller.enqueue(encoder.encode(payload));
                 },
                 end() {
                     if (!active)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidjs/start",
-  "version": "2.0.0-rc.2",
+  "version": "2.0.0-rc.3",
   "type": "module",
   "files": [
     "dist",
@@ -40,7 +40,7 @@
     "defu": "^6.1.4",
     "error-stack-parser": "^2.1.4",
     "fast-glob": "^3.3.3",
-    "h3": "^2.0.1-rc.25",
+    "h3": "^2.0.1-rc.26",
     "html-to-image": "^1.11.13",
     "micromatch": "^4.0.8",
     "oxc-parser": "^0.139.0",