@solidjs/start 1.1.7 → 2.0.0-alpha.0

package/dist/server/fetchEvent.spec.js

@@ -0,0 +1,65 @@
+import * as h3 from "h3";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { createFetchEvent, getFetchEvent, mergeResponseHeaders, } from "./fetchEvent.js";
+vi.mock(import("h3"), async (mod) => {
+    return {
+        ...(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();
+        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.req,
+                response: expect.any(Object),
+                clientAddress: "127.0.0.1",
+                locals: {},
+                nativeEvent: mockH3Event,
+            });
+        });
+        it("should create response stub with correct properties", () => {
+            const fetchEvent = createFetchEvent(mockH3Event);
+            expect(fetchEvent.response).toHaveProperty("status");
+            expect(fetchEvent.response).toHaveProperty("statusText");
+            expect(fetchEvent.response).toHaveProperty("headers");
+        });
+    });
+    describe("getFetchEvent", () => {
+        it("should create and cache FetchEvent on first call", () => {
+            const fetchEvent = getFetchEvent(mockH3Event);
+            expect(mockH3Event.context.solidFetchEvent).toBe(fetchEvent);
+            expect(fetchEvent.nativeEvent).toBe(mockH3Event);
+        });
+        it("should return cached FetchEvent on subsequent calls", () => {
+            const firstCall = getFetchEvent(mockH3Event);
+            const secondCall = getFetchEvent(mockH3Event);
+            expect(firstCall).toBe(secondCall);
+        });
+    });
+    describe("mergeResponseHeaders", () => {
+        it("should merge headers from Headers object to H3Event", () => {
+            const headers = new Headers({
+                "content-type": "application/json",
+                "x-custom": "value",
+            });
+            mergeResponseHeaders(mockH3Event, headers);
+            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("h3").EventHandler<import("h3").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("h3").EventHandler<import("h3").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,106 +1,182 @@
+import middleware from "solid-start:middleware";
+import { defineHandler, getCookie, H3, redirect, setCookie } from "h3";
+import { join } from "pathe";
 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.`);
-                    }
-                }
-                // 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;
+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 = url.pathname;
+            const serverFunctionTest = join(import.meta.env.BASE_URL, SERVER_FN_BASE);
+            if (pathname.startsWith(serverFunctionTest)) {
+                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;
                 }
-                if (resolvedOptions.onCompleteAll) {
-                    const og = resolvedOptions.onCompleteAll;
-                    resolvedOptions.onCompleteAll = options => {
-                        handleStreamCompleteRedirect(context)(options);
-                        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.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(() => {
+                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"));
         }
     };
 }
@@ -111,10 +187,19 @@ 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) {
+        ret = new Response(res.body, {
+            status: res.status,
+            statusText: res.statusText,
+            headers: Object.fromEntries(res.headers.entries())
+        });
+    }
+    for (const [name, value] of event.response.headers) {
+        ret.headers.set(name, value);
+    }
+    return ret;
 }

package/dist/server/index.d.ts

@@ -1,6 +1,8 @@
-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";
+/**
+ * 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[]>;
+};

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

@@ -0,0 +1,24 @@
+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 "pathe";
+export function getClientDevManifest() {
+    return {
+        import(id) {
+            return import(__rewriteRelativeImportExtension(/* @vite-ignore */ join("/", id), true));
+        },
+        async getAssets(id) {
+            const assetsPath = `/@manifest/client/${Date.now()}/assets?id=${id}`;
+            const assets = (await import(__rewriteRelativeImportExtension(/* @vite-ignore */ assetsPath, true))).default;
+            return await Promise.all(assets.map(async (v) => ({
+                ...v,
+                children: await v.children()
+            })));
+        },
+    };
+}

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

@@ -0,0 +1,5 @@
+export declare function getSsrDevManifest(environment: "client" | "ssr"): {
+    path: (id: string) => string;
+    getAssets(id: string): Promise<any[]>;
+};
+export { getSsrDevManifest as getSsrManifest };

package/dist/server/manifest/dev-ssr-manifest.js

@@ -0,0 +1,23 @@
+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, normalize } from "pathe";
+export function getSsrDevManifest(environment) {
+    return {
+        path: (id) => normalize(join(import.meta.env.BASE_URL, id)),
+        async getAssets(id) {
+            const assetsPath = `/@manifest/${environment}/${Date.now()}/assets?id=${id}`;
+            const assets = (await import(__rewriteRelativeImportExtension(/* @vite-ignore */ assetsPath, true))).default;
+            return await Promise.all(assets.map(async (v) => ({
+                ...v,
+                children: await v.children()
+            })));
+        },
+    };
+}
+export { getSsrDevManifest as getSsrManifest };

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

@@ -0,0 +1,5 @@
+export declare function getClientProdManifest(): {
+    import(id: string): Promise<any>;
+    getAssets(id: string): Promise<any>;
+    json(): Promise<any>;
+};

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

@@ -0,0 +1,26 @@
+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;
+};
+export function getClientProdManifest() {
+    return {
+        import(id) {
+            // @ts-ignore
+            return import(__rewriteRelativeImportExtension(/* @vite-ignore */ window.manifest[id].output, true));
+        },
+        async getAssets(id) {
+            if (id.startsWith("./"))
+                id = id.slice(2);
+            // @ts-ignore
+            return window.manifest[id]?.assets ?? [];
+        },
+        async json() {
+            // @ts-ignore
+            return window.manifest;
+        },
+    };
+}

package/dist/server/manifest/prod-ssr-manifest.d.ts

@@ -0,0 +1,6 @@
+import type { Asset } from "../assets/render.tsx";
+export declare function getSsrProdManifest(): {
+    path(id: string): string;
+    getAssets(id: string): Promise<Asset[]>;
+    json(): Promise<Record<string, any>>;
+};

package/dist/server/manifest/prod-ssr-manifest.js

@@ -0,0 +1,90 @@
+import { clientViteManifest } from "solid-start:client-vite-manifest";
+import { join } from "pathe";
+// Only reads from client manifest atm, might need server support for islands
+export function getSsrProdManifest() {
+    const viteManifest = clientViteManifest;
+    return {
+        path(id) {
+            if (id.startsWith("./"))
+                id = id.slice(2);
+            const viteManifestEntry = clientViteManifest[id /*import.meta.env.START_CLIENT_ENTRY*/];
+            if (!viteManifestEntry)
+                throw new Error(`No entry found in vite manifest for '${id}'`);
+            return join("/", viteManifestEntry.file);
+        },
+        async getAssets(id) {
+            if (id.startsWith("./"))
+                id = id.slice(2);
+            return createHtmlTagsForAssets(findAssetsInViteManifest(clientViteManifest, id));
+        },
+        async json() {
+            const json = {};
+            const entryKeys = Object.keys(viteManifest)
+                .filter((id) => viteManifest[id]?.isEntry || viteManifest[id]?.isDynamicEntry)
+                .map((id) => id);
+            for (const entryKey of entryKeys) {
+                json[entryKey] = {
+                    output: join("/", viteManifest[entryKey].file),
+                    assets: await this.getAssets(entryKey),
+                };
+            }
+            return json;
+        },
+    };
+}
+function createHtmlTagsForAssets(assets) {
+    return assets
+        .filter((asset) => asset.endsWith(".css") ||
+        asset.endsWith(".js") ||
+        asset.endsWith(".ts") ||
+        asset.endsWith(".mjs"))
+        .map((asset) => ({
+        tag: "link",
+        attrs: {
+            href: '/' + asset,
+            key: asset,
+            ...(asset.endsWith(".css")
+                ? { rel: "stylesheet" }
+                : { rel: "modulepreload" }),
+        },
+    }));
+}
+const entryId = import.meta.env.START_CLIENT_ENTRY.slice(2);
+let entryImports = undefined;
+function findAssetsInViteManifest(manifest, id, assetMap = new Map(), stack = []) {
+    if (stack.includes(id)) {
+        return [];
+    }
+    const cached = assetMap.get(id);
+    if (cached) {
+        return cached;
+    }
+    const chunk = manifest[id];
+    if (!chunk) {
+        return [];
+    }
+    if (!entryImports) {
+        entryImports = [
+            entryId,
+            ...(manifest[entryId]?.imports ?? [])
+        ];
+    }
+    // Only include entry imports, if we are specifically crawling the entry
+    // Chunks (e.g. routes) that import something from entry, should not render entry css redundantly
+    const excludeEntryImports = id !== entryId;
+    const assets = chunk.css?.filter(Boolean) || [];
+    if (chunk.imports) {
+        stack.push(id);
+        for (let i = 0, l = chunk.imports.length; i < l; i++) {
+            const importId = chunk.imports[i];
+            if (!importId || (excludeEntryImports && entryImports.includes(importId)))
+                continue;
+            assets.push(...findAssetsInViteManifest(manifest, importId, assetMap, stack));
+        }
+        stack.pop();
+    }
+    assets.push(chunk.file);
+    const all = Array.from(new Set(assets));
+    assetMap.set(id, all);
+    return all;
+}

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

@@ -0,0 +1,4 @@
+import { getSsrDevManifest } from "./dev-ssr-manifest.ts";
+import { getSsrProdManifest } from "./prod-ssr-manifest.ts";
+export declare function getSsrManifest(target: "client" | "ssr"): ReturnType<typeof getSsrDevManifest> | ReturnType<typeof getSsrProdManifest>;
+export { getSsrManifest as getManifest };

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

@@ -0,0 +1,6 @@
+import { getSsrDevManifest } from "./dev-ssr-manifest.js";
+import { getSsrProdManifest } from "./prod-ssr-manifest.js";
+export function getSsrManifest(target) {
+    return import.meta.env.DEV ? getSsrDevManifest(target) : getSsrProdManifest();
+}
+export { getSsrManifest as getManifest };