@solidjs/start 1.2.1 → 2.0.0-alpha.1

package/dist/server/fetchEvent.spec.js

@@ -1,62 +1,35 @@
+import * as h3 from "h3";
 import { beforeEach, describe, expect, it, vi } from "vitest";
-import { cloneEvent, createFetchEvent, getFetchEvent, mergeResponseHeaders } from "./fetchEvent";
-vi.mock("vinxi/http", () => ({
-    getWebRequest: vi.fn(),
-    getRequestIP: vi.fn(),
-    getResponseStatus: vi.fn(),
-    setResponseStatus: vi.fn(),
-    getResponseStatusText: vi.fn(),
-    getResponseHeader: vi.fn(),
-    getResponseHeaders: vi.fn(),
-    setResponseHeader: vi.fn(),
-    appendResponseHeader: vi.fn(),
-    removeResponseHeader: vi.fn()
-}));
-import * as vinxiHttp from "vinxi/http";
-const mockedVinxiHttp = vi.mocked(vinxiHttp);
-const createMockH3Event = () => {
-    const mockRequest = new Request("http://localhost/test");
-    const mockStatus = 200;
-    const mockStatusText = "OK";
+import { createFetchEvent, getFetchEvent, mergeResponseHeaders } from "./fetchEvent.js";
+vi.mock(import("h3"), async (mod) => {
     return {
-        node: {
-            req: {},
-            res: {
-                statusCode: mockStatus,
-                statusMessage: mockStatusText
-            }
-        },
-        context: {},
-        web: {
-            request: mockRequest
-        }
+        ...(await mod()),
+        getRequestIP: vi.fn(),
     };
+});
+const mockedH3 = vi.mocked(h3);
+const createMockH3Event = () => {
+    const event = new h3.H3Event(new Request("http://localhost/test"));
+    event.res.status = 200;
+    event.res.statusText = "OK";
+    return event;
 };
 describe("fetchEvent", () => {
     let mockH3Event;
     beforeEach(() => {
         mockH3Event = createMockH3Event();
         vi.clearAllMocks();
-        mockedVinxiHttp.getWebRequest.mockReturnValue(mockH3Event.web?.request);
-        mockedVinxiHttp.getRequestIP.mockReturnValue("127.0.0.1");
-        mockedVinxiHttp.getResponseStatus.mockReturnValue(200);
-        mockedVinxiHttp.setResponseStatus.mockImplementation(() => { });
-        mockedVinxiHttp.getResponseStatusText.mockReturnValue("OK");
-        mockedVinxiHttp.getResponseHeader.mockReturnValue(undefined);
-        mockedVinxiHttp.getResponseHeaders.mockReturnValue({});
-        mockedVinxiHttp.setResponseHeader.mockImplementation(() => { });
-        mockedVinxiHttp.appendResponseHeader.mockImplementation(() => { });
-        mockedVinxiHttp.removeResponseHeader.mockImplementation(() => { });
+        mockedH3.getRequestIP.mockReturnValue("127.0.0.1");
     });
     describe("createFetchEvent", () => {
         it("should create a FetchEvent from H3Event", () => {
             const fetchEvent = createFetchEvent(mockH3Event);
             expect(fetchEvent).toEqual({
-                request: mockH3Event.web?.request,
+                request: mockH3Event.req,
                 response: expect.any(Object),
                 clientAddress: "127.0.0.1",
                 locals: {},
-                nativeEvent: mockH3Event
+                nativeEvent: mockH3Event,
             });
         });
         it("should create response stub with correct properties", () => {
@@ -66,16 +39,6 @@ describe("fetchEvent", () => {
             expect(fetchEvent.response).toHaveProperty("headers");
         });
     });
-    describe("cloneEvent", () => {
-        it("should create a shallow copy of FetchEvent", () => {
-            const original = createFetchEvent(mockH3Event);
-            const cloned = cloneEvent(original);
-            expect(cloned).toEqual(original);
-            expect(cloned).not.toBe(original);
-            expect(cloned.request).toBe(original.request);
-            expect(cloned.response).toBe(original.response);
-        });
-    });
     describe("getFetchEvent", () => {
         it("should create and cache FetchEvent on first call", () => {
             const fetchEvent = getFetchEvent(mockH3Event);
@@ -92,153 +55,11 @@ describe("fetchEvent", () => {
         it("should merge headers from Headers object to H3Event", () => {
             const headers = new Headers({
                 "content-type": "application/json",
-                "x-custom": "value"
+                "x-custom": "value",
             });
             mergeResponseHeaders(mockH3Event, headers);
-            expect(mockedVinxiHttp.appendResponseHeader).toHaveBeenCalledWith(mockH3Event, "content-type", "application/json");
-            expect(mockedVinxiHttp.appendResponseHeader).toHaveBeenCalledWith(mockH3Event, "x-custom", "value");
-        });
-    });
-    describe("ResponseStub", () => {
-        let fetchEvent;
-        beforeEach(() => {
-            fetchEvent = createFetchEvent(mockH3Event);
-        });
-        describe("status", () => {
-            it("should get status from H3Event", () => {
-                expect(fetchEvent.response.status).toBe(200);
-            });
-            it("should set status on H3Event", () => {
-                fetchEvent.response.status = 404;
-                expect(mockedVinxiHttp.setResponseStatus).toHaveBeenCalledWith(mockH3Event, 404);
-            });
-        });
-        describe("statusText", () => {
-            it("should get statusText from H3Event", () => {
-                expect(fetchEvent.response.statusText).toBe("OK");
-            });
-            it("should set statusText on H3Event", () => {
-                fetchEvent.response.statusText = "Not Found";
-                expect(mockedVinxiHttp.setResponseStatus).toHaveBeenCalledWith(mockH3Event, 200, "Not Found");
-            });
-        });
-    });
-    describe("HeaderProxy", () => {
-        let fetchEvent;
-        beforeEach(() => {
-            fetchEvent = createFetchEvent(mockH3Event);
-        });
-        describe("get", () => {
-            it("should return null for non-existent header", () => {
-                expect(fetchEvent.response.headers.get("non-existent")).toBe(null);
-            });
-            it("should return string value for single header", () => {
-                mockedVinxiHttp.getResponseHeader.mockReturnValue("application/json");
-                expect(fetchEvent.response.headers.get("content-type")).toBe("application/json");
-            });
-            it("should join array values with comma", () => {
-                mockedVinxiHttp.getResponseHeader.mockReturnValue(["text/html", "application/json"]);
-                expect(fetchEvent.response.headers.get("accept")).toBe("text/html, application/json");
-            });
-        });
-        describe("has", () => {
-            it("should return false for non-existent header", () => {
-                mockedVinxiHttp.getResponseHeader.mockReturnValue(undefined);
-                expect(fetchEvent.response.headers.has("non-existent")).toBe(false);
-            });
-            it("should return true for existing header", () => {
-                mockedVinxiHttp.getResponseHeader.mockReturnValue("application/json");
-                expect(fetchEvent.response.headers.has("content-type")).toBe(true);
-            });
-        });
-        describe("set", () => {
-            it("should set header value", () => {
-                fetchEvent.response.headers.set("content-type", "application/json");
-                expect(mockedVinxiHttp.setResponseHeader).toHaveBeenCalledWith(mockH3Event, "content-type", "application/json");
-            });
-        });
-        describe("delete", () => {
-            it("should remove header", () => {
-                fetchEvent.response.headers.delete("content-type");
-                expect(mockedVinxiHttp.removeResponseHeader).toHaveBeenCalledWith(mockH3Event, "content-type");
-            });
-        });
-        describe("append", () => {
-            it("should append header value", () => {
-                fetchEvent.response.headers.append("x-custom", "value");
-                expect(mockedVinxiHttp.appendResponseHeader).toHaveBeenCalledWith(mockH3Event, "x-custom", "value");
-            });
-        });
-        describe("getSetCookie", () => {
-            it("should return array for single cookie", () => {
-                mockedVinxiHttp.getResponseHeader.mockReturnValue("session=abc123");
-                expect(fetchEvent.response.headers.getSetCookie()).toEqual(["session=abc123"]);
-            });
-            it("should return array for multiple cookies", () => {
-                mockedVinxiHttp.getResponseHeader.mockReturnValue(["session=abc123", "theme=dark"]);
-                expect(fetchEvent.response.headers.getSetCookie()).toEqual([
-                    "session=abc123",
-                    "theme=dark"
-                ]);
-            });
-        });
-        describe("forEach", () => {
-            it("should iterate over headers", () => {
-                mockedVinxiHttp.getResponseHeaders.mockReturnValue({
-                    "content-type": "application/json",
-                    "x-custom": ["value1", "value2"]
-                });
-                const callback = vi.fn();
-                fetchEvent.response.headers.forEach(callback);
-                expect(callback).toHaveBeenCalledWith("application/json", "content-type", expect.any(Object));
-                expect(callback).toHaveBeenCalledWith("value1, value2", "x-custom", expect.any(Object));
-            });
-        });
-        describe("entries", () => {
-            it("should return iterator of header entries", () => {
-                mockedVinxiHttp.getResponseHeaders.mockReturnValue({
-                    "content-type": "application/json",
-                    "x-custom": ["value1", "value2"]
-                });
-                const entries = Array.from(fetchEvent.response.headers.entries());
-                expect(entries).toEqual([
-                    ["content-type", "application/json"],
-                    ["x-custom", "value1, value2"]
-                ]);
-            });
-        });
-        describe("keys", () => {
-            it("should return iterator of header keys", () => {
-                mockedVinxiHttp.getResponseHeaders.mockReturnValue({
-                    "content-type": "application/json",
-                    "x-custom": "value"
-                });
-                const keys = Array.from(fetchEvent.response.headers.keys());
-                expect(keys).toEqual(["content-type", "x-custom"]);
-            });
-        });
-        describe("values", () => {
-            it("should return iterator of header values", () => {
-                mockedVinxiHttp.getResponseHeaders.mockReturnValue({
-                    "content-type": "application/json",
-                    "x-custom": ["value1", "value2"]
-                });
-                const values = Array.from(fetchEvent.response.headers.values());
-                expect(values).toEqual(["application/json", "value1, value2"]);
-            });
-        });
-        describe("Symbol.iterator", () => {
-            it("should be iterable", () => {
-                mockedVinxiHttp.getResponseHeaders.mockReturnValue({
-                    "content-type": "application/json",
-                    "x-custom": "value"
-                });
-                const entries = Array.from(fetchEvent.response.headers);
-                expect(entries).toEqual([
-                    ["content-type", "application/json"],
-                    ["x-custom", "value"]
-                ]);
-            });
+            expect(headers.get("content-type")).toBe("application/json");
+            expect(headers.get("x-custom")).toBe("value");
         });
     });
 });

package/dist/server/handler.d.ts

@@ -1,12 +1,6 @@
-import type { FetchEvent, HandlerOptions, PageEvent, ResponseStub } from "./types";
-/**
- * Checks if user has set a redirect status in the response.
- * If not, falls back to the 302 (temporary redirect)
- */
-export declare function getExpectedRedirectStatus(response: ResponseStub): number;
-export declare function createBaseHandler(fn: (context: PageEvent) => unknown, createPageEvent: (event: FetchEvent) => Promise<PageEvent>, options?: HandlerOptions | ((context: PageEvent) => HandlerOptions | Promise<HandlerOptions>), routerLoad?: (event: FetchEvent) => Promise<void>): import("vinxi/http").EventHandler<import("vinxi/http").EventHandlerRequest, Promise<any>>;
-/**
- *
- * Read more: https://docs.solidjs.com/solid-start/reference/server/create-handler
- */
-export declare function createHandler(fn: (context: PageEvent) => unknown, options?: HandlerOptions | ((context: PageEvent) => HandlerOptions | Promise<HandlerOptions>), routerLoad?: (event: FetchEvent) => Promise<void>): import("vinxi/http").EventHandler<import("vinxi/http").EventHandlerRequest, Promise<any>>;
+import { H3 } from "h3";
+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>)): H3;
+export declare function createHandler(fn: (context: PageEvent) => JSX.Element, options?: HandlerOptions | ((context: PageEvent) => HandlerOptions | Promise<HandlerOptions>)): H3;
+export declare function createPageEvent(ctx: FetchEvent): Promise<PageEvent>;

package/dist/server/handler.js

@@ -1,108 +1,175 @@
+import middleware from "solid-start:middleware";
+import { defineHandler, getCookie, H3, redirect, setCookie } from "h3";
 import { sharedConfig } from "solid-js";
-import { renderToStream, renderToString } from "solid-js/web";
-import { provideRequestEvent } from "solid-js/web/storage";
-import { eventHandler, sendRedirect, setHeader, setResponseStatus } from "vinxi/http";
-import { matchAPIRoute } from "../router/routes";
-import { getFetchEvent } from "./fetchEvent";
-import { createPageEvent } from "./pageEvent";
-// according to https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#redirection_messages
-const validRedirectStatuses = new Set([301, 302, 303, 307, 308]);
-/**
- * Checks if user has set a redirect status in the response.
- * If not, falls back to the 302 (temporary redirect)
- */
-export function getExpectedRedirectStatus(response) {
-    if (response.status && validRedirectStatuses.has(response.status)) {
-        return response.status;
-    }
-    return 302;
-}
-export function createBaseHandler(fn, createPageEvent, options = {}, routerLoad) {
-    return eventHandler({
-        handler: (e) => {
-            const event = getFetchEvent(e);
-            return provideRequestEvent(event, async () => {
-                if (routerLoad) {
-                    await routerLoad(event);
-                }
-                // api
-                const match = matchAPIRoute(new URL(event.request.url).pathname, event.request.method);
-                if (match) {
-                    const mod = await match.handler.import();
-                    const fn = event.request.method === "HEAD" ? mod["HEAD"] || mod["GET"] : mod[event.request.method];
-                    event.params = match.params || {};
-                    // @ts-ignore
-                    sharedConfig.context = { event };
-                    const res = await fn(event);
-                    if (res !== undefined)
-                        return res;
-                    if (event.request.method !== "GET") {
-                        throw new Error(`API handler for ${event.request.method} "${event.request.url}" did not return a response.`);
-                    }
-                    if (!match.isPage)
-                        return;
-                }
-                // render
-                const context = await createPageEvent(event);
-                const resolvedOptions = typeof options == "function" ? await options(context) : { ...options };
-                const mode = resolvedOptions.mode || "stream";
-                // @ts-ignore
-                if (resolvedOptions.nonce)
-                    context.nonce = resolvedOptions.nonce;
-                if (mode === "sync" || !import.meta.env.START_SSR) {
-                    const html = renderToString(() => {
-                        sharedConfig.context.event = context;
-                        return fn(context);
-                    }, resolvedOptions);
-                    context.complete = true;
-                    if (context.response && context.response.headers.get("Location")) {
-                        const status = getExpectedRedirectStatus(context.response);
-                        return sendRedirect(e, context.response.headers.get("Location"), status);
-                    }
-                    return html;
-                }
-                if (resolvedOptions.onCompleteAll) {
-                    const og = resolvedOptions.onCompleteAll;
-                    resolvedOptions.onCompleteAll = options => {
-                        handleStreamCompleteRedirect(context)(options);
-                        og(options);
-                    };
+import { getRequestEvent, renderToStream, renderToString } from "solid-js/web";
+import { createRoutes } from "../router.jsx";
+import { decorateHandler, decorateMiddleware } from "./fetchEvent.js";
+import { getSsrManifest } from "./manifest/ssr-manifest.js";
+import { matchAPIRoute } from "./routes.js";
+import { handleServerFunction } from "./server-functions-handler.js";
+import { getExpectedRedirectStatus } from "./util.js";
+const SERVER_FN_BASE = "/_server";
+export function createBaseHandler(createPageEvent, fn, options = {}) {
+    const handler = defineHandler({
+        middleware: middleware.length ? middleware.map(decorateMiddleware) : undefined,
+        handler: decorateHandler(async (e) => {
+            const event = getRequestEvent();
+            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,
+                });
+            }
+            const match = matchAPIRoute(pathname, event.request.method);
+            if (match) {
+                const mod = await match.handler.import();
+                const fn = event.request.method === "HEAD" ? mod["HEAD"] || mod["GET"] : mod[event.request.method];
+                event.params = match.params || {};
+                // @ts-expect-error
+                sharedConfig.context = { event };
+                const res = await fn(event);
+                if (res !== undefined) {
+                    if (res instanceof Response)
+                        return produceResponseWithEventHeaders(res);
+                    return res;
                 }
-                else
-                    resolvedOptions.onCompleteAll = handleStreamCompleteRedirect(context);
-                if (resolvedOptions.onCompleteShell) {
-                    const og = resolvedOptions.onCompleteShell;
-                    resolvedOptions.onCompleteShell = options => {
-                        handleShellCompleteRedirect(context, e)();
-                        og(options);
-                    };
+                if (event.request.method !== "GET") {
+                    throw new Error(`API handler for ${event.request.method} "${event.request.url}" did not return a response.`);
                 }
-                else
-                    resolvedOptions.onCompleteShell = handleShellCompleteRedirect(context, e);
-                const stream = renderToStream(() => {
+                if (!match.isPage)
+                    return;
+            }
+            const context = await createPageEvent(event);
+            const resolvedOptions = typeof options === "function" ? await options(context) : { ...options };
+            const mode = resolvedOptions.mode || "stream";
+            if (resolvedOptions.nonce)
+                context.nonce = resolvedOptions.nonce;
+            if (mode === "sync" || !import.meta.env.START_SSR) {
+                const html = renderToString(() => {
                     sharedConfig.context.event = context;
                     return fn(context);
                 }, resolvedOptions);
+                context.complete = true;
                 if (context.response && context.response.headers.get("Location")) {
                     const status = getExpectedRedirectStatus(context.response);
-                    return sendRedirect(e, context.response.headers.get("Location"), status);
+                    return redirect(context.response.headers.get("Location"), status);
                 }
-                if (mode === "async")
-                    return stream;
-                // fix cloudflare streaming
-                const { writable, readable } = new TransformStream();
-                stream.pipeTo(writable);
-                return readable;
-            });
-        }
+                return html;
+            }
+            if (resolvedOptions.onCompleteAll) {
+                const og = resolvedOptions.onCompleteAll;
+                resolvedOptions.onCompleteAll = options => {
+                    handleStreamCompleteRedirect(context)(options);
+                    og(options);
+                };
+            }
+            else
+                resolvedOptions.onCompleteAll = handleStreamCompleteRedirect(context);
+            if (resolvedOptions.onCompleteShell) {
+                const og = resolvedOptions.onCompleteShell;
+                resolvedOptions.onCompleteShell = options => {
+                    handleShellCompleteRedirect(context, e)();
+                    og(options);
+                };
+            }
+            else
+                resolvedOptions.onCompleteShell = handleShellCompleteRedirect(context, e);
+            const _stream = renderToStream(() => {
+                sharedConfig.context.event = context;
+                return fn(context);
+            }, resolvedOptions);
+            const stream = _stream; // stream has a hidden 'then' method
+            if (context.response && context.response.headers.get("Location")) {
+                const status = getExpectedRedirectStatus(context.response);
+                return redirect(context.response.headers.get("Location"), status);
+            }
+            if (mode === "async")
+                return await stream;
+            delete stream.then;
+            // using TransformStream in dev can cause solid-start-dev-server to crash
+            // when stream is cancelled
+            if (globalThis.USING_SOLID_START_DEV_SERVER)
+                return stream;
+            // returning stream directly breaks cloudflare workers
+            const { writable, readable } = new TransformStream();
+            stream.pipeTo(writable);
+            return readable;
+        }),
     });
+    const app = new H3();
+    app.use(handler);
+    return app;
+}
+export function createHandler(fn, options = {}) {
+    return createBaseHandler(createPageEvent, fn, options);
+}
+export async function createPageEvent(ctx) {
+    ctx.response.headers.set("Content-Type", "text/html");
+    // const prevPath = ctx.request.headers.get("x-solid-referrer");
+    // const mutation = ctx.request.headers.get("x-solid-mutation") === "true";
+    const manifest = getSsrManifest(import.meta.env.SSR && import.meta.env.DEV ? "ssr" : "client");
+    // Handle Vite build.cssCodeSplit
+    // When build.cssCodeSplit is false, a single CSS file is generated with the key style.css
+    const mergedCSS = import.meta.env.PROD ? await manifest.getAssets("style.css") : [];
+    const assets = [
+        ...mergedCSS,
+        ...(await manifest.getAssets(import.meta.env.START_CLIENT_ENTRY)),
+        ...(await manifest.getAssets(import.meta.env.START_APP_ENTRY)),
+        // ...(import.meta.env.START_ISLANDS
+        //   ? (await serverManifest.inputs[serverManifest.handler]!.assets()).filter(
+        //       s => (s as any).attrs.rel !== "modulepreload"
+        //     )
+        //   : [])
+    ];
+    const pageEvent = Object.assign(ctx, {
+        assets,
+        router: {
+            submission: initFromFlash(ctx),
+        },
+        routes: createRoutes(),
+        // prevUrl: prevPath || "",
+        // mutation: mutation,
+        // $type: FETCH_EVENT,
+        complete: false,
+        $islands: new Set(),
+    });
+    return pageEvent;
+}
+function initFromFlash(ctx) {
+    const flash = getCookie(ctx.nativeEvent, "flash");
+    if (!flash)
+        return;
+    try {
+        const param = JSON.parse(flash);
+        if (!param || !param.result)
+            return;
+        const input = [...param.input.slice(0, -1), new Map(param.input[param.input.length - 1])];
+        const result = param.error ? new Error(param.result) : param.result;
+        return {
+            input,
+            url: param.url,
+            pending: false,
+            result: param.thrown ? undefined : result,
+            error: param.thrown ? result : undefined,
+        };
+    }
+    catch (e) {
+        console.error(e);
+    }
+    finally {
+        setCookie(ctx.nativeEvent, "flash", "", { maxAge: 0 });
+    }
 }
 function handleShellCompleteRedirect(context, e) {
     return () => {
         if (context.response && context.response.headers.get("Location")) {
             const status = getExpectedRedirectStatus(context.response);
-            setResponseStatus(e, status);
-            setHeader(e, "Location", context.response.headers.get("Location"));
+            e.res.status = status;
+            e.res.headers.set("Location", context.response.headers.get("Location"));
         }
     };
 }
@@ -113,10 +180,40 @@ function handleStreamCompleteRedirect(context) {
         to && write(`<script>window.location="${to}"</script>`);
     };
 }
-/**
- *
- * Read more: https://docs.solidjs.com/solid-start/reference/server/create-handler
- */
-export function createHandler(fn, options, routerLoad) {
-    return createBaseHandler(fn, createPageEvent, options, routerLoad);
+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) {
+    if (import.meta.env.BASE_URL === "/" || import.meta.env.BASE_URL === "")
+        return path;
+    return path.slice(import.meta.env.BASE_URL.length);
 }

package/dist/server/index.d.ts

@@ -1,6 +1,9 @@
-export { createHandler } from "./handler";
-export { StartServer } from "./StartServer";
-export type { APIEvent, APIHandler, Asset, ContextMatches, DocumentComponentProps, FetchEvent, HandlerOptions, PageEvent, ResponseStub, ServerFunctionMeta } from "./types";
-import { getServerFunctionMeta as getServerFunctionMeta_ } from "../shared/serverFunction";
-/** @deprecated */
-export declare const getServerFunctionMeta: typeof getServerFunctionMeta_;
+export { default as lazy } from "../shared/lazy.ts";
+export { getServerFunctionMeta } from "../shared/serverFunction.ts";
+export { StartServer } from "./StartServer.tsx";
+export { createHandler } from "./handler.ts";
+export type { APIEvent, APIHandler, Asset, ContextMatches, DocumentComponentProps, FetchEvent, HandlerOptions, PageEvent, ResponseStub, ServerFunctionMeta, } 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/index.jsx

@@ -1,6 +1,14 @@
-// @refresh skip
-export { createHandler } from "./handler";
-export { StartServer } from "./StartServer";
-import { getServerFunctionMeta as getServerFunctionMeta_ } from "../shared/serverFunction";
-/** @deprecated */
-export const getServerFunctionMeta = getServerFunctionMeta_;
+export { default as lazy } from "../shared/lazy.js";
+export { getServerFunctionMeta } from "../shared/serverFunction.js";
+export { StartServer } from "./StartServer.jsx";
+export { createHandler } from "./handler.js";
+/**
+ * Checks if user has set a redirect status in the response.
+ * If not, falls back to the 302 (temporary redirect)
+ */
+// export function getExpectedRedirectStatus(response: ResponseStub): number {
+//   if (response.status && validRedirectStatuses.has(response.status)) {
+//     return response.status;
+//   }
+//   return 302;
+// }

package/dist/server/manifest/client-manifest.d.ts

@@ -0,0 +1,9 @@
+export declare function getClientManifest(): {
+    import(id: string): Promise<any>;
+    getAssets(id: string): Promise<any[]>;
+} | {
+    import(id: string): Promise<any>;
+    getAssets(id: string): Promise<any>;
+    json(): Promise<any>;
+};
+export { getClientManifest as getManifest };

package/dist/server/manifest/client-manifest.js

@@ -0,0 +1,6 @@
+import { getClientDevManifest } from "./dev-client-manifest.js";
+import { getClientProdManifest } from "./prod-client-manifest.js";
+export function getClientManifest() {
+    return import.meta.env.DEV ? getClientDevManifest() : getClientProdManifest();
+}
+export { getClientManifest as getManifest };

package/dist/server/manifest/dev-client-manifest.d.ts

@@ -0,0 +1,4 @@
+export declare function getClientDevManifest(): {
+    import(id: string): Promise<any>;
+    getAssets(id: string): Promise<any[]>;
+};