vorzelajs 0.0.1

package/dist/runtime/resolve.js

@@ -0,0 +1,449 @@
+import { parseErrorStack } from '../debug/error-stack';
+// @ts-expect-error resolved by vorzelajs vite plugin
+import { routeHydrationManifest } from 'virtual:vorzela/hydration';
+// @ts-expect-error resolved by vorzelajs vite plugin
+import { routeManifest } from 'virtual:vorzela/routes';
+import { mergeHeads } from './head';
+import { isNotFound, isRedirect } from './navigation';
+import { buildRouteBranch, matchPathPattern, normalizePath } from './path';
+const generatedRouteHydrationManifest = routeHydrationManifest;
+const generatedRouteManifest = routeManifest;
+function createResponseStub() {
+    return {
+        headers: new Headers(),
+        status: 200,
+    };
+}
+function createClientRequest(pathname) {
+    if (typeof window === 'undefined') {
+        return new Request(`http://localhost${pathname}`);
+    }
+    return new Request(new URL(pathname, window.location.origin), {
+        headers: {
+            'X-Vorzela-Navigation': 'client',
+        },
+    });
+}
+function createRouteLocation(target, pathname, request) {
+    const targetUrl = new URL(target, new URL(request.url).origin);
+    return {
+        href: targetUrl.href,
+        pathname,
+        search: targetUrl.search,
+        searchParams: targetUrl.searchParams,
+    };
+}
+function createRawSearch(searchParams) {
+    const rawSearch = {};
+    for (const key of new Set(searchParams.keys())) {
+        const values = searchParams.getAll(key);
+        rawSearch[key] = values.length <= 1 ? values[0] : values;
+    }
+    return rawSearch;
+}
+function selectBestMatch(pathname) {
+    return generatedRouteManifest
+        .filter((entry) => entry.id !== '__root__' && entry.matchPath !== null)
+        .map((entry) => ({
+        entry,
+        result: matchPathPattern(entry.matchPath, pathname),
+    }))
+        .filter((candidate) => candidate.result.matched)
+        .sort((left, right) => {
+        if (left.result.score !== right.result.score) {
+            return right.result.score - left.result.score;
+        }
+        return right.entry.fullPath.length - left.entry.fullPath.length;
+    })[0];
+}
+async function loadRouteDefinition(entry) {
+    const module = await entry.loadRoute();
+    return module.Route;
+}
+function resolveNotFoundHandlerId(loadedEntries) {
+    for (let index = loadedEntries.length - 1; index >= 0; index -= 1) {
+        const candidate = loadedEntries[index];
+        if (candidate.route.options.notFoundComponent) {
+            return candidate.entry.id;
+        }
+    }
+    return null;
+}
+function resolveErrorHandlerId(loadedEntries) {
+    for (let index = loadedEntries.length - 1; index >= 0; index -= 1) {
+        const candidate = loadedEntries[index];
+        if (candidate.route.options.errorComponent) {
+            return candidate.entry.id;
+        }
+    }
+    return null;
+}
+function createRouteErrorData(error, phase) {
+    const debug = process.env.NODE_ENV !== 'production'
+        ? parseErrorStack(error)
+        : undefined;
+    if (error instanceof Error) {
+        return {
+            debug,
+            message: error.message || 'Unexpected route error',
+            name: error.name || 'Error',
+            phase,
+            status: 500,
+        };
+    }
+    return {
+        debug,
+        message: typeof error === 'string' ? error : 'Unexpected route error',
+        name: 'Error',
+        phase,
+        status: 500,
+    };
+}
+function createRouteErrorState(loadedEntries, targetId, error, phase) {
+    return {
+        handlerId: resolveErrorHandlerId(loadedEntries),
+        targetId,
+        error: createRouteErrorData(error, phase),
+    };
+}
+function resolveMatchHydration(entry, route) {
+    const detected = generatedRouteHydrationManifest[entry.id]?.detected ?? 'static';
+    const configured = route.options.hydration ?? 'auto';
+    return configured === 'auto' ? detected : configured;
+}
+function createResolvedMatch(entry, route, params, loaderData, search) {
+    return {
+        fullPath: entry.fullPath,
+        hydration: resolveMatchHydration(entry, route),
+        id: entry.id,
+        loaderData,
+        params,
+        route,
+        search,
+    };
+}
+function validateRouteSearch(route, rawSearch) {
+    return route.options.validateSearch
+        ? route.options.validateSearch(rawSearch)
+        : rawSearch;
+}
+async function materializeMatches(matches) {
+    const routesById = new Map(generatedRouteManifest.map((entry) => [entry.id, entry]));
+    return Promise.all(matches.map(async (match) => {
+        const entry = routesById.get(match.id);
+        if (!entry) {
+            throw new Error(`Unknown route id: ${match.id}`);
+        }
+        return {
+            ...match,
+            route: await loadRouteDefinition(entry),
+        };
+    }));
+}
+export async function resolveRoute(target, options = {}) {
+    const normalized = normalizePath(target);
+    const request = options.request ?? createClientRequest(target);
+    const responseStub = createResponseStub();
+    const context = options.context ?? {};
+    const location = createRouteLocation(target, normalized, request);
+    const rawSearch = createRawSearch(location.searchParams);
+    const bestMatch = selectBestMatch(normalized);
+    if (!bestMatch) {
+        const rootEntry = generatedRouteManifest.find((entry) => entry.id === '__root__');
+        if (!rootEntry) {
+            throw new Error(`No route matched ${normalized}`);
+        }
+        const rootRoute = await loadRouteDefinition(rootEntry);
+        let rootSearch = rawSearch;
+        if (rootRoute.options.validateSearch) {
+            try {
+                rootSearch = validateRouteSearch(rootRoute, rawSearch);
+            }
+            catch (error) {
+                if (isRedirect(error)) {
+                    throw error;
+                }
+                if (isNotFound(error)) {
+                    return {
+                        head: mergeHeads([]),
+                        matches: [
+                            createResolvedMatch(rootEntry, rootRoute, {}, undefined, rawSearch),
+                        ],
+                        notFound: {
+                            handlerId: rootRoute.options.notFoundComponent ? rootEntry.id : null,
+                            targetId: rootEntry.id,
+                        },
+                        pathname: normalized,
+                        renderSource: 'component',
+                        responseHeaders: responseStub.headers,
+                        search: location.search,
+                    };
+                }
+                return {
+                    head: mergeHeads([]),
+                    matches: [
+                        createResolvedMatch(rootEntry, rootRoute, {}, undefined, rawSearch),
+                    ],
+                    pathname: normalized,
+                    renderSource: 'component',
+                    responseHeaders: responseStub.headers,
+                    routeError: createRouteErrorState([{ entry: rootEntry, route: rootRoute }], rootEntry.id, error, 'validateSearch'),
+                    search: location.search,
+                };
+            }
+        }
+        const head = rootRoute.options.head
+            ? rootRoute.options.head({
+                context,
+                loaderData: undefined,
+                location,
+                params: {},
+                pathname: normalized,
+                search: rootSearch,
+            })
+            : undefined;
+        return {
+            head: mergeHeads([head]),
+            matches: [
+                createResolvedMatch(rootEntry, rootRoute, {}, undefined, rootSearch),
+            ],
+            notFound: {
+                handlerId: rootRoute.options.notFoundComponent ? rootEntry.id : null,
+                targetId: rootEntry.id,
+            },
+            pathname: normalized,
+            renderSource: 'component',
+            responseHeaders: responseStub.headers,
+            search: location.search,
+        };
+    }
+    const branchEntries = buildRouteBranch(generatedRouteManifest, bestMatch.entry.id);
+    const accumulatedHeads = [];
+    const matches = [];
+    const loadedEntries = [];
+    for (const entry of branchEntries) {
+        const route = await loadRouteDefinition(entry);
+        const params = bestMatch.result.params;
+        loadedEntries.push({ entry, route });
+        let validatedSearch = rawSearch;
+        if (route.options.validateSearch) {
+            try {
+                validatedSearch = validateRouteSearch(route, rawSearch);
+            }
+            catch (error) {
+                if (isRedirect(error)) {
+                    throw error;
+                }
+                if (isNotFound(error)) {
+                    matches.push(createResolvedMatch(entry, route, params, undefined, rawSearch));
+                    return {
+                        head: mergeHeads(accumulatedHeads),
+                        matches,
+                        notFound: {
+                            handlerId: resolveNotFoundHandlerId(loadedEntries),
+                            targetId: entry.id,
+                        },
+                        pathname: normalized,
+                        renderSource: 'component',
+                        responseHeaders: responseStub.headers,
+                        search: location.search,
+                    };
+                }
+                matches.push(createResolvedMatch(entry, route, params, undefined, rawSearch));
+                return {
+                    head: mergeHeads(accumulatedHeads),
+                    matches,
+                    pathname: normalized,
+                    renderSource: 'component',
+                    responseHeaders: responseStub.headers,
+                    routeError: createRouteErrorState(loadedEntries, entry.id, error, 'validateSearch'),
+                    search: location.search,
+                };
+            }
+        }
+        if (route.options.beforeLoad) {
+            try {
+                const beforeLoadResult = await route.options.beforeLoad({
+                    context,
+                    location,
+                    params: params,
+                    pathname: normalized,
+                    request,
+                    response: responseStub,
+                    search: validatedSearch,
+                });
+                if (isRedirect(beforeLoadResult) || isNotFound(beforeLoadResult)) {
+                    throw beforeLoadResult;
+                }
+            }
+            catch (error) {
+                if (isRedirect(error)) {
+                    throw error;
+                }
+                if (isNotFound(error)) {
+                    matches.push(createResolvedMatch(entry, route, params, undefined, validatedSearch));
+                    return {
+                        head: mergeHeads(accumulatedHeads),
+                        matches,
+                        notFound: {
+                            handlerId: resolveNotFoundHandlerId(loadedEntries),
+                            targetId: entry.id,
+                        },
+                        pathname: normalized,
+                        renderSource: 'component',
+                        responseHeaders: responseStub.headers,
+                        search: location.search,
+                    };
+                }
+                matches.push(createResolvedMatch(entry, route, params, undefined, validatedSearch));
+                return {
+                    head: mergeHeads(accumulatedHeads),
+                    matches,
+                    pathname: normalized,
+                    renderSource: 'component',
+                    responseHeaders: responseStub.headers,
+                    routeError: createRouteErrorState(loadedEntries, entry.id, error, 'beforeLoad'),
+                    search: location.search,
+                };
+            }
+        }
+        let loaderData;
+        if (route.options.loader) {
+            try {
+                loaderData = await route.options.loader({
+                    context,
+                    location,
+                    params: params,
+                    pathname: normalized,
+                    request,
+                    response: responseStub,
+                    search: validatedSearch,
+                });
+            }
+            catch (error) {
+                if (isRedirect(error)) {
+                    throw error;
+                }
+                if (isNotFound(error)) {
+                    matches.push(createResolvedMatch(entry, route, params, undefined, validatedSearch));
+                    return {
+                        head: mergeHeads(accumulatedHeads),
+                        matches,
+                        notFound: {
+                            handlerId: resolveNotFoundHandlerId(loadedEntries),
+                            targetId: entry.id,
+                        },
+                        pathname: normalized,
+                        renderSource: 'component',
+                        responseHeaders: responseStub.headers,
+                        search: location.search,
+                    };
+                }
+                matches.push(createResolvedMatch(entry, route, params, undefined, validatedSearch));
+                return {
+                    head: mergeHeads(accumulatedHeads),
+                    matches,
+                    pathname: normalized,
+                    renderSource: 'component',
+                    responseHeaders: responseStub.headers,
+                    routeError: createRouteErrorState(loadedEntries, entry.id, error, 'loader'),
+                    search: location.search,
+                };
+            }
+        }
+        let head;
+        if (route.options.head) {
+            try {
+                head = route.options.head({
+                    context,
+                    loaderData,
+                    location,
+                    params: params,
+                    pathname: normalized,
+                    search: validatedSearch,
+                });
+                if (head) {
+                    accumulatedHeads.push(head);
+                }
+            }
+            catch (error) {
+                matches.push(createResolvedMatch(entry, route, params, loaderData, validatedSearch));
+                return {
+                    head: mergeHeads(accumulatedHeads),
+                    matches,
+                    pathname: normalized,
+                    renderSource: 'component',
+                    responseHeaders: responseStub.headers,
+                    routeError: createRouteErrorState(loadedEntries, entry.id, error, 'render'),
+                    search: location.search,
+                };
+            }
+        }
+        matches.push(createResolvedMatch(entry, route, params, loaderData, validatedSearch));
+    }
+    return {
+        head: mergeHeads(accumulatedHeads),
+        matches,
+        pathname: normalized,
+        renderSource: 'component',
+        responseHeaders: responseStub.headers,
+        search: location.search,
+    };
+}
+export function serializeRouteState(state) {
+    return {
+        head: state.head,
+        matches: state.matches.map((match) => ({
+            fullPath: match.fullPath,
+            hydration: match.hydration,
+            id: match.id,
+            loaderData: match.loaderData,
+            params: match.params,
+            search: match.search,
+        })),
+        notFound: state.notFound,
+        pathname: state.pathname,
+        routeError: state.routeError,
+        search: state.search,
+    };
+}
+export async function materializeBootstrapPayload(payload) {
+    return {
+        head: payload.head,
+        matches: await materializeMatches(payload.matches),
+        notFound: payload.notFound,
+        pathname: payload.pathname,
+        renderSource: 'component',
+        routeError: payload.routeError,
+        search: payload.search,
+    };
+}
+export async function materializePayloadEnvelope(payload) {
+    return {
+        head: payload.head,
+        matches: await materializeMatches(payload.matches),
+        notFound: payload.notFound,
+        pathname: payload.pathname,
+        payloadHtml: payload.html,
+        renderSource: 'payload',
+        routeError: payload.routeError,
+        search: payload.search,
+    };
+}
+export function getResolvedRouteStatus(state) {
+    if (state.routeError) {
+        return state.routeError.error.status;
+    }
+    if (state.notFound) {
+        return 404;
+    }
+    const leaf = state.matches[state.matches.length - 1];
+    return leaf?.id === '/$' || leaf?.id.endsWith('/$') ? 404 : 200;
+}
+export function isNotFoundState(state) {
+    if (state.notFound) {
+        return true;
+    }
+    const leaf = state.matches[state.matches.length - 1];
+    return leaf?.id === '/$' || leaf?.id.endsWith('/$');
+}

package/dist/runtime/runtime.d.ts

@@ -0,0 +1,40 @@
+import type { Accessor, JSX } from 'solid-js';
+import type { BootstrapPayload, NavigateToOptions, ResolvedRouteState, RouteErrorData, RouterCreateOptions, RouteSearch, SetSearchFunction } from './types';
+type NavigationOptions = {
+    force?: boolean;
+    replace?: boolean;
+    scroll?: boolean;
+};
+export interface VorzelaRouter {
+    context: Record<string, unknown>;
+    init: () => Promise<void>;
+    navigate: (to: string | NavigateToOptions, options?: NavigationOptions) => Promise<void>;
+    prefetch: (to: string | NavigateToOptions) => Promise<void>;
+    setSearch: SetSearchFunction;
+    state: Accessor<ResolvedRouteState>;
+}
+export declare function createRouter(initialPayload: BootstrapPayload, options?: RouterCreateOptions): VorzelaRouter;
+type RenderResolvedMatchesOptions = {
+    onRenderError?: (error: RouteErrorData) => void;
+    retry?: () => void;
+    wrapHydrationBoundaries?: boolean;
+};
+export declare function renderResolvedMatches(state: Pick<ResolvedRouteState, 'matches' | 'notFound' | 'payloadHtml' | 'renderSource' | 'routeError'>, options?: RenderResolvedMatchesOptions): JSX.Element;
+export declare function RouterProvider(props: {
+    router: VorzelaRouter;
+}): JSX.Element;
+export declare function Outlet(): number | boolean | Node | JSX.ArrayElement | (string & {}) | null;
+export declare function useRouter(): VorzelaRouter;
+export declare function useNavigate(): (to: string | NavigateToOptions, options?: NavigationOptions) => Promise<void>;
+export declare function useParams<T extends Record<string, string> = Record<string, string>>(): T;
+export declare function useLoaderData<T = unknown>(): T;
+export declare function useSearch<T extends RouteSearch = RouteSearch>(): () => T;
+export declare function useSetSearch<T extends RouteSearch = RouteSearch>(): SetSearchFunction<T>;
+export declare function readBootstrapPayload(): BootstrapPayload;
+type LinkProps = JSX.AnchorHTMLAttributes<HTMLAnchorElement> & {
+    replace?: boolean;
+    to: string;
+};
+export declare function Link(props: LinkProps): JSX.Element;
+export {};
+//# sourceMappingURL=runtime.d.ts.map

package/dist/runtime/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../src/runtime/runtime.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAa,GAAG,EAAE,MAAM,UAAU,CAAA;AAYxD,OAAO,KAAK,EACV,gBAAgB,EAChB,iBAAiB,EAEjB,kBAAkB,EAIlB,cAAc,EAId,mBAAmB,EAEnB,WAAW,EACX,iBAAiB,EAElB,MAAM,SAAS,CAAA;AAEhB,KAAK,iBAAiB,GAAG;IACvB,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB,CAAA;AAaD,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAChC,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IACzB,QAAQ,EAAE,CAAC,EAAE,EAAE,MAAM,GAAG,iBAAiB,EAAE,OAAO,CAAC,EAAE,iBAAiB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IACxF,QAAQ,EAAE,CAAC,EAAE,EAAE,MAAM,GAAG,iBAAiB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IAC3D,SAAS,EAAE,iBAAiB,CAAA;IAC5B,KAAK,EAAE,QAAQ,CAAC,kBAAkB,CAAC,CAAA;CACpC;AAsUD,wBAAgB,YAAY,CAC1B,cAAc,EAAE,gBAAgB,EAChC,OAAO,GAAE,mBAAwB,GAChC,aAAa,CA6Wf;AAMD,KAAK,4BAA4B,GAAG;IAClC,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,CAAA;IAC/C,KAAK,CAAC,EAAE,MAAM,IAAI,CAAA;IAClB,uBAAuB,CAAC,EAAE,OAAO,CAAA;CAClC,CAAA;AAED,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,IAAI,CAAC,kBAAkB,EAAE,SAAS,GAAG,UAAU,GAAG,aAAa,GAAG,cAAc,GAAG,YAAY,CAAC,EACvG,OAAO,GAAE,4BAAiC,GACzC,GAAG,CAAC,OAAO,CA8Gb;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE;IAAE,MAAM,EAAE,aAAa,CAAA;CAAE,eA2D9D;AAED,wBAAgB,MAAM,sEAErB;AAED,wBAAgB,SAAS,kBAQxB;AAED,wBAAgB,WAAW,KAGjB,IAAI,MAAM,GAAG,iBAAiB,EAAE,UAAU,iBAAiB,mBAOpE;AAED,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAO1D,CAAC,CACzB;AAED,wBAAgB,aAAa,CAAC,CAAC,GAAG,OAAO,KAOZ,CAAC,CAC7B;AAED,wBAAgB,SAAS,CAAC,CAAC,SAAS,WAAW,GAAG,WAAW,aAgB5D;AAED,wBAAgB,YAAY,CAAC,CAAC,SAAS,WAAW,GAAG,WAAW,KAAK,iBAAiB,CAAC,CAAC,CAAC,CAuBxF;AAED,wBAAgB,oBAAoB,IAAI,gBAAgB,CAQvD;AAED,KAAK,SAAS,GAAG,GAAG,CAAC,oBAAoB,CAAC,iBAAiB,CAAC,GAAG;IAC7D,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,EAAE,EAAE,MAAM,CAAA;CACX,CAAA;AAED,wBAAgB,IAAI,CAAC,KAAK,EAAE,SAAS,eAqFpC"}