@xmachines/play-router 2.2.0 → 4.0.0

package/dist/base-path.js

@@ -1,418 +0,0 @@
-/**
- * The base-path support — it mounts the routes of a machine under a URL prefix.
- *
- * A host application often owns a part of its own URL space, and it wants a machine
- * to own the rest of that space, inside the SAME router. A URL such as
- * `/:machineId/play/dashboard` has two halves: `/:machineId/play` belongs to the
- * host, which resolves `:machineId` in a loader, and `/dashboard` belongs to the
- * `meta.route` tree of the machine.
- *
- * This module is the boundary between those two halves:
- * - {@link resolveBasePath} makes the concrete prefix that the browser URL carries,
- *   from a base-path pattern and its params.
- * - {@link stripBasePath} removes that prefix from an inbound location of the router,
- *   and it reports a location OUTSIDE the prefix as foreign, so that the bridge stays
- *   out of it.
- * - {@link joinBasePath} adds the prefix again to an outbound path of the machine.
- *
- * The prefix lives on the BRIDGE, and not on the `RouteMap`. A route map is static,
- * it is shared, and it holds an LRU cache inside, while a mount point is dynamic. One
- * route map therefore serves every `machineId` without a rebuild.
- *
- * @internal The package exports these primitives for an adapter and for a host, but
- * a consumer normally uses the `basePath` option of a bridge instead.
- */
-import { InvalidBasePathError, MissingBasePathParamError } from "./errors.js";
-/**
- * The base path of a bridge that has no `basePath` option.
- *
- * The object is FROZEN, and both levels of it: {@link resolveBasePath} returns this
- * exact instance for every bridge with no mount, and
- * `RouterBridgeBase.basePathParams` hands its `params` to the caller.
- * `Readonly<Record<string, string>>` is gone at run time, so without the freeze one
- * write in consumer code would leak that key into every other unmounted bridge in
- * the process.
- */
-export const NO_BASE_PATH = Object.freeze({
-    path: "",
-    params: Object.freeze({}),
-});
-/**
- * Normalizes a base path, and it substitutes no `:param` segment of that path.
- *
- * Use this function when you want the form of the pattern, for example to declare
- * the routes of a machine in a route config of a host that substitutes each param
- * itself. {@link resolveBasePath} gives the form that a bridge needs.
- *
- * @param basePath - The prefix, as a pattern or as a concrete path. An absent value,
- *   `""`, and `"/"` all give `""`.
- * @returns The normalized prefix. It starts with `/`, and it carries no trailing `/`.
- * @throws {InvalidBasePathError} For a wildcard segment, for an optional `:param?`
- *   segment, for a `$param` segment, for a query string or a hash fragment, for a URL
- *   scheme, for a dot segment (`.`, `..`, and their percent-encoded forms), and for any
- *   segment that a browser rewrites — one that holds whitespace, a backslash, or a
- *   character that a URL percent-encodes.
- *
- * @example
- * ```typescript
- * normalizeBasePath("/:machineId/play/");  // "/:machineId/play"
- * normalizeBasePath("admin");              // "/admin"
- * normalizeBasePath("/");                  // ""
- * ```
- */
-export function normalizeBasePath(basePath) {
-    if (basePath === undefined || basePath === null || basePath === "")
-        return "";
-    // A base path is a PATHNAME, so refuse a whole URL before the slash collapse hides
-    // the mistake. "https://host/admin" collapses to "/https:/host/admin", whose every
-    // segment passes the segment guards below. The bridge would take that mount, then
-    // strip no real router location under it: the machine would go permanently silent,
-    // exactly as it does for a query or a hash.
-    assertNoScheme(basePath);
-    // Collapse each duplicate slash, add the leading slash, and drop the trailing one.
-    // The result therefore concatenates cleanly with a machine path, which always
-    // starts with "/", and it compares cleanly with a sanitized router location, which
-    // sanitizePathname() has already collapsed.
-    const collapsed = `/${basePath}`.replace(/\/+/g, "/").replace(/\/$/, "");
-    if (collapsed === "")
-        return "";
-    for (const segment of collapsed.slice(1).split("/")) {
-        assertBasePathSegment(segment, basePath);
-    }
-    return collapsed;
-}
-/**
- * Resolves a base path and its params to the concrete prefix that a browser URL
- * carries.
- *
- * A bridge calls this function one time, and again on each `setBasePath()` call. The
- * result is always concrete. {@link stripBasePath} therefore compares a literal
- * prefix, and no URLPattern match runs on the hot path of a navigation.
- *
- * @param basePath - The prefix, as a pattern or as a concrete path.
- * @param params - The values of the `:param` segments of `basePath`.
- * @returns The concrete prefix, and the values of each param for a `play.route` event.
- * @throws {InvalidBasePathError} For a wildcard segment, for an optional `:param?`
- *   segment, for a `$param` segment, for a query string or a hash fragment, for a URL
- *   scheme, for a dot segment (`.`, `..`, and their percent-encoded forms), and for any
- *   segment that a browser rewrites — one that holds whitespace, a backslash, or a
- *   character that a URL percent-encodes.
- * @throws {MissingBasePathParamError} When a `:param` of the prefix has no value.
- *
- * @example
- * ```typescript
- * resolveBasePath("/:machineId/play", { machineId: "abc123" });
- * // → { path: "/abc123/play", params: { machineId: "abc123" } }
- *
- * resolveBasePath("/admin");
- * // → { path: "/admin", params: {} }
- * ```
- */
-export function resolveBasePath(basePath, params) {
-    const normalized = normalizeBasePath(basePath);
-    if (normalized === "")
-        return NO_BASE_PATH;
-    if (!normalized.includes(":")) {
-        return Object.freeze({
-            path: normalized,
-            params: Object.freeze({}),
-        });
-    }
-    // A null prototype, for both directions of the lookup. A plain `{}` accumulator
-    // turns `resolvedParams["__proto__"] = value` into a write of the PROTOTYPE, so a
-    // param of that name would vanish from the result.
-    const resolvedParams = Object.create(null);
-    const segments = normalized
-        .slice(1)
-        .split("/")
-        .map((segment) => {
-        if (!segment.startsWith(":"))
-            return segment;
-        const name = segment.slice(1);
-        // `Object.hasOwn`, and not a bare read: `params[name]` walks the prototype
-        // chain, so ":constructor" with no value of its own found
-        // `Object.prototype.constructor` and resolved the prefix to the source text of
-        // a function. `stripBasePath` then read EVERY location as foreign, and the
-        // machine went silent for ever instead of failing loudly here.
-        const value = params !== undefined && Object.hasOwn(params, name)
-            ? params[name] // nosemgrep: gitlab.eslint.detect-object-injection
-            : undefined;
-        if (value === undefined || value === null || value === "") {
-            throw new MissingBasePathParamError(name, basePath ?? "");
-        }
-        const text = String(value);
-        const encoded = encodeBasePathValue(text);
-        // The guards of `assertBasePathSegment` run on the PATTERN, before this
-        // substitution, so they see ":id" and never the value that replaces it. A value
-        // of "." or ".." therefore passed every one of them and resolved away in the
-        // browser: "/m/../play" comes back as "/play", `stripBasePath` reads every
-        // location as foreign, and the machine goes permanently silent with no error —
-        // the exact failure the dot-segment guard exists to prevent. Test the RESOLVED
-        // segment here.
-        if (!isStableSegment(encoded)) {
-            throw new InvalidBasePathError(basePath ?? "", `the value "${text}" of ":${name}" resolves to the segment "${encoded}", which a browser rewrites, so the prefix that comes back is not the prefix that went out.`);
-        }
-        resolvedParams[name] = text; // nosemgrep: gitlab.eslint.detect-object-injection
-        return encoded;
-    });
-    // FROZEN, both levels, for the same reason NO_BASE_PATH is: `RouterBridgeBase`
-    // returns `this.mount.params` BY REFERENCE from its accessor, and
-    // `Readonly<Record<string, string>>` is gone at run time. One write in consumer code
-    // would change what the bridge reports for the rest of its life, while `basePath`
-    // still holds the real prefix — the staleness the accessor promises cannot happen.
-    // Spread, and not the null-prototype record itself: a spread creates OWN properties,
-    // so a param named "__proto__" stays a key AND the value keeps a normal prototype.
-    // Handing the bare record out made `bridge.basePathParams.hasOwnProperty(…)` throw,
-    // on a value the docs describe as a `Readonly<Record<string, string>>`.
-    return Object.freeze({
-        path: `/${segments.join("/")}`,
-        params: Object.freeze({ ...resolvedParams }),
-    });
-}
-/**
- * Removes the base path from an inbound location of the router.
- *
- * The return value separates the two cases that make a shared router work:
- * - A string is the MACHINE half of the location, for example `"/dashboard"` of
- *   `"/abc123/play/dashboard"`. The bridge matches it against the route map.
- * - `null` means that the location is FOREIGN: it lies outside the mount, so it
- *   belongs to the host. The bridge sends no `play.route` event, AND it runs no
- *   corrective navigation. A correction here would drag the user off a page of the
- *   host.
- *
- * The match is exact, and it respects each segment boundary. `"/abc/playground"` is
- * therefore foreign to the mount `"/abc/play"`.
- *
- * @param pathname - A sanitized pathname of the router, with no query and no duplicate slash.
- * @param basePath - The concrete prefix of {@link resolveBasePath}. `""` removes nothing.
- * @returns The machine half of the path, or `null` when the location is foreign.
- *
- * @example
- * ```typescript
- * stripBasePath("/abc123/play/dashboard", "/abc123/play");  // "/dashboard"
- * stripBasePath("/abc123/play", "/abc123/play");            // "/"
- * stripBasePath("/settings", "/abc123/play");               // null — the host owns it
- * ```
- */
-export function stripBasePath(pathname, basePath) {
-    if (basePath === "")
-        return pathname;
-    if (pathname === basePath)
-        return "/";
-    if (pathname.startsWith(`${basePath}/`))
-        return pathname.slice(basePath.length);
-    return null;
-}
-/**
- * Adds the base path to an outbound path of the machine.
- *
- * The function joins the PATHNAME only. A query string and a hash fragment of the
- * path of the machine stay at the end, because the prefix belongs in front of the
- * path.
- *
- * @param basePath - The concrete prefix of {@link resolveBasePath}. `""` adds nothing.
- * @param path - The path of the machine, for example `"/dashboard"` or `"/dates?trip=one-way"`.
- * @returns The location for the router of the host.
- *
- * @example
- * ```typescript
- * joinBasePath("/abc123/play", "/dashboard");         // "/abc123/play/dashboard"
- * joinBasePath("/abc123/play", "/");                  // "/abc123/play"
- * joinBasePath("/abc123/play", "/x?tab=a");           // "/abc123/play/x?tab=a"
- * joinBasePath("", "/dashboard");                     // "/dashboard"
- * ```
- */
-export function joinBasePath(basePath, path) {
-    if (basePath === "")
-        return path;
-    const mark = firstMarkIndex(path);
-    const pathname = mark === -1 ? path : path.slice(0, mark);
-    const suffix = mark === -1 ? "" : path.slice(mark);
-    // The root of the machine IS the mount point: "/" must not append a trailing slash,
-    // because the router callback reports "/abc123/play" and a mismatch there would
-    // defeat the echo suppression of the bridge.
-    const joined = pathname === "" || pathname === "/"
-        ? basePath
-        : `${basePath}${pathname.startsWith("/") ? "" : "/"}${pathname}`;
-    return `${joined}${suffix}`;
-}
-/**
- * Gives the index of the first query mark or fragment mark of a path, or `-1`.
- *
- * The names say `At`, because both values are an INDEX. A name such as `hash` reads
- * as a digest to a reader and to a scanner both: `gitlab.eslint.detect-possible-timing-attacks`
- * fires on a `===` test against an identifier of that name, and it cannot see that
- * the operands here are two numbers.
- *
- * @internal `RouterBridgeBase` splits a location on the same boundary, to read the
- *   pathname half of an actor route. One function, so the two sides cannot disagree
- *   about where a pathname ends.
- */
-export function firstMarkIndex(path) {
-    const queryAt = path.indexOf("?");
-    const fragmentAt = path.indexOf("#");
-    if (queryAt === -1)
-        return fragmentAt;
-    if (fragmentAt === -1)
-        return queryAt;
-    return Math.min(queryAt, fragmentAt);
-}
-/**
- * Refuses each segment of a base path that resolves to ONE concrete prefix never.
- *
- * A bridge writes a real browser URL from its prefix. A wildcard and an optional
- * segment each describe a SET of prefixes, so neither of them holds a value to write,
- * and a silent pass would put a literal `*` or `:section?` into the address bar.
- */
-function assertBasePathSegment(segment, basePath) {
-    if (segment.includes("*")) {
-        throw new InvalidBasePathError(basePath, 'a wildcard segment cannot resolve to one concrete prefix. Drop the splat segment: mount on the prefix itself, for example "/:machineId/play" for the route "/$machineId/play/$".');
-    }
-    if (segment.startsWith("$")) {
-        throw new InvalidBasePathError(basePath, `"${segment}" looks like a route param of TanStack Router. A base path declares a param as ":${segment.slice(1)}", and its value goes in basePathParams.`);
-    }
-    if (segment.startsWith(":") && segment.endsWith("?")) {
-        throw new InvalidBasePathError(basePath, `the optional segment "${segment}" cannot resolve to one concrete prefix. Give a required ":${segment.slice(1, -1)}" param, or mount on the shorter prefix.`);
-    }
-    if (segment === ":") {
-        throw new InvalidBasePathError(basePath, "a param segment needs a name.");
-    }
-    // A browser resolves "." and ".." out of a location, so the prefix that
-    // `navigateRouter` writes is not the prefix that comes back: "/../admin/about"
-    // becomes "/admin/about", which no longer starts with the mount. Every later location
-    // would read as foreign and the machine would go permanently silent.
-    //
-    // The PERCENT-ENCODED forms resolve away exactly the same. The WHATWG URL standard
-    // reads "%2e" as a single-dot segment and ".%2e", "%2e." and "%2e%2e" as double-dot
-    // segments, each test case-insensitive, so "/a/%2e%2e/admin" also comes back as
-    // "/admin". A guard on the two literal forms alone let that mount through.
-    if (isDotSegment(segment)) {
-        throw new InvalidBasePathError(basePath, `the segment "${segment}" resolves away in a browser, so the prefix that comes back is not the prefix that went out. Give the path that it resolves to.`);
-    }
-    // A browser percent-encodes a space, a tab and a newline of a pathname, so the prefix
-    // that comes back is not the prefix that went out — the same failure as a dot segment,
-    // and the same silence. `assertNoScheme` also reads the RAW value, and a leading space
-    // hid a whole URL from it: " https://host/admin" collapsed to "/ https:/host/admin".
-    if (/\s/.test(segment)) {
-        throw new InvalidBasePathError(basePath, `the segment "${segment}" holds whitespace, which a browser percent-encodes, so the prefix that comes back is not the prefix that went out. Give the path with no whitespace in it.`);
-    }
-    // A base path is a PATHNAME. A query or a hash in it would survive normalization,
-    // then never match a router location — `sanitizePathname` has already removed both
-    // by the time `stripBasePath` compares — so every location would read as foreign
-    // and the machine would go permanently silent. Refuse it here instead.
-    if (segment.includes("?") || segment.includes("#")) {
-        throw new InvalidBasePathError(basePath, "a base path is a pathname only: it can carry no query string and no hash fragment. Put a query on the machine's own route instead.");
-    }
-    // The general form of the three guards above, and the one that catches the rest. A
-    // browser reads a "\" as a "/", so "/adm\in" arrives as two segments and "/a\..\x"
-    // arrives as "/x"; it percent-encodes a non-ASCII character and the characters '"',
-    // '<', '>', '{', '}', '^' and '`', so "/café" arrives as "/caf%C3%A9". Each one gives
-    // the same silence as a dot segment: no location matches the mount, and no error says
-    // so. The guards above stay, because each one names the mistake it found.
-    if (!isStableSegment(segment)) {
-        throw new InvalidBasePathError(basePath, `a browser rewrites the segment "${segment}", so the prefix that comes back is not the prefix that went out. Give the segment in the form that a URL carries, for example "caf%C3%A9" for "café".`);
-    }
-}
-/** The origin of the probe of {@link isStableSegment}. It reaches no network. */
-const PROBE_ORIGIN = "http://probe.invalid";
-/**
- * Tells you whether a browser writes a path segment back exactly as it went out.
- *
- * The WHATWG URL parser rewrites a segment in several ways: it resolves "." and ".."
- * away, it reads a "\" as a "/", and it percent-encodes whitespace, a non-ASCII
- * character, and the characters '"', '<', '>', '{', '}', '^' and '`'. Every one of them
- * gives one failure: the prefix that `navigateRouter` writes is not the prefix that
- * comes back, so `stripBasePath` reads every location as foreign and the machine goes
- * permanently silent, with no error raised.
- *
- * The function asks the URL parser, and it lists no character, because that list
- * belongs to the standard and not to this file.
- */
-function isStableSegment(segment) {
-    try {
-        return new URL(`/${segment}`, PROBE_ORIGIN).pathname === `/${segment}`;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Tells you whether a segment is a single-dot or a double-dot path segment.
- *
- * The WHATWG URL standard names six forms, and a browser resolves every one of them out
- * of a location: "." and "%2e" for the single dot, and "..", ".%2e", "%2e." and "%2e%2e"
- * for the double dot. Each percent test is case-insensitive.
- */
-function isDotSegment(segment) {
-    const decoded = segment.toLowerCase().replaceAll("%2e", ".");
-    return decoded === "." || decoded === "..";
-}
-/**
- * Refuses a base path that carries a URL scheme.
- *
- * The test runs on the RAW value, because the slash collapse of
- * {@link normalizeBasePath} turns the form into a path that looks legal. It also runs
- * on the TRIMMED value, because a browser drops the leading whitespace of a URL: a
- * scheme behind a space is still a scheme. And it runs at every segment boundary,
- * because a scheme that a caller joined behind a prefix of its own is still a scheme.
- *
- * A protocol-relative `//host/path` is NOT refused: it is indistinguishable from a
- * sloppy `//a//b`, which the collapse deliberately forgives.
- *
- * @throws {InvalidBasePathError} For `scheme://host/path`.
- */
-function assertNoScheme(basePath) {
-    // RFC 3986: a scheme starts with a letter, then holds letters, digits, "+", "-"
-    // and ".". A leading "//" with no scheme is the protocol-relative form.
-    // The test runs at EVERY segment boundary, and not at the start alone. A caller that
-    // joins a prefix onto a base writes "/https://app.example.com/admin", and also
-    // "/tenant/https://app.example.com/admin": the collapse then makes
-    // "/tenant/https:/app.example.com/admin", whose every segment is legal, so the bridge
-    // mounts where no real location starts and the machine goes permanently silent. A
-    // guard that stripped the LEADING slashes alone caught the first form and missed the
-    // second.
-    if (/(?:^|\/)[a-zA-Z][a-zA-Z\d+\-.]*:\/\//.test(basePath.trim())) {
-        throw new InvalidBasePathError(basePath, 'a base path is a pathname only: it can carry no scheme and no host. Give the path part alone, for example "/admin" for "https://app.example.com/admin".');
-    }
-}
-/**
- * Escapes the value of a base-path param for a URL segment.
- *
- * `encodeURIComponent` leaves a `*` alone, and that is correct here: a `*` is a legal
- * path character, and a browser reports it literally. An escape to `%2A` resolved a
- * mount that no real location matches, so `stripBasePath` read every location as
- * foreign and the machine went permanently silent, with no error raised.
- *
- * The `*` of "a pattern of no navigation" never reaches this value.
- * `resolveNavigationPath` tests the MACHINE half of the route, and `joinBasePath` adds
- * the prefix after that test — see the one `navigateRouter` call in
- * `pushResolvedRoute`.
- */
-function encodeBasePathValue(value) {
-    // `encodeURIComponent` encodes for a QUERY component, so it escapes eight characters
-    // that RFC 3986 lets a path segment hold raw: the sub-delims "$&+,;=" and ":" and
-    // "@". Every router reports those raw in a pathname, so an escape resolves a mount
-    // that no real location matches — `stripBasePath` reads every location as foreign and
-    // the machine goes permanently silent, with no error raised.
-    //
-    // Escape for a segment instead: put those characters back, and keep the escape of
-    // everything that would change the SHAPE of the path — "/", "?", "#" and "%" among
-    // them — because a value must forge no path and no query.
-    return encodeURIComponent(value).replace(/%(?:24|26|2B|2C|3A|3B|3D|40)/g, (escaped) => PATH_SEGMENT_SAFE.get(escaped) ?? escaped);
-}
-/**
- * The escapes that {@link encodeBasePathValue} undoes: the characters a path segment
- * holds raw, which `encodeURIComponent` escapes because it encodes for a query.
- */
-/** A Map, and not an object: a dynamic key reaches no prototype through one. */
-const PATH_SEGMENT_SAFE = new Map([
-    ["%24", "$"],
-    ["%26", "&"],
-    ["%2B", "+"],
-    ["%2C", ","],
-    ["%3A", ":"],
-    ["%3B", ";"],
-    ["%3D", "="],
-    ["%40", "@"],
-]);
-//# sourceMappingURL=base-path.js.map

package/dist/base-path.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"base-path.js","sourceRoot":"","sources":["../src/base-path.ts"],"names":[],"mappings":"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"}

package/dist/create-route-map.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"create-route-map.d.ts","sourceRoot":"","sources":["../src/create-route-map.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,QAAQ,CAAC;AAG9C,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAE/C;;GAEG;AACH,MAAM,WAAW,eAAe;IAC/B;;;;;;;;;;OAUG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,eAAe,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,QAAQ,CAU5F"}

package/dist/create-route-map.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"create-route-map.js","sourceRoot":"","sources":["../src/create-route-map.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAoB/C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,UAAU,cAAc,CAAC,OAAwB,EAAE,OAAyB;IACjF,MAAM,SAAS,GAAG,oBAAoB,CAAC,OAAO,CAAC,CAAC;IAChD,MAAM,MAAM,GAAG,iBAAiB,CAAC,SAAS,CAAC,CAAC;IAC5C,OAAO,IAAI,QAAQ,CAClB,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;QACrB,OAAO,EAAE,IAAI,CAAC,OAAO;QACrB,IAAI,EAAE,IAAI,CAAC,QAAQ;KACnB,CAAC,CAAC,EACH,OAAO,CACP,CAAC;AACH,CAAC"}

package/dist/extract-routes.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"extract-routes.d.ts","sourceRoot":"","sources":["../src/extract-routes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,QAAQ,CAAC;AAE9C,OAAO,KAAK,EAAE,SAAS,EAA6C,MAAM,YAAY,CAAC;AA6EvF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,oBAAoB,GAAI,SAAS,eAAe,KAAG,SAoB/D,CAAC"}

package/dist/extract-routes.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"extract-routes.js","sourceRoot":"","sources":["../src/extract-routes.ts"],"names":[],"mappings":"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"}

package/dist/framework-params.d.ts

@@ -1,144 +0,0 @@
-/**
- * The params of a framework router, reconciled with the pattern of the machine.
- *
- * A framework that parses the params itself — Vue Router and SolidJS Router both do —
- * lets a bridge keep that parse instead of running URLPattern again. The decision that
- * makes it safe is the same in each of them, and the source of the params is the one
- * thing that differs, so the decision lives here and each bridge supplies its source.
- *
- * @see [Multi-router integration](../../docs/examples/multi-router-integration.md)
- */
-/**
- * Reads the names of every `:param` of a route pattern of the route map.
- *
- * @param pattern - A route pattern, for example `/profile/:userId`.
- * @returns The names, in the order that the pattern declares them. A fresh array, because
- *   `readPatternParams` caches the one it holds.
- */
-export declare function getPatternParamNames(pattern: string): string[];
-/**
- * The names of every param the pattern REQUIRES, so `:name?` is left out.
- *
- * An optional segment that did not match has no value, and a framework reports none.
- * That is a complete answer and not a partial one, so a MIXED pattern such as
- * `/profile/:userId/:tab?` keeps the parse of the framework when only `:tab` is absent.
- * A caller that counted that absence as a gap would fall back to the URLPattern
- * extraction, which THROWS on a runtime with no URLPattern — for a route the framework
- * had already answered.
- *
- * A pattern whose params are ALL optional reports nothing at all, which reads the same
- * as "the framework matched another route", so {@link pickOwnParams} falls back for it.
- * {@link resolveFrameworkParams} settles that case from the PATH instead, and it needs
- * no URLPattern to do it.
- *
- * @param pattern - A route pattern, for example `/profile/:userId/:tab?`.
- * @returns The required names, in the order that the pattern declares them. A fresh
- *   array, because `readPatternParams` caches the one it holds.
- */
-export declare function getRequiredPatternParamNames(pattern: string): string[];
-/**
- * Keeps the entries of `params` whose name the pattern of the machine declares, and
- * only when the result covers EVERY name of that pattern.
- *
- * A complete pick is an answer, and a partial pick is not: a wrapper route of the host
- * can declare a subset of the params of the machine — a tenant segment, for example,
- * but not the document one — and keeping that subset drops the rest from a route that
- * declares them. The caller falls back to its own extraction for `null`.
- *
- * The result has a null prototype, so a param named `__proto__` stays an own key.
- *
- * An OPTIONAL name of the pattern (`:name?`) is covered whether the framework reports
- * it or not: a segment that did not match has no value, and that is a complete answer.
- * At least one declared name must come back, though — a framework that reports none
- * matched another route, and the path may still hold a value that only the fallback
- * reads. A pattern whose params are ALL optional therefore always answers `null` here
- * when the framework reports nothing; {@link resolveFrameworkParams} then reads the PATH,
- * which settles the question without the framework and without URLPattern.
- *
- * @param params - The params of the framework router. {@link cleanFrameworkParams}
- *   removes each empty value already, and one that reaches here anyway counts as
- *   absent: an empty value says that the segment did not match, and never that the
- *   path carries the empty string.
- * @param names - The names that the pattern of the machine declares.
- * @param requiredNames - The names the pattern REQUIRES. The default treats every name
- *   as required, so a two-argument call keeps the strict test.
- * @returns The params of the machine, or `null` when the framework covers them not.
- */
-export declare function pickOwnParams(params: Record<string, string>, names: string[], requiredNames?: string[]): Record<string, string> | null;
-/**
- * The params of a framework router, in the shape that {@link pickOwnParams} reads.
- *
- * Every framework reports a param that its own route DECLARES and that the location
- * did not fill: Vue Router gives `undefined` or `""`, and SolidJS Router does the
- * same. Such an entry is not an answer, and a pick that kept it would send an empty
- * value to the actor as though the path carried one. Drop it here instead, one time,
- * because the rule belongs to the decision of {@link resolveFrameworkParams} and not
- * to a bridge: `VueRouterBridge` and `SolidRouterBridge` held one copy each.
- *
- * A value of an array — the splat of a catch-all route of Vue Router — becomes its
- * `String()` form, exactly as a single value does.
- *
- * The result has a null prototype, for the same reason {@link pickOwnParams} gives: a
- * plain `{}` accumulator turns `cleaned["__proto__"] = value` into a write of the
- * PROTOTYPE setter, which drops a string value in silence. `pickOwnParams` then read
- * `Object.hasOwn(params, "__proto__")` as `false`, called the pick incomplete, and fell
- * back to the URLPattern extraction — which THROWS on a runtime with no URLPattern, for
- * a route the framework had answered already.
- *
- * @param params - The raw params of the framework router.
- * @returns The params with no absent value, each one a string.
- */
-export declare function cleanFrameworkParams(params: Record<string, unknown>): Record<string, string>;
-/** What {@link resolveFrameworkParams} needs from the bridge that calls it. */
-export interface FrameworkParamsSource {
-    /** The route pattern of the match, from `routeMap.getPathByStateId`. */
-    pattern: string | null | undefined;
-    /** The resolved prefix of the mount. `""` means that the machine owns the router. */
-    basePath: string;
-    /**
-     * The machine-side path of the location, with the mount prefix already removed.
-     *
-     * The field is OPTIONAL, so a caller that was written before it keeps its behaviour:
-     * the one branch that reads it falls back without it, exactly as it did.
-     */
-    pathname?: string;
-    /** The params of the framework router, read lazily and cleaned of empty values. */
-    frameworkParams(): Record<string, string>;
-    /** The URLPattern extraction of the base class, read lazily. */
-    fallback(): Record<string, string>;
-}
-/**
- * Decides which params describe the route of the machine.
- *
- * The three branches, in the order that they apply:
- *
- * - **The pattern declares no name** — a static path, a bare `*` wildcard, or an
- *   unknown stateId. The answer is `{}`. The params of the framework must NOT travel
- *   here: under a catch-all they hold the splat of the host, and that value would reach
- *   the actor as a param of the machine. This branch also reaches no URLPattern, which
- *   matters: the extraction needs the constructor even for a pattern with no parameter,
- *   so a delegation would throw on a runtime without the API.
- * - **The bridge sits under a mount** — the framework matched a route of the HOST by
- *   construction, because the machine owns the suffix of the path only. Its params
- *   therefore describe this pattern never, whatever they are named, and a name that
- *   happens to collide carries the value of the host. Read the params of the machine
- *   from its own pattern instead.
- * - **The framework covers every REQUIRED name** — it matched the machine route. Keep
- *   its parse, together with its decoding. An optional `:name?` that the framework
- *   reports not is covered too: a segment that did not match has no value. A gap in a
- *   required name falls back, because keeping it would drop a name the route declares.
- * - **The path IS the bare form of the pattern** — every optional segment is absent, so
- *   `{}` is the complete answer. The branch reads the path and trusts the framework with
- *   nothing, which is what makes it safe under a catch-all of the host, and it calls
- *   URLPattern for a location that needs none.
- *
- * None of this decides whether the APPLICATION needs a URLPattern polyfill. A `RouteMap`
- * that holds one parameterized route compiles it in the CONSTRUCTOR, and it throws a
- * `URLPatternUnavailableError` there when the runtime has no URLPattern. The polyfill
- * question is therefore settled at startup: only a route map of static paths alone
- * escapes it. What these branches decide is whether a NAVIGATION calls URLPattern again.
- *
- * @returns The path parameters of the machine route, or `{}`.
- */
-export declare function resolveFrameworkParams({ pattern, basePath, pathname, frameworkParams, fallback, }: FrameworkParamsSource): Record<string, string>;
-//# sourceMappingURL=framework-params.d.ts.map

package/dist/framework-params.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"framework-params.d.ts","sourceRoot":"","sources":["../src/framework-params.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAUH;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAE9D;AAqCD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,4BAA4B,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAEtE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,aAAa,CAC5B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC9B,KAAK,EAAE,MAAM,EAAE,EACf,aAAa,GAAE,MAAM,EAAU,GAC7B,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAoC/B;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAc5F;AAkDD,+EAA+E;AAC/E,MAAM,WAAW,qBAAqB;IACrC,wEAAwE;IACxE,OAAO,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IACnC,qFAAqF;IACrF,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,mFAAmF;IACnF,eAAe,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1C,gEAAgE;IAChE,QAAQ,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACnC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,sBAAsB,CAAC,EACtC,OAAO,EACP,QAAQ,EACR,QAAQ,EACR,eAAe,EACf,QAAQ,GACR,EAAE,qBAAqB,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAqBhD"}