@plumile/router 0.1.51 → 0.1.53

package/lib/tools/index.js

@@ -0,0 +1,13 @@
+export function onlyDefinedStyles(styles) {
+    const filteredStyles = [];
+    for (const style of styles) {
+        if (style != null) {
+            filteredStyles.push(style);
+        }
+    }
+    return filteredStyles;
+}
+export function cx(styles) {
+    return onlyDefinedStyles(styles).join(' ');
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/tools/query.d.ts

@@ -0,0 +1,2 @@
+export declare function parseRawQuery(search: string | undefined): Record<string, string | string[]>;
+//# sourceMappingURL=query.d.ts.map

package/lib/tools/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../src/tools/query.ts"],"names":[],"mappings":"AAYA,wBAAgB,aAAa,CAC3B,MAAM,EAAE,MAAM,GAAG,SAAS,GACzB,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,CAmCnC"}

package/lib/tools/query.js

@@ -0,0 +1,43 @@
+const __rawQueryCache = new Map();
+const __emptyRaw = Object.freeze({});
+export function parseRawQuery(search) {
+    if (search == null || search === '' || search === '?')
+        return __emptyRaw;
+    let raw = search;
+    if (raw.startsWith('?'))
+        raw = raw.slice(1);
+    const params = new URLSearchParams(raw);
+    const agg = {};
+    params.forEach((value, key) => {
+        const existing = agg[key];
+        if (existing == null) {
+            agg[key] = value;
+        }
+        else if (Array.isArray(existing)) {
+            existing.push(value);
+        }
+        else {
+            agg[key] = [existing, value];
+        }
+    });
+    const parts = [];
+    const keys = Object.keys(agg).sort();
+    for (const k of keys) {
+        const v = agg[k];
+        if (Array.isArray(v)) {
+            for (const vv of v)
+                parts.push(`${k}=${vv}`);
+        }
+        else {
+            parts.push(`${k}=${v}`);
+        }
+    }
+    const key = parts.join('&');
+    const cached = __rawQueryCache.get(key);
+    if (cached != null) {
+        return cached;
+    }
+    __rawQueryCache.set(key, agg);
+    return agg;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/tools.d.ts

@@ -0,0 +1,15 @@
+import type { ParamData } from 'path-to-regexp';
+import { type FilterSchema, type PrepareResult, type PreparedMatch, type Redirect, type ResolvedPreparedMatch, type Route, type RouteNode, type RouterMatchedRoute } from './types.js';
+import type { RouterPrepareEvent, RouterNavigationSource, RouterLocationSnapshot } from './instrumentation/Instrumentation.js';
+import type { FlatRoute } from './builder.js';
+type PrepareInstrumentation = {
+    emit: (event: RouterPrepareEvent) => void;
+    source: RouterNavigationSource;
+    location: RouterLocationSnapshot;
+};
+export declare function getMatchedRoute<TParams extends ParamData>(routes: FlatRoute<TParams>[], location: Location): RouterMatchedRoute<TParams> | null;
+export declare function prepareMatch<TParams extends ParamData, TContext = unknown>(match: RouterMatchedRoute<TParams> | null, query?: Record<string, unknown>, instrumentation?: PrepareInstrumentation, context?: TContext): PreparedMatch<TParams, TContext>;
+export declare function prepareMatchAsync<TParams extends ParamData, TContext = unknown>(match: RouterMatchedRoute<TParams> | null, query?: Record<string, unknown>, instrumentation?: PrepareInstrumentation, context?: TContext): Promise<ResolvedPreparedMatch<TParams, TContext>>;
+export declare function r<TContext = unknown, TPrepared extends PrepareResult = PrepareResult, TVariables extends ParamData = ParamData, TQuery extends Record<string, unknown> = Record<string, unknown>, TChildren extends readonly (RouteNode | Redirect)[] | undefined = readonly (RouteNode | Redirect)[] | undefined>(route: Route<TContext, TPrepared, TVariables, TQuery, FilterSchema | undefined, TChildren>): Route<TContext, TPrepared, TVariables, TQuery, FilterSchema | undefined, TChildren>;
+export {};
+//# sourceMappingURL=tools.d.ts.map

package/lib/tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEhD,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,aAAa,EAGlB,KAAK,QAAQ,EACb,KAAK,qBAAqB,EAE1B,KAAK,KAAK,EACV,KAAK,SAAS,EACd,KAAK,kBAAkB,EACxB,MAAM,YAAY,CAAC;AAEpB,OAAO,KAAK,EACV,kBAAkB,EAClB,sBAAsB,EACtB,sBAAsB,EACvB,MAAM,sCAAsC,CAAC;AAE9C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAG9C,KAAK,sBAAsB,GAAG;IAC5B,IAAI,EAAE,CAAC,KAAK,EAAE,kBAAkB,KAAK,IAAI,CAAC;IAC1C,MAAM,EAAE,sBAAsB,CAAC;IAC/B,QAAQ,EAAE,sBAAsB,CAAC;CAClC,CAAC;AASF,wBAAgB,eAAe,CAAC,OAAO,SAAS,SAAS,EACvD,MAAM,EAAE,SAAS,CAAC,OAAO,CAAC,EAAE,EAC5B,QAAQ,EAAE,QAAQ,GACjB,kBAAkB,CAAC,OAAO,CAAC,GAAG,IAAI,CAepC;AAgCD,wBAAgB,YAAY,CAAC,OAAO,SAAS,SAAS,EAAE,QAAQ,GAAG,OAAO,EACxE,KAAK,EAAE,kBAAkB,CAAC,OAAO,CAAC,GAAG,IAAI,EACzC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,eAAe,CAAC,EAAE,sBAAsB,EACxC,OAAO,CAAC,EAAE,QAAQ,GACjB,aAAa,CAAC,OAAO,EAAE,QAAQ,CAAC,CA2IlC;AAWD,wBAAsB,iBAAiB,CACrC,OAAO,SAAS,SAAS,EACzB,QAAQ,GAAG,OAAO,EAElB,KAAK,EAAE,kBAAkB,CAAC,OAAO,CAAC,GAAG,IAAI,EACzC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,eAAe,CAAC,EAAE,sBAAsB,EACxC,OAAO,CAAC,EAAE,QAAQ,GACjB,OAAO,CAAC,qBAAqB,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC,CA6BnD;AAOD,wBAAgB,CAAC,CACf,QAAQ,GAAG,OAAO,EAClB,SAAS,SAAS,aAAa,GAAG,aAAa,EAC/C,UAAU,SAAS,SAAS,GAAG,SAAS,EACxC,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChE,SAAS,SAAS,SAAS,CAAC,SAAS,GAAG,QAAQ,CAAC,EAAE,GAAG,SAAS,GAC3D,SAAS,CAAC,SAAS,GAAG,QAAQ,CAAC,EAAE,GACjC,SAAS,EAEb,KAAK,EAAE,KAAK,CACV,QAAQ,EACR,SAAS,EACT,UAAU,EACV,MAAM,EACN,YAAY,GAAG,SAAS,EACxB,SAAS,CACV,GACA,KAAK,CACN,QAAQ,EACR,SAAS,EACT,UAAU,EACV,MAAM,EACN,YAAY,GAAG,SAAS,EACxB,SAAS,CACV,CAEA"}

package/lib/tools.js

@@ -0,0 +1,179 @@
+import { createPreparedValueResource } from './prepareResource.js';
+export function getMatchedRoute(routes, location) {
+    for (const route of routes) {
+        const match = route.matchFunction(location.pathname);
+        if (match !== false) {
+            const { path, params } = match;
+            return {
+                match,
+                route,
+                path,
+                params,
+            };
+        }
+    }
+    return null;
+}
+function buildHighlightId(routePath, index, moduleId) {
+    const parts = [];
+    if (typeof moduleId === 'string' && moduleId.trim() !== '') {
+        parts.push(`module:${moduleId}`);
+    }
+    if (typeof routePath === 'string' && routePath.trim() !== '') {
+        parts.push(`path:${routePath}`);
+    }
+    if (parts.length === 0) {
+        parts.push('route');
+    }
+    parts.push(`index:${index}`);
+    return parts.join('|');
+}
+export function prepareMatch(match, query, instrumentation, context) {
+    if (match == null) {
+        return {
+            match,
+            segments: [],
+            routes: [],
+        };
+    }
+    const matchedRoute = match.route;
+    const segments = match.route.routes.map((route, routeIndex) => {
+        const { path, prepare, querySchema, resourcePage, render } = route;
+        let moduleId;
+        if (resourcePage != null &&
+            typeof resourcePage.getModuleId === 'function') {
+            const resolvedModuleId = resourcePage.getModuleId();
+            if (typeof resolvedModuleId === 'string') {
+                moduleId = resolvedModuleId;
+            }
+        }
+        let prepareStartedAt = 0;
+        if (instrumentation != null) {
+            prepareStartedAt = Date.now();
+            instrumentation.emit({
+                kind: 'prepare-start',
+                source: instrumentation.source,
+                timestamp: prepareStartedAt,
+                location: instrumentation.location,
+                routePath: path,
+                moduleId,
+            });
+        }
+        let preparedResource;
+        if (prepare != null) {
+            preparedResource = createPreparedValueResource(() => {
+                return prepare({
+                    match,
+                    matchedRoute,
+                    context: context,
+                    resourcePage,
+                    variables: { ...match.params },
+                    query: query ?? {},
+                });
+            });
+            const preparedLoad = preparedResource.load();
+            if (instrumentation != null) {
+                preparedLoad
+                    .then(() => {
+                    const finishedAt = Date.now();
+                    instrumentation.emit({
+                        kind: 'prepare-complete',
+                        source: instrumentation.source,
+                        timestamp: finishedAt,
+                        location: instrumentation.location,
+                        routePath: path,
+                        moduleId,
+                        durationMs: finishedAt - prepareStartedAt,
+                        hasPrepared: true,
+                        status: 'resolved',
+                    });
+                })
+                    .catch(() => {
+                    const finishedAt = Date.now();
+                    instrumentation.emit({
+                        kind: 'prepare-complete',
+                        source: instrumentation.source,
+                        timestamp: finishedAt,
+                        location: instrumentation.location,
+                        routePath: path,
+                        moduleId,
+                        durationMs: finishedAt - prepareStartedAt,
+                        hasPrepared: true,
+                        status: 'rejected',
+                    });
+                });
+            }
+            else {
+                preparedLoad.catch(() => {
+                });
+            }
+        }
+        if (instrumentation != null && prepare == null) {
+            const finishedAt = Date.now();
+            instrumentation.emit({
+                kind: 'prepare-complete',
+                source: instrumentation.source,
+                timestamp: finishedAt,
+                location: instrumentation.location,
+                routePath: path,
+                moduleId,
+                durationMs: finishedAt - prepareStartedAt,
+                hasPrepared: false,
+                status: 'resolved',
+            });
+        }
+        if (resourcePage != null && resourcePage.get() == null) {
+            try {
+                Promise.resolve(resourcePage.load()).catch(() => {
+                });
+            }
+            catch {
+            }
+        }
+        return {
+            path,
+            fullPath: path,
+            segmentIndex: routeIndex,
+            preparedResource,
+            redirectTo: matchedRoute.redirectTo ?? null,
+            render,
+            resourcePage,
+            highlightId: buildHighlightId(path, routeIndex, moduleId),
+            querySchema,
+        };
+    });
+    return {
+        match,
+        segments,
+        routes: segments,
+    };
+}
+export async function prepareMatchAsync(match, query, instrumentation, context) {
+    const preparedMatch = prepareMatch(match, query, instrumentation, context);
+    const segments = await Promise.all(preparedMatch.segments.map(async (route) => {
+        let prepared;
+        if (route.preparedResource != null) {
+            prepared = await route.preparedResource.load();
+        }
+        return {
+            path: route.path,
+            fullPath: route.fullPath,
+            segmentIndex: route.segmentIndex,
+            prepared,
+            redirectTo: route.redirectTo,
+            render: route.render,
+            resourcePage: route.resourcePage,
+            highlightId: route.highlightId,
+            querySchema: route.querySchema,
+        };
+    }));
+    return {
+        match: preparedMatch.match,
+        segments,
+        routes: segments,
+    };
+}
+export function r(route) {
+    return route;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tools.js","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"AAuBA,OAAO,EAAE,2BAA2B,EAAE,MAAM,sBAAsB,CAAC;AAenE,MAAM,UAAU,eAAe,CAC7B,MAA4B,EAC5B,QAAkB;IAElB,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,MAAM,KAAK,GAAG,KAAK,CAAC,aAAa,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;QACrD,IAAI,KAAK,KAAK,KAAK,EAAE,CAAC;YACpB,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC;YAC/B,OAAO;gBACL,KAAK;gBACL,KAAK;gBACL,IAAI;gBACJ,MAAM;aACP,CAAC;QACJ,CAAC;IACH,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC;AAKD,SAAS,gBAAgB,CACvB,SAA6B,EAC7B,KAAa,EACb,QAAiB;IAEjB,MAAM,KAAK,GAAa,EAAE,CAAC;IAC3B,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,QAAQ,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC;QAC3D,KAAK,CAAC,IAAI,CAAC,UAAU,QAAQ,EAAE,CAAC,CAAC;IACnC,CAAC;IACD,IAAI,OAAO,SAAS,KAAK,QAAQ,IAAI,SAAS,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC;QAC7D,KAAK,CAAC,IAAI,CAAC,QAAQ,SAAS,EAAE,CAAC,CAAC;IAClC,CAAC;IACD,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACvB,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACtB,CAAC;IACD,KAAK,CAAC,IAAI,CAAC,SAAS,KAAK,EAAE,CAAC,CAAC;IAC7B,OAAO,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AACzB,CAAC;AAUD,MAAM,UAAU,YAAY,CAC1B,KAAyC,EACzC,KAA+B,EAC/B,eAAwC,EACxC,OAAkB;IAMlB,IAAI,KAAK,IAAI,IAAI,EAAE,CAAC;QAClB,OAAO;YACL,KAAK;YACL,QAAQ,EAAE,EAAE;YACZ,MAAM,EAAE,EAAE;SACX,CAAC;IACJ,CAAC;IAED,MAAM,YAAY,GAAG,KAAK,CAAC,KAAK,CAAC;IAEjC,MAAM,QAAQ,GAAqC,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,CACvE,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE;QACpB,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC;QACnE,IAAI,QAA4B,CAAC;QACjC,IACE,YAAY,IAAI,IAAI;YACpB,OAAO,YAAY,CAAC,WAAW,KAAK,UAAU,EAC9C,CAAC;YACD,MAAM,gBAAgB,GAAG,YAAY,CAAC,WAAW,EAAE,CAAC;YACpD,IAAI,OAAO,gBAAgB,KAAK,QAAQ,EAAE,CAAC;gBACzC,QAAQ,GAAG,gBAAgB,CAAC;YAC9B,CAAC;QACH,CAAC;QAED,IAAI,gBAAgB,GAAG,CAAC,CAAC;QACzB,IAAI,eAAe,IAAI,IAAI,EAAE,CAAC;YAC5B,gBAAgB,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;YAC9B,eAAe,CAAC,IAAI,CAAC;gBACnB,IAAI,EAAE,eAAe;gBACrB,MAAM,EAAE,eAAe,CAAC,MAAM;gBAC9B,SAAS,EAAE,gBAAgB;gBAC3B,QAAQ,EAAE,eAAe,CAAC,QAAQ;gBAClC,SAAS,EAAE,IAAI;gBACf,QAAQ;aACT,CAAC,CAAC;QACL,CAAC;QAED,IAAI,gBAAwD,CAAC;QAC7D,IAAI,OAAO,IAAI,IAAI,EAAE,CAAC;YACpB,gBAAgB,GAAG,2BAA2B,CAAC,GAAG,EAAE;gBAClD,OAAO,OAAO,CAAC;oBACb,KAAK;oBACL,YAAY;oBACZ,OAAO,EAAE,OAAmB;oBAC5B,YAAY;oBAEZ,SAAS,EAAE,EAAE,GAAG,KAAK,CAAC,MAAM,EAAE;oBAC9B,KAAK,EAAE,KAAK,IAAI,EAAE;iBACnB,CAAC,CAAC;YACL,CAAC,CAAC,CAAC;YAGH,MAAM,YAAY,GAAG,gBAAgB,CAAC,IAAI,EAAE,CAAC;YAE7C,IAAI,eAAe,IAAI,IAAI,EAAE,CAAC;gBAC5B,YAAY;qBACT,IAAI,CAAC,GAAG,EAAE;oBACT,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;oBAC9B,eAAe,CAAC,IAAI,CAAC;wBACnB,IAAI,EAAE,kBAAkB;wBACxB,MAAM,EAAE,eAAe,CAAC,MAAM;wBAC9B,SAAS,EAAE,UAAU;wBACrB,QAAQ,EAAE,eAAe,CAAC,QAAQ;wBAClC,SAAS,EAAE,IAAI;wBACf,QAAQ;wBACR,UAAU,EAAE,UAAU,GAAG,gBAAgB;wBACzC,WAAW,EAAE,IAAI;wBACjB,MAAM,EAAE,UAAU;qBACnB,CAAC,CAAC;gBACL,CAAC,CAAC;qBACD,KAAK,CAAC,GAAG,EAAE;oBACV,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;oBAC9B,eAAe,CAAC,IAAI,CAAC;wBACnB,IAAI,EAAE,kBAAkB;wBACxB,MAAM,EAAE,eAAe,CAAC,MAAM;wBAC9B,SAAS,EAAE,UAAU;wBACrB,QAAQ,EAAE,eAAe,CAAC,QAAQ;wBAClC,SAAS,EAAE,IAAI;wBACf,QAAQ;wBACR,UAAU,EAAE,UAAU,GAAG,gBAAgB;wBACzC,WAAW,EAAE,IAAI;wBACjB,MAAM,EAAE,UAAU;qBACnB,CAAC,CAAC;gBACL,CAAC,CAAC,CAAC;YACP,CAAC;iBAAM,CAAC;gBACN,YAAY,CAAC,KAAK,CAAC,GAAG,EAAE;gBAExB,CAAC,CAAC,CAAC;YACL,CAAC;QACH,CAAC;QAED,IAAI,eAAe,IAAI,IAAI,IAAI,OAAO,IAAI,IAAI,EAAE,CAAC;YAC/C,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;YAC9B,eAAe,CAAC,IAAI,CAAC;gBACnB,IAAI,EAAE,kBAAkB;gBACxB,MAAM,EAAE,eAAe,CAAC,MAAM;gBAC9B,SAAS,EAAE,UAAU;gBACrB,QAAQ,EAAE,eAAe,CAAC,QAAQ;gBAClC,SAAS,EAAE,IAAI;gBACf,QAAQ;gBACR,UAAU,EAAE,UAAU,GAAG,gBAAgB;gBACzC,WAAW,EAAE,KAAK;gBAClB,MAAM,EAAE,UAAU;aACnB,CAAC,CAAC;QACL,CAAC;QAED,IAAI,YAAY,IAAI,IAAI,IAAI,YAAY,CAAC,GAAG,EAAE,IAAI,IAAI,EAAE,CAAC;YACvD,IAAI,CAAC;gBACH,OAAO,CAAC,OAAO,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE;gBAEhD,CAAC,CAAC,CAAC;YACL,CAAC;YAAC,MAAM,CAAC;YAET,CAAC;QACH,CAAC;QACD,OAAO;YACL,IAAI;YACJ,QAAQ,EAAE,IAAI;YACd,YAAY,EAAE,UAAU;YACxB,gBAAgB;YAChB,UAAU,EAAE,YAAY,CAAC,UAAU,IAAI,IAAI;YAC3C,MAAM;YACN,YAAY;YACZ,WAAW,EAAE,gBAAgB,CAAC,IAAI,EAAE,UAAU,EAAE,QAAQ,CAAC;YACzD,WAAW;SACZ,CAAC;IACJ,CAAC,CACF,CAAC;IAEF,OAAO;QACL,KAAK;QACL,QAAQ;QACR,MAAM,EAAE,QAAQ;KACjB,CAAC;AACJ,CAAC;AAWD,MAAM,CAAC,KAAK,UAAU,iBAAiB,CAIrC,KAAyC,EACzC,KAA+B,EAC/B,eAAwC,EACxC,OAAkB;IAElB,MAAM,aAAa,GAAG,YAAY,CAAC,KAAK,EAAE,KAAK,EAAE,eAAe,EAAE,OAAO,CAAC,CAAC;IAC3E,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,GAAG,CAChC,aAAa,CAAC,QAAQ,CAAC,GAAG,CACxB,KAAK,EAAE,KAAK,EAAmD,EAAE;QAC/D,IAAI,QAAiB,CAAC;QACtB,IAAI,KAAK,CAAC,gBAAgB,IAAI,IAAI,EAAE,CAAC;YACnC,QAAQ,GAAG,MAAM,KAAK,CAAC,gBAAgB,CAAC,IAAI,EAAE,CAAC;QACjD,CAAC;QACD,OAAO;YACL,IAAI,EAAE,KAAK,CAAC,IAAI;YAChB,QAAQ,EAAE,KAAK,CAAC,QAAQ;YACxB,YAAY,EAAE,KAAK,CAAC,YAAY;YAChC,QAAQ;YACR,UAAU,EAAE,KAAK,CAAC,UAAU;YAC5B,MAAM,EAAE,KAAK,CAAC,MAAM;YACpB,YAAY,EAAE,KAAK,CAAC,YAAY;YAChC,WAAW,EAAE,KAAK,CAAC,WAAW;YAC9B,WAAW,EAAE,KAAK,CAAC,WAAW;SAC/B,CAAC;IACJ,CAAC,CACF,CACF,CAAC;IAEF,OAAO;QACL,KAAK,EAAE,aAAa,CAAC,KAAK;QAC1B,QAAQ;QACR,MAAM,EAAE,QAAQ;KACjB,CAAC;AACJ,CAAC;AAOD,MAAM,UAAU,CAAC,CASf,KAOC;IASD,OAAO,KAAK,CAAC;AACf,CAAC","sourcesContent":["import type { ParamData } from 'path-to-regexp';\n\nimport {\n  type FilterSchema,\n  type PrepareResult,\n  type PreparedMatch,\n  type PreparedMatchRoute,\n  type PreparedRouteSegment,\n  type Redirect,\n  type ResolvedPreparedMatch,\n  type ResolvedPreparedRouteSegment,\n  type Route,\n  type RouteNode,\n  type RouterMatchedRoute,\n} from './types.js';\n\nimport type {\n  RouterPrepareEvent,\n  RouterNavigationSource,\n  RouterLocationSnapshot,\n} from './instrumentation/Instrumentation.js';\n\nimport type { FlatRoute } from './builder.js';\nimport { createPreparedValueResource } from './prepareResource.js';\n\ntype PrepareInstrumentation = {\n  emit: (event: RouterPrepareEvent) => void;\n  source: RouterNavigationSource;\n  location: RouterLocationSnapshot;\n};\n\n/**\n * Finds the first flat route matching the provided location.\n *\n * @param routes - Flattened route list to evaluate.\n * @param location - Browser location whose pathname should be matched.\n * @returns Matched route with params or `null` if none match.\n */\nexport function getMatchedRoute<TParams extends ParamData>(\n  routes: FlatRoute<TParams>[],\n  location: Location,\n): RouterMatchedRoute<TParams> | null {\n  for (const route of routes) {\n    const match = route.matchFunction(location.pathname);\n    if (match !== false) {\n      const { path, params } = match;\n      return {\n        match,\n        route,\n        path,\n        params,\n      };\n    }\n  }\n\n  return null;\n}\n\n/**\n * Derives a deterministic identifier that links prepared routes to DOM markers.\n */\nfunction buildHighlightId(\n  routePath: string | undefined,\n  index: number,\n  moduleId?: string,\n): string {\n  const parts: string[] = [];\n  if (typeof moduleId === 'string' && moduleId.trim() !== '') {\n    parts.push(`module:${moduleId}`);\n  }\n  if (typeof routePath === 'string' && routePath.trim() !== '') {\n    parts.push(`path:${routePath}`);\n  }\n  if (parts.length === 0) {\n    parts.push('route');\n  }\n  parts.push(`index:${index}`);\n  return parts.join('|');\n}\n\n/**\n * Prepares a matched route by executing `prepare` callbacks and resolving resource pages.\n *\n * @param match - Matched route descriptor (or `null` when nothing matched).\n * @param query - Optional query object forwarded to prepare functions.\n * @param context - Optional router context forwarded to prepare functions.\n * @returns Prepared hierarchy ready for the renderer.\n */\nexport function prepareMatch<TParams extends ParamData, TContext = unknown>(\n  match: RouterMatchedRoute<TParams> | null,\n  query?: Record<string, unknown>,\n  instrumentation?: PrepareInstrumentation,\n  context?: TContext,\n): PreparedMatch<TParams, TContext> {\n  // NOTE: Runtime retains a generic PreparedResult; type-level narrowing is achieved externally\n  // through the route union and PreparedAccess helpers. We intentionally avoid injecting\n  // generic parameters here to keep runtime lightweight while still enabling compile-time\n  // discrimination in userland via createRouter generics.\n  if (match == null) {\n    return {\n      match,\n      segments: [],\n      routes: [],\n    };\n  }\n\n  const matchedRoute = match.route;\n\n  const segments: PreparedRouteSegment<TContext>[] = match.route.routes.map(\n    (route, routeIndex) => {\n      const { path, prepare, querySchema, resourcePage, render } = route;\n      let moduleId: string | undefined;\n      if (\n        resourcePage != null &&\n        typeof resourcePage.getModuleId === 'function'\n      ) {\n        const resolvedModuleId = resourcePage.getModuleId();\n        if (typeof resolvedModuleId === 'string') {\n          moduleId = resolvedModuleId;\n        }\n      }\n\n      let prepareStartedAt = 0;\n      if (instrumentation != null) {\n        prepareStartedAt = Date.now();\n        instrumentation.emit({\n          kind: 'prepare-start',\n          source: instrumentation.source,\n          timestamp: prepareStartedAt,\n          location: instrumentation.location,\n          routePath: path,\n          moduleId,\n        });\n      }\n\n      let preparedResource: PreparedMatchRoute['preparedResource'];\n      if (prepare != null) {\n        preparedResource = createPreparedValueResource(() => {\n          return prepare({\n            match,\n            matchedRoute,\n            context: context as TContext,\n            resourcePage,\n            // Fix Object.create(null) issue in path-to-regexp\n            variables: { ...match.params },\n            query: query ?? {},\n          });\n        });\n        // Eagerly evaluate prepare so the prepared resource immediately reflects\n        // sync resolution or async pending state for the current route snapshot.\n        const preparedLoad = preparedResource.load();\n\n        if (instrumentation != null) {\n          preparedLoad\n            .then(() => {\n              const finishedAt = Date.now();\n              instrumentation.emit({\n                kind: 'prepare-complete',\n                source: instrumentation.source,\n                timestamp: finishedAt,\n                location: instrumentation.location,\n                routePath: path,\n                moduleId,\n                durationMs: finishedAt - prepareStartedAt,\n                hasPrepared: true,\n                status: 'resolved',\n              });\n            })\n            .catch(() => {\n              const finishedAt = Date.now();\n              instrumentation.emit({\n                kind: 'prepare-complete',\n                source: instrumentation.source,\n                timestamp: finishedAt,\n                location: instrumentation.location,\n                routePath: path,\n                moduleId,\n                durationMs: finishedAt - prepareStartedAt,\n                hasPrepared: true,\n                status: 'rejected',\n              });\n            });\n        } else {\n          preparedLoad.catch(() => {\n            // Intentionally ignored: route rendering/error boundaries own the failure.\n          });\n        }\n      }\n\n      if (instrumentation != null && prepare == null) {\n        const finishedAt = Date.now();\n        instrumentation.emit({\n          kind: 'prepare-complete',\n          source: instrumentation.source,\n          timestamp: finishedAt,\n          location: instrumentation.location,\n          routePath: path,\n          moduleId,\n          durationMs: finishedAt - prepareStartedAt,\n          hasPrepared: false,\n          status: 'resolved',\n        });\n      }\n\n      if (resourcePage != null && resourcePage.get() == null) {\n        try {\n          Promise.resolve(resourcePage.load()).catch(() => {\n            // Intentionally ignored: route rendering/error boundaries own the failure.\n          });\n        } catch {\n          // Intentionally ignored: route rendering/error boundaries own the failure.\n        }\n      }\n      return {\n        path,\n        fullPath: path,\n        segmentIndex: routeIndex,\n        preparedResource,\n        redirectTo: matchedRoute.redirectTo ?? null,\n        render,\n        resourcePage,\n        highlightId: buildHighlightId(path, routeIndex, moduleId),\n        querySchema,\n      };\n    },\n  );\n\n  return {\n    match,\n    segments,\n    routes: segments,\n  };\n}\n\n/**\n * Resolves every async prepare resource for a matched route hierarchy.\n *\n * @param match - Matched route descriptor (or `null` when nothing matched).\n * @param query - Optional query object forwarded to prepare functions.\n * @param instrumentation - Optional instrumentation sink for prepare lifecycle events.\n * @param context - Optional router context forwarded to prepare functions.\n * @returns Prepared hierarchy with concrete prepared values instead of resources.\n */\nexport async function prepareMatchAsync<\n  TParams extends ParamData,\n  TContext = unknown,\n>(\n  match: RouterMatchedRoute<TParams> | null,\n  query?: Record<string, unknown>,\n  instrumentation?: PrepareInstrumentation,\n  context?: TContext,\n): Promise<ResolvedPreparedMatch<TParams, TContext>> {\n  const preparedMatch = prepareMatch(match, query, instrumentation, context);\n  const segments = await Promise.all(\n    preparedMatch.segments.map(\n      async (route): Promise<ResolvedPreparedRouteSegment<TContext>> => {\n        let prepared: unknown;\n        if (route.preparedResource != null) {\n          prepared = await route.preparedResource.load();\n        }\n        return {\n          path: route.path,\n          fullPath: route.fullPath,\n          segmentIndex: route.segmentIndex,\n          prepared,\n          redirectTo: route.redirectTo,\n          render: route.render,\n          resourcePage: route.resourcePage,\n          highlightId: route.highlightId,\n          querySchema: route.querySchema,\n        };\n      },\n    ),\n  );\n\n  return {\n    match: preparedMatch.match,\n    segments,\n    routes: segments,\n  };\n}\n\n/**\n * Route helper that preserves TypeScript inference (including conditional query-schema inference).\n *\n * @param route - Route definition to return unchanged with inferred generics.\n */\nexport function r<\n  TContext = unknown,\n  TPrepared extends PrepareResult = PrepareResult,\n  TVariables extends ParamData = ParamData,\n  TQuery extends Record<string, unknown> = Record<string, unknown>,\n  TChildren extends readonly (RouteNode | Redirect)[] | undefined =\n    | readonly (RouteNode | Redirect)[]\n    | undefined,\n>(\n  route: Route<\n    TContext,\n    TPrepared,\n    TVariables,\n    TQuery,\n    FilterSchema | undefined,\n    TChildren\n  >,\n): Route<\n  TContext,\n  TPrepared,\n  TVariables,\n  TQuery,\n  FilterSchema | undefined,\n  TChildren\n> {\n  return route;\n}\n"]}