@solidjs/start 0.7.1 → 0.7.3

package/config/index.js

@@ -108,7 +108,7 @@ export function defineConfig(baseConfig = {}) {
             }),
             ...plugins,
             serverTransform({
-              runtime: normalize(fileURLToPath(new URL("./server-fns-runtime.ts", import.meta.url)))
+              runtime: normalize(fileURLToPath(new URL("../dist/runtime/server-fns-runtime.js", import.meta.url)))
             }),
             start.experimental.islands ? serverComponents.server() : null,
             solid({ ...start.solid, ssr: true, extensions: extensions.map(ext => `.${ext}`) }),
@@ -167,7 +167,7 @@ export function defineConfig(baseConfig = {}) {
             }),
             ...plugins,
             serverFunctions.client({
-              runtime: normalize(fileURLToPath(new URL("./server-runtime.ts", import.meta.url)))
+              runtime: normalize(fileURLToPath(new URL("../dist/runtime/server-runtime.js", import.meta.url)))
             }),
             start.experimental.islands ? serverComponents.client() : null,
             solid({ ...start.solid, ssr: start.ssr, extensions: extensions.map(ext => `.${ext}`) }),
@@ -207,7 +207,7 @@ export function defineConfig(baseConfig = {}) {
         name: "server-fns",
         type: "http",
         base: "/_server",
-        handler: normalize(fileURLToPath(new URL("./server-handler.ts", import.meta.url))),
+        handler: normalize(fileURLToPath(new URL("../dist/runtime/server-handler.js", import.meta.url))),
         middleware: start.middleware,
         target: "server",
         routes: solidStartServerFsRouter({ dir: routeDir, extensions }),
@@ -230,7 +230,7 @@ export function defineConfig(baseConfig = {}) {
             }),
             ...plugins,
             serverFunctionServer({
-              runtime: normalize(fileURLToPath(new URL("./server-fns-runtime.ts", import.meta.url)))
+              runtime: normalize(fileURLToPath(new URL("../dist/runtime/server-fns-runtime.js", import.meta.url)))
             }),
             solid({ ...start.solid, ssr: true, extensions: extensions.map(ext => `.${ext}`) }),
             config("app-server", {

package/config/server-components.js

@@ -20,7 +20,7 @@ function client() {
 }
 
 function server() {
-  const runtime = normalize(fileURLToPath(new URL("./server-runtime.ts", import.meta.url)));
+  const runtime = normalize(fileURLToPath(new URL("../dist/runtime/server-runtime.js", import.meta.url)));
   // export function serverComponents({
   // 	resolve = {
   // 		conditions: ["react-server"],

package/dist/client/StartClient.d.ts

@@ -0,0 +1,3 @@
+import type { JSX } from "solid-js";
+import "./mount";
+export declare function StartClient(): JSX.Element;

package/{client/StartClient.tsx → dist/client/StartClient.jsx}

@@ -1,22 +1,17 @@
 // @refresh skip
 // @ts-ignore
 import App from "#start/app";
-import type { JSX } from "solid-js";
 import { ErrorBoundary } from "../shared/ErrorBoundary";
 import "./mount";
-
-function Dummy(props: { children: JSX.Element }) {
-  return props.children;
+function Dummy(props) {
+    return props.children;
 }
-
 export function StartClient() {
-  return (
-    <Dummy>
+    return (<Dummy>
       <Dummy>
         <ErrorBoundary>
           <App />
         </ErrorBoundary>
       </Dummy>
-    </Dummy>
-  );
+    </Dummy>);
 }

package/{client/index.tsx → dist/client/index.d.ts}

@@ -1,4 +1,3 @@
 import "vinxi/client";
 export { StartClient } from "./StartClient";
 export { mount } from "./mount";
-

package/dist/client/index.jsx

@@ -0,0 +1,4 @@
+// @refresh skip
+import "vinxi/client";
+export { StartClient } from "./StartClient";
+export { mount } from "./mount";

package/dist/client/islands.d.ts

@@ -0,0 +1,3 @@
+import "vinxi/client";
+export declare function StartClient(): null;
+export { mount } from "./mount";

package/{client/islands.ts → dist/client/islands.jsx}

@@ -1,6 +1,6 @@
 // @refresh skip
 import "vinxi/client";
 export function StartClient() {
-  return null;
+    return null;
 }
 export { mount } from "./mount";

package/dist/client/mount.d.ts

@@ -0,0 +1,3 @@
+import type { JSX } from "solid-js";
+import { type MountableElement } from "solid-js/web";
+export declare function mount(fn: () => JSX.Element, el: MountableElement): (() => void) | undefined;

package/dist/client/mount.js

@@ -0,0 +1,85 @@
+import { createStore } from "solid-js/store";
+import { createComponent, getHydrationKey, getOwner, hydrate } from "solid-js/web";
+export function mount(fn, el) {
+    if (import.meta.env.START_ISLANDS) {
+        const map = new WeakMap();
+        async function mountIsland(el) {
+            if (el.dataset.css) {
+                let css = JSON.parse(el.dataset.css);
+                for (let href of css) {
+                    if (!document.querySelector(`link[href="${href}"]`)) {
+                        let link = document.createElement("link");
+                        link.rel = "stylesheet";
+                        link.href = href;
+                        document.head.appendChild(link);
+                    }
+                }
+            }
+            let mod = await import(
+            /* @vite-ignore */
+            import.meta.env.MANIFEST["client"].chunks[el.dataset.id.split("#")[0]].output.path);
+            if (!mod || !el.dataset.hk)
+                return;
+            let Component = mod[el.dataset.id.split("#")[1]];
+            let hk = el.dataset.hk;
+            // _$DEBUG("hydrating island", el.dataset.island, hk.slice(0, hk.length - 1) + `1-`, el);
+            let props = createStore({
+                ...JSON.parse(el.dataset.props),
+                get children() {
+                    const p = el.getElementsByTagName("solid-children");
+                    getHydrationKey();
+                    [...p].forEach(a => {
+                        a.__$owner = getOwner();
+                    });
+                    return;
+                }
+            });
+            map.set(el, props);
+            hydrate(() => createComponent(Component, props[0]), el, {
+                renderId: hk.slice(0, hk.length - 1) + `${1 + Number(el.dataset.offset)}-`,
+                owner: lookupOwner(el)
+            });
+            delete el.dataset.hk;
+            el.dataset.hkk = hk;
+        }
+        let queue = [];
+        let queued = false;
+        function runTaskQueue(info) {
+            while (info.timeRemaining() > 0 && queue.length) {
+                mountIsland(queue.shift());
+            }
+            if (queue.length) {
+                requestIdleCallback(runTaskQueue);
+            }
+            else
+                queued = false;
+        }
+        const hydrateIslands = () => {
+            const islands = document.querySelectorAll("solid-island[data-hk]");
+            const assets = new Set();
+            islands.forEach((el) => el.dataset.id && assets.add(el.dataset.id));
+            Promise.all([...assets].map(asset => import(/* @vite-ignore */ import.meta.env.MANIFEST["client"].chunks[asset.split("#")[0]].output.path)))
+                .then(() => {
+                islands.forEach((el) => {
+                    if (el.dataset.when === "idle" && "requestIdleCallback" in window) {
+                        if (!queued) {
+                            queued = true;
+                            requestIdleCallback(runTaskQueue);
+                        }
+                        queue.push(el);
+                    }
+                    else
+                        mountIsland(el);
+                });
+            })
+                .catch(e => console.error(e));
+        };
+        function lookupOwner(el) {
+            const parent = el.closest("solid-children");
+            return parent && parent.__$owner;
+        }
+        hydrateIslands();
+        return;
+    }
+    return hydrate(fn, el);
+}

package/dist/client/spa/index.d.ts

@@ -0,0 +1,5 @@
+import type { JSX } from "solid-js";
+import { type MountableElement } from "solid-js/web";
+import "vinxi/client";
+export declare function mount(fn: () => JSX.Element, el: MountableElement): void;
+export { StartClient } from "../StartClient";

package/dist/client/spa/index.jsx

@@ -0,0 +1,6 @@
+import { render } from "solid-js/web";
+import "vinxi/client";
+export function mount(fn, el) {
+    render(fn, el);
+}
+export { StartClient } from "../StartClient";

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { GET } from "./shared/GET";
+export { HttpHeader } from "./shared/HttpHeader";
+export { HttpStatusCode } from "./shared/HttpStatusCode";
+export { default as clientOnly } from "./shared/clientOnly";

package/dist/index.jsx

@@ -0,0 +1,5 @@
+// @refresh skip
+export { GET } from "./shared/GET";
+export { HttpHeader } from "./shared/HttpHeader";
+export { HttpStatusCode } from "./shared/HttpStatusCode";
+export { default as clientOnly } from "./shared/clientOnly";

package/dist/middleware/index.d.ts

@@ -0,0 +1,18 @@
+import type { FetchEvent } from "../server/types";
+/** Function responsible for receiving an observable [operation]{@link Operation} and returning a [result]{@link OperationResult}. */
+export type MiddlewareFn = (event: FetchEvent) => Promise<unknown> | unknown;
+/** This composes an array of Exchanges into a single ExchangeIO function */
+export type RequestMiddleware = (event: FetchEvent) => Response | Promise<Response> | void | Promise<void>;
+type EventHandlerResponse<T = any> = T | Promise<T>;
+type ResponseMiddlewareResponseParam = {
+    body?: Awaited<EventHandlerResponse>;
+};
+export type ResponseMiddleware = (event: FetchEvent, response: ResponseMiddlewareResponseParam) => Response | Promise<Response> | void | Promise<void>;
+export declare function createMiddleware({ onRequest, onBeforeResponse }: {
+    onRequest?: RequestMiddleware | RequestMiddleware[] | undefined;
+    onBeforeResponse?: ResponseMiddleware | ResponseMiddleware[] | undefined;
+}): {
+    onRequest?: import("h3")._RequestMiddleware<import("h3").EventHandlerRequest> | import("h3")._RequestMiddleware<import("h3").EventHandlerRequest>[] | undefined;
+    onBeforeResponse?: import("h3")._ResponseMiddleware<import("h3").EventHandlerRequest, any> | import("h3")._ResponseMiddleware<import("h3").EventHandlerRequest, any>[] | undefined;
+};
+export {};

package/dist/middleware/index.js

@@ -0,0 +1,40 @@
+import { defineMiddleware, sendWebResponse } from "vinxi/http";
+import { getFetchEvent } from "../server/fetchEvent.js";
+function wrapRequestMiddleware(onRequest) {
+    return async (h3Event) => {
+        const fetchEvent = getFetchEvent(h3Event);
+        const response = await onRequest(fetchEvent);
+        if (!response) {
+            return;
+        }
+        else {
+            sendWebResponse(h3Event, response);
+        }
+    };
+}
+function wrapResponseMiddleware(onBeforeResponse) {
+    return async (h3Event, response) => {
+        const fetchEvent = getFetchEvent(h3Event);
+        const mwResponse = await onBeforeResponse(fetchEvent, response);
+        if (!mwResponse) {
+            return;
+        }
+        else {
+            sendWebResponse(h3Event, mwResponse);
+        }
+    };
+}
+export function createMiddleware({ onRequest, onBeforeResponse }) {
+    return defineMiddleware({
+        onRequest: typeof onRequest === "function"
+            ? wrapRequestMiddleware(onRequest)
+            : Array.isArray(onRequest)
+                ? onRequest.map(wrapRequestMiddleware)
+                : undefined,
+        onBeforeResponse: typeof onBeforeResponse === "function"
+            ? wrapResponseMiddleware(onBeforeResponse)
+            : Array.isArray(onBeforeResponse)
+                ? onBeforeResponse.map(wrapResponseMiddleware)
+                : undefined
+    });
+}

package/dist/router/FileRoutes.d.ts

@@ -0,0 +1,2 @@
+export declare function createRoutes(): any[];
+export declare const FileRoutes: () => any[];

package/dist/router/FileRoutes.js

@@ -0,0 +1,25 @@
+import { getRequestEvent, isServer } from "solid-js/web";
+import lazyRoute from "./lazyRoute";
+import { pageRoutes as routeConfigs } from "./routes";
+export function createRoutes() {
+    function createRoute(route) {
+        return {
+            ...route,
+            ...(route.$$route ? route.$$route.require().route : undefined),
+            info: {
+                ...(route.$$route ? route.$$route.require().route.info : {}),
+                filesystem: true
+            },
+            component: lazyRoute(route.$component, import.meta.env.START_ISLANDS
+                ? import.meta.env.MANIFEST["ssr"]
+                : import.meta.env.MANIFEST["client"], import.meta.env.MANIFEST["ssr"]),
+            children: route.children ? route.children.map(createRoute) : undefined
+        };
+    }
+    const routes = routeConfigs.map(createRoute);
+    return routes;
+}
+let routes;
+export const FileRoutes = isServer
+    ? () => getRequestEvent().routes
+    : () => routes || (routes = createRoutes());

package/dist/router/index.jsx

@@ -0,0 +1,2 @@
+/* @refresh skip */
+export { FileRoutes } from "./FileRoutes";

package/dist/router/lazyRoute.d.ts

@@ -0,0 +1,6 @@
+import { type Component } from "solid-js";
+export default function lazyRoute<T>(component: any, clientManifest: any, serverManifest: any, exported?: string): Component<T> & {
+    preload: () => Promise<{
+        default: Component<T>;
+    }>;
+};

package/dist/router/lazyRoute.js

@@ -0,0 +1,48 @@
+/// <reference types="vinxi/types/client" />
+import { createComponent, lazy, onCleanup } from "solid-js";
+import { appendStyles, cleanupStyles, preloadStyles, updateStyles } from "vinxi/css";
+import { renderAsset } from "../server/renderAsset";
+export default function lazyRoute(component, clientManifest, serverManifest, exported = "default") {
+    return lazy(async () => {
+        if (import.meta.env.DEV) {
+            let manifest = import.meta.env.SSR ? serverManifest : clientManifest;
+            const mod = await manifest.inputs[component.src].import();
+            if (!mod[exported])
+                console.error(`Module ${component.src} does not export ${exported}`);
+            const Component = mod[exported];
+            let assets = await clientManifest.inputs?.[component.src].assets();
+            const styles = assets.filter((asset) => asset.tag === "style");
+            if (typeof window !== "undefined" && import.meta.hot) {
+                import.meta.hot.on("css-update", data => {
+                    updateStyles(styles, data);
+                });
+            }
+            const Comp = props => {
+                if (typeof window !== "undefined") {
+                    appendStyles(styles);
+                }
+                onCleanup(() => {
+                    if (typeof window !== "undefined") {
+                        // remove style tags added by vite when a CSS file is imported
+                        cleanupStyles(styles);
+                    }
+                });
+                return [...assets.map((asset) => renderAsset(asset)), createComponent(Component, props)];
+            };
+            return { default: Comp };
+        }
+        else {
+            const mod = await component.import();
+            const Component = mod[exported];
+            let assets = await clientManifest.inputs?.[component.src].assets();
+            const styles = assets.filter((asset) => asset.tag === "style" || asset.attrs.rel === "stylesheet");
+            if (typeof window !== "undefined") {
+                preloadStyles(styles);
+            }
+            const Comp = props => {
+                return [...styles.map((asset) => renderAsset(asset)), createComponent(Component, props)];
+            };
+            return { default: Comp };
+        }
+    });
+}

package/dist/router/routes.d.ts

@@ -0,0 +1,25 @@
+interface Route {
+    path: string;
+    id: string;
+    children?: Route[];
+    $component?: any;
+    $GET?: any;
+    $POST?: any;
+    $PUT?: any;
+    $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;
+} | undefined;
+export {};

package/dist/router/routes.js

@@ -0,0 +1,51 @@
+import { createRouter } from "radix3";
+import fileRoutes from "vinxi/routes";
+export const pageRoutes = defineRoutes(fileRoutes.filter(o => o.$component));
+function defineRoutes(fileRoutes) {
+    function processRoute(routes, route, id, full) {
+        const parentRoute = Object.values(routes).find(o => {
+            return id.startsWith(o.id + "/");
+        });
+        if (!parentRoute) {
+            routes.push({ ...route, id, path: id.replace(/\/\([^)/]+\)/g, "").replace(/\./g, "/") });
+            return routes;
+        }
+        processRoute(parentRoute.children || (parentRoute.children = []), route, id.slice(parentRoute.id.length), full);
+        return routes;
+    }
+    return fileRoutes
+        .sort((a, b) => a.path.length - b.path.length)
+        .reduce((prevRoutes, route) => {
+        return processRoute(prevRoutes, route, route.path, route.path);
+    }, []);
+}
+export function matchAPIRoute(path, method) {
+    const match = router.lookup(path);
+    if (match) {
+        const handler = match.route[`$${method}`];
+        if (handler === undefined)
+            return;
+        return {
+            handler,
+            params: match.params
+        };
+    }
+}
+function containsHTTP(route) {
+    return 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.replace(/\(.*\)\/?/g, "").replace(/\*([^/]*)/g, (_, m) => `**:${m}`);
+        if (/:[^/]*\?/g.test(path)) {
+            throw new Error(`Optional parameters are not supported in API routes: ${path}`);
+        }
+        if (memo[path]) {
+            throw new Error(`Duplicate API routes for "${path}" found at "${memo[path].route.path}" and "${route.path}"`);
+        }
+        memo[path] = { route };
+        return memo;
+    }, {})
+});

package/dist/runtime/server-fns-runtime.d.ts

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

package/dist/runtime/server-fns-runtime.js

@@ -0,0 +1,30 @@
+import { getRequestEvent } from "solid-js/web";
+import { provideRequestEvent } from "solid-js/web/storage";
+import { cloneEvent } from "../server/fetchEvent";
+export function createServerReference(fn, id, name) {
+    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;
+    return new Proxy(fn, {
+        get(target, prop, receiver) {
+            if (prop === "url") {
+                return `${baseURL}/_server?id=${encodeURIComponent(id)}&name=${encodeURIComponent(name)}`;
+            }
+            if (prop === "GET")
+                return receiver;
+        },
+        apply(target, thisArg, args) {
+            const ogEvt = getRequestEvent();
+            if (!ogEvt)
+                throw new Error("Cannot call server function outside of a request");
+            const evt = cloneEvent(ogEvt);
+            evt.locals.serverFunctionMeta = {
+                id: id + "#" + name,
+            };
+            evt.serverOnly = true;
+            return provideRequestEvent(evt, () => {
+                return fn.apply(thisArg, args);
+            });
+        }
+    });
+}

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

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<unknown>>;
+export default _default;