@solidjs/start 1.2.0 → 2.0.0-alpha.0

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 };

package/dist/{router → server}/routes.d.ts

@@ -1,3 +1,4 @@
+import type { FetchEvent } from "./types.ts";
 interface Route {
     path: string;
     id: string;
@@ -11,18 +12,12 @@ interface Route {
     $PATCH?: any;
     $DELETE?: any;
 }
-declare module "vinxi/routes" {
-    interface Register {
-        route: {
-            path: string;
-            children?: Route[];
-        };
-    }
-}
 export declare const pageRoutes: Route[];
 export declare function matchAPIRoute(path: string, method: string): {
-    handler: any;
-    params: Record<string, any> | undefined;
+    params?: Record<string, any>;
+    handler: {
+        import: () => Promise<Record<string, (e: FetchEvent) => Promise<any>>>;
+    };
     isPage: boolean;
 } | undefined;
 export {};

package/dist/{router → server}/routes.js

@@ -1,16 +1,17 @@
+// @ts-expect-error
+import fileRoutes from "solid-start:routes";
 import { createRouter } from "radix3";
-import fileRoutes from "vinxi/routes";
-export const pageRoutes = defineRoutes(fileRoutes.filter(o => o.page));
+export const pageRoutes = defineRoutes(fileRoutes.filter((o) => o.page));
 function defineRoutes(fileRoutes) {
     function processRoute(routes, route, id, full) {
-        const parentRoute = Object.values(routes).find(o => {
+        const parentRoute = Object.values(routes).find((o) => {
             return id.startsWith(o.id + "/");
         });
         if (!parentRoute) {
             routes.push({
                 ...route,
                 id,
-                path: id.replace(/\([^)/]+\)/g, "").replace(/\/+/g, "/")
+                path: id.replace(/\([^)/]+\)/g, "").replace(/\/+/g, "/"),
             });
             return routes;
         }
@@ -23,45 +24,16 @@ function defineRoutes(fileRoutes) {
         return processRoute(prevRoutes, route, route.path, route.path);
     }, []);
 }
-export function matchAPIRoute(path, method) {
-    const match = router.lookup(path);
-    if (match && match.route) {
-        const route = match.route;
-        // Find the appropriate handler for the HTTP method
-        const handler = method === "HEAD"
-            ? route.$HEAD || route.$GET
-            : route[`$${method}`];
-        if (handler === undefined)
-            return;
-        // Check if this is a page route
-        const isPage = route.page === true && route.$component !== undefined;
-        // Return comprehensive route information
-        return {
-            handler,
-            params: match.params,
-            isPage
-        };
-    }
-    return undefined;
-}
-function containsHTTP(route) {
-    return (route["$HEAD"] ||
-        route["$GET"] ||
-        route["$POST"] ||
-        route["$PUT"] ||
-        route["$PATCH"] ||
-        route["$DELETE"]);
-}
 const router = createRouter({
     routes: fileRoutes.reduce((memo, route) => {
         if (!containsHTTP(route))
             return memo;
-        let path = route.path
+        const path = route.path
             .replace(/\([^)/]+\)/g, "")
             .replace(/\/+/g, "/")
             .replace(/\*([^/]*)/g, (_, m) => `**:${m}`)
             .split("/")
-            .map(s => (s.startsWith(":") || s.startsWith("*") ? s : encodeURIComponent(s)))
+            .map((s) => s.startsWith(":") || s.startsWith("*") ? s : encodeURIComponent(s))
             .join("/");
         if (/:[^/]*\?/g.test(path)) {
             throw new Error(`Optional parameters are not supported in API routes: ${path}`);
@@ -71,5 +43,32 @@ const router = createRouter({
         }
         memo[path] = { route };
         return memo;
-    }, {})
+    }, {}),
 });
+function containsHTTP(route) {
+    return (route["$HEAD"] ||
+        route["$GET"] ||
+        route["$POST"] ||
+        route["$PUT"] ||
+        route["$PATCH"] ||
+        route["$DELETE"]);
+}
+export function matchAPIRoute(path, method) {
+    const match = router.lookup(path);
+    if (match && match.route) {
+        const route = match.route;
+        // Find the appropriate handler for the HTTP method
+        const handler = method === "HEAD" ? route.$HEAD || route.$GET : route[`$${method}`];
+        if (handler === undefined)
+            return;
+        // Check if this is a page route
+        const isPage = route.page === true && route.$component !== undefined;
+        // Return comprehensive route information
+        return {
+            handler,
+            params: match.params,
+            isPage,
+        };
+    }
+    return undefined;
+}

package/dist/{runtime → server}/server-fns-runtime.d.ts

@@ -1 +1 @@
-export declare function createServerReference(fn: Function, id: string, name: string): Function;
+export declare function createServerReference(fn: Function, id: string): Function;

package/dist/{runtime → server}/server-fns-runtime.js

@@ -1,14 +1,15 @@
 import { getRequestEvent } from "solid-js/web";
 import { provideRequestEvent } from "solid-js/web/storage";
-import { cloneEvent } from "../server/fetchEvent";
-export function createServerReference(fn, id, name) {
+export function createServerReference(fn, id) {
     if (typeof fn !== "function")
         throw new Error("Export from a 'use server' module must be a function");
-    const baseURL = import.meta.env.SERVER_BASE_URL;
+    let baseURL = import.meta.env.BASE_URL ?? "/";
+    if (!baseURL.endsWith("/"))
+        baseURL += "/";
     return new Proxy(fn, {
         get(target, prop, receiver) {
             if (prop === "url") {
-                return `${baseURL}/_server?id=${encodeURIComponent(id)}&name=${encodeURIComponent(name)}`;
+                return `${baseURL}_server?id=${encodeURIComponent(id)}`;
             }
             if (prop === "GET")
                 return receiver;
@@ -18,9 +19,9 @@ export function createServerReference(fn, id, name) {
             const ogEvt = getRequestEvent();
             if (!ogEvt)
                 throw new Error("Cannot call server function outside of a request");
-            const evt = cloneEvent(ogEvt);
+            const evt = { ...ogEvt };
             evt.locals.serverFunctionMeta = {
-                id: id + "#" + name,
+                id
             };
             evt.serverOnly = true;
             return provideRequestEvent(evt, () => {

package/dist/server/server-functions-handler.d.ts

@@ -0,0 +1,2 @@
+import { type H3Event } from "h3";
+export declare function handleServerFunction(h3Event: H3Event): Promise<unknown>;