@xmachines/play-router 2.2.0 → 4.0.0

package/dist/framework-params.js

@@ -1,291 +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)
- */
-/**
- * The expression reads each NAMED parameter of a route pattern of the route map, for
- * example `userId` of `/profile/:userId`, `section` of `/settings/:section?`, and
- * `cat-id` of `/docs/:cat-id`. A `*` wildcard carries no name, and the expression
- * therefore matches it not.
- */
-const PATTERN_PARAM_NAME_RE = /:([A-Za-z_$][A-Za-z0-9_$-]*)(\?)?/g;
-/**
- * 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 function getPatternParamNames(pattern) {
-    return [...readPatternParams(pattern).names];
-}
-/**
- * The names of each pattern that this module has read, kept at the module level.
- *
- * {@link resolveFrameworkParams} runs on EVERY navigation, and the answer for one
- * pattern never changes: a pattern is a static string of the route map. The number of
- * the route patterns of the application therefore bounds this cache, exactly as it
- * bounds the compiled-pattern cache of `url-pattern-utils.ts`.
- */
-const patternParamCache = new Map();
-/**
- * Reads the declared names and the REQUIRED names of a pattern in ONE scan.
- *
- * {@link resolveFrameworkParams} needs both lists for every navigation, and two calls
- * walked the pattern two times and allocated two match arrays for one answer. The two
- * exported readers stay, because each one names what a caller asks for.
- *
- * The result is CACHED, and each caller therefore treats the two arrays as read-only.
- */
-function readPatternParams(pattern) {
-    const cached = patternParamCache.get(pattern);
-    if (cached)
-        return cached;
-    const names = [];
-    const required = [];
-    for (const match of pattern.matchAll(PATTERN_PARAM_NAME_RE)) {
-        const name = match[1] ?? "";
-        names.push(name);
-        if (match[2] === undefined)
-            required.push(name);
-    }
-    const read = { names, required };
-    patternParamCache.set(pattern, read);
-    return read;
-}
-/**
- * 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 function getRequiredPatternParamNames(pattern) {
-    return [...readPatternParams(pattern).required];
-}
-/**
- * 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 function pickOwnParams(params, names, requiredNames = names) {
-    const required = new Set(requiredNames);
-    const picked = Object.create(null);
-    for (const name of names) {
-        // `Object.hasOwn` first, and not a bare read: this function is exported, so a
-        // caller can hand it a plain object, and `params["constructor"]` then walks the
-        // prototype chain and answers with a function for a name that the object holds not.
-        const value = Object.hasOwn(params, name)
-            ? params[name] // nosemgrep: gitlab.eslint.detect-object-injection
-            : undefined;
-        // An ABSENT value, and an empty one: {@link cleanFrameworkParams} drops both
-        // already, and this function is exported, so a caller of its own reaches here with
-        // either. A `?? ""` fallback wrote the empty value into the pick instead — the
-        // exact value that cleaning exists to remove — and that entry then counted as "the
-        // framework matched this route", so the pick won over the fallback that reads the
-        // value the PATH carries.
-        if (value === undefined || value === null || value === "") {
-            if (required.has(name))
-                return null;
-            continue;
-        }
-        picked[name] = value; // nosemgrep: gitlab.eslint.detect-object-injection
-    }
-    // NONE of the declared names came back, so the framework matched another route — a
-    // catch-all, in practice — and it knows nothing about this pattern. An empty pick
-    // would then drop a value the PATH carries: `/settings/security` against
-    // `/settings/:section?` holds "security", and only the fallback reads it. One name
-    // present is what says the framework matched this route, and an optional segment that
-    // did not match is genuinely absent.
-    if (names.length > 0 && Object.keys(picked).length === 0)
-        return null;
-    // Spread at the boundary: `event.params` reaches a machine of the user, and it was a
-    // plain object before this release. A spread creates OWN properties, so a param named
-    // "__proto__" stays a key while the value keeps a prototype — `hasOwnProperty` on it
-    // therefore answers instead of throwing.
-    return { ...picked };
-}
-/**
- * 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 function cleanFrameworkParams(params) {
-    const cleaned = Object.create(null);
-    for (const [name, value] of Object.entries(params)) {
-        if (value === undefined || value === null)
-            continue;
-        // The test runs on the STRING, and not on the raw value: a repeatable segment that
-        // the location did not fill comes back as an EMPTY ARRAY from Vue Router, and `[]`
-        // is not `""`. A raw test therefore let it through as `String([])`, which is the
-        // empty value this function exists to drop — `pickOwnParams` then picked it and the
-        // actor received `{ section: "" }` as though the path carried a value.
-        const text = String(value);
-        if (text === "")
-            continue;
-        cleaned[name] = text; // nosemgrep: gitlab.eslint.detect-object-injection
-    }
-    return cleaned;
-}
-/** A segment that is exactly one optional param, for example `:section?`. */
-const OPTIONAL_SEGMENT_RE = /^:[A-Za-z_$][A-Za-z0-9_$-]*\?$/;
-/**
- * True when the path IS the pattern with every optional segment absent.
- *
- * The test reads the PATH, and it trusts the framework with nothing. A pattern whose
- * trailing segments are all optional has a bare form that holds no `:` and no `*` —
- * `/settings/:section?` has the bare form `/settings` — and a path that equals that
- * form can only match the pattern with every optional group absent. No param has a
- * value, so `{}` is the complete answer whatever route the framework matched, and the
- * URLPattern fallback has nothing to add.
- *
- * The function answers `false` for anything it cannot prove:
- *
- * - An optional segment that is NOT trailing. `/a/:b?/c` matches `/a//c` for URLPattern,
- *   because the `/` before the group is a literal of its own, so `/a/c` is no bare form.
- * - A remaining segment that holds a `:` or a `*`. A required param has a value that
- *   only the fallback reads, and a wildcard matches a path of any length.
- *
- * @param pathname - The machine-side path, with the mount prefix already removed.
- * @param pattern - The route pattern of the machine.
- */
-function pathIsBareForm(pathname, pattern) {
-    const segments = pattern.split("/");
-    let end = segments.length;
-    while (end > 0 && OPTIONAL_SEGMENT_RE.test(segments.at(end - 1) ?? ""))
-        end -= 1;
-    // Nothing was optional at the end, so the pattern needs a value somewhere.
-    if (end === segments.length)
-        return false;
-    const kept = segments.slice(0, end);
-    if (kept.some((segment) => segment.includes(":") || segment.includes("*")))
-        return false;
-    return trimPath(kept.join("/")) === trimPath(pathname);
-}
-/**
- * One comparable form for a path: no query, no fragment, and no trailing slash.
- *
- * The root stays `"/"`, because a bare pattern of `/:section?` has the bare form `""`
- * and the path of that page is `"/"`.
- */
-function trimPath(path) {
-    const cut = path.split(/[?#]/)[0] ?? "";
-    const trimmed = cut.length > 1 && cut.endsWith("/") ? cut.slice(0, -1) : cut;
-    return trimmed === "" ? "/" : trimmed;
-}
-/**
- * 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 function resolveFrameworkParams({ pattern, basePath, pathname, frameworkParams, fallback, }) {
-    if (!pattern)
-        return {};
-    // One scan of the pattern, for both lists: this runs on every navigation.
-    const { names, required } = readPatternParams(pattern);
-    if (names.length === 0)
-        return {};
-    if (basePath !== "")
-        return fallback();
-    const picked = pickOwnParams(frameworkParams(), names, required);
-    if (picked !== null)
-        return picked;
-    // The framework reported none of the names. That is ambiguous on its own — it means
-    // "the segment is absent" or "another route matched" — and the PATH settles it
-    // without the framework and without URLPattern: a path that is the bare form of the
-    // pattern fills no optional segment, so `{}` is the complete answer.
-    //
-    // Only an all-optional pattern reaches this: `pathIsBareForm` refuses a bare form
-    // that still holds a `:`, so a missing REQUIRED name still falls back.
-    if (pathname !== undefined && pathIsBareForm(pathname, pattern))
-        return {};
-    return fallback();
-}
-//# sourceMappingURL=framework-params.js.map

package/dist/framework-params.js.map

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

package/dist/machine-to-graph.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"machine-to-graph.d.ts","sourceRoot":"","sources":["../src/machine-to-graph.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,QAAQ,CAAC;AAE9C,OAAO,EAAe,KAAK,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC3D,OAAO,KAAK,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAGnE;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,YAAY,GAAG,KAAK,CAAC,eAAe,EAAE,eAAe,CAAC,CAAC;AAsDnE,eAAO,MAAM,cAAc,GAAI,SAAS,eAAe,KAAG,YAwEzD,CAAC"}

package/dist/machine-to-graph.js.map

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

package/dist/query.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../src/query.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAa,MAAM,kBAAkB,CAAC;AAEzD,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AACzF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAIN,KAAK,eAAe,EACpB,MAAM,gBAAgB,CAAC;AAqBxB;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,kBAAkB,GAAI,MAAM,SAAS,EAAE,SAAS,MAAM,KAAG,SAAS,EA0B9E,CAAC;AAkBF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,iBAAiB,GAAI,MAAM,SAAS,KAAG,SAAS,EAW5D,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW,GAAI,MAAM,SAAS,EAAE,MAAM,MAAM,KAAG,OAE3D,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,4BAA4B,GACxC,OAAO,KAAK,CAAC,eAAe,EAAE,eAAe,CAAC,EAC9C,SAAS,MAAM,KACb,MAAM,EAER,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,gBAAgB,GAC5B,OAAO,KAAK,CAAC,eAAe,EAAE,eAAe,CAAC,EAC9C,aAAa,MAAM,EACnB,WAAW,MAAM,KACf,OAKF,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,eAAO,MAAM,gBAAgB,GAAI,MAAM,SAAS,EAAE,UAAU,eAAe,KAAG,YAAY,EAazF,CAAC"}

package/dist/query.js.map

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

package/dist/url-pattern-utils.d.ts

@@ -1,93 +0,0 @@
-/**
- * The minimal structural type of the part of URLPattern that this package uses.
- * The package therefore needs no hard dependency on the complete type declaration of
- * URLPattern.
- */
-export type URLPatternLike = {
-    exec(input: {
-        pathname: string;
-    }): {
-        pathname: {
-            groups: Record<string, string | undefined>;
-        };
-    } | null;
-    test(input: {
-        pathname: string;
-    }): boolean;
-};
-/** The constructor type of a URLPatternLike instance. */
-export type URLPatternCtor = new (init: {
-    pathname: string;
-}) => URLPatternLike;
-/**
- * Returns the URLPattern constructor of `globalThis`, or `undefined` when it is
- * absent: in Node < 24, and in an older browser without a polyfill.
- */
-export declare function getURLPatternCtor(): URLPatternCtor | undefined;
-/**
- * Tells you if a route path is a parameterized pattern, and not a concrete URL.
- *
- * A pattern holds a `:param` segment, which is necessary or optional, or the `*`
- * wildcard, or both. Each of them needs a URLPattern match, and each of them carries
- * no concrete value. Therefore the code can push such a path to a browser URL
- * never.
- *
- * This function is THE single source of truth of the question "is this path a
- * pattern?". `RouteMap` uses it for its decision between the static map and the
- * index of the pattern buckets, and `RouterBridgeBase.resolveNavigationPath` uses it
- * to skip a route of no navigation. The two tests therefore cannot move apart.
- *
- * @param path - The string of a URL path or of a route pattern, for example `/profile/:userId` or `/docs/*`
- * @returns `true` when the path holds a `:param` or a `*` pattern syntax
- */
-export declare function isParameterizedPattern(path: string): boolean;
-/**
- * Normalizes a route path, so that each of its parameter names is a valid URLPattern
- * identifier.
- *
- * URLPattern requires a valid JS identifier as a parameter name, and such an
- * identifier holds no hyphen. Therefore the function replaces a name with a hyphen,
- * for example `:cat-id`, with the equivalent name with an underscore (`:cat_id`),
- * for the compilation step of URLPattern. A caller that needs the values of the
- * captured groups, and not a test of the match alone, must map each normalized group
- * name back to the original param name with {@link getNormalizedParamNameMap}.
- *
- * @example
- * normalizeParamNames("/docs/:cat-id/:page-num?")
- * // → "/docs/:cat_id/:page_num?"
- */
-export declare function normalizeParamNames(path: string): string;
-/**
- * Builds the map from each normalized URLPattern group name back to the original
- * param name, which holds a hyphen, of a route pattern.
- *
- * The map holds only the params that {@link normalizeParamNames} rewrote. A param
- * with a valid identifier keeps its own name, and it needs no entry.
- *
- * @example
- * getNormalizedParamNameMap("/docs/:cat-id/:plain")
- * // → Map { "cat_id" → "cat-id" }
- */
-export declare function getNormalizedParamNameMap(path: string): Map<string, string>;
-export declare function getCompiledPattern(pattern: string, Ctor: URLPatternCtor): URLPatternLike;
-/**
- * Computes the key of the bucket index of a path or of a pattern.
- *
- * The key is the first path segment, for example `"settings"` of `"/settings/:id"`.
- * A first segment with a parameter (`:lang`) goes into the `"*"` wildcard bucket.
- * The root path `"/"` gives the key `"/"`.
- *
- * @param path - The string of a URL path or of a route pattern
- */
-export declare function getIndexKey(path: string): string;
-/**
- * Joins the bucket of the named segment and the wildcard bucket of one index key.
- * The order of the insertion stays, through the `order` field.
- *
- * @param patternBuckets - The map from a bucket key to its ordered pattern entries
- * @param indexKey - The key of the first segment, from `getIndexKey`
- */
-export declare function getCandidates<T extends {
-    order: number;
-}>(patternBuckets: Map<string, T[]>, indexKey: string): T[];
-//# sourceMappingURL=url-pattern-utils.d.ts.map

package/dist/url-pattern-utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"url-pattern-utils.d.ts","sourceRoot":"","sources":["../src/url-pattern-utils.ts"],"names":[],"mappings":"AAgBA;;;;GAIG;AACH,MAAM,MAAM,cAAc,GAAG;IAC5B,IAAI,CAAC,KAAK,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,GAAG;QAClC,QAAQ,EAAE;YAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAA;SAAE,CAAC;KACzD,GAAG,IAAI,CAAC;IACT,IAAI,CAAC,KAAK,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC;CAC3C,CAAC;AAEF,yDAAyD;AACzD,MAAM,MAAM,cAAc,GAAG,KAAK,IAAI,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,KAAK,cAAc,CAAC;AAEhF;;;GAGG;AACH,wBAAgB,iBAAiB,IAAI,cAAc,GAAG,SAAS,CAE9D;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE5D;AASD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAIxD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAO3E;AA0ED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,cAAc,GAAG,cAAc,CAqBxF;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAMhD;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,EACxD,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC,EAChC,QAAQ,EAAE,MAAM,GACd,CAAC,EAAE,CA2BL"}

package/dist/url-pattern-utils.js

@@ -1,233 +0,0 @@
-/**
- * The shared URLPattern utilities — an internal module. index.ts does not export it
- *
- * This module holds the common URLPattern work of four files:
- * - `create-route-map.ts`
- * - `base-route-map.ts`
- * - `find-route.ts`
- * - `router-bridge-base.ts`
- *
- * The module reads URLPattern from globalThis. A consumer must load a polyfill in an
- * environment without the native API: Node < 24, and an older browser.
- *
- * @internal
- */
-import { InvalidRoutePatternError } from "./errors.js";
-/**
- * Returns the URLPattern constructor of `globalThis`, or `undefined` when it is
- * absent: in Node < 24, and in an older browser without a polyfill.
- */
-export function getURLPatternCtor() {
-    return globalThis["URLPattern"];
-}
-/**
- * Tells you if a route path is a parameterized pattern, and not a concrete URL.
- *
- * A pattern holds a `:param` segment, which is necessary or optional, or the `*`
- * wildcard, or both. Each of them needs a URLPattern match, and each of them carries
- * no concrete value. Therefore the code can push such a path to a browser URL
- * never.
- *
- * This function is THE single source of truth of the question "is this path a
- * pattern?". `RouteMap` uses it for its decision between the static map and the
- * index of the pattern buckets, and `RouterBridgeBase.resolveNavigationPath` uses it
- * to skip a route of no navigation. The two tests therefore cannot move apart.
- *
- * @param path - The string of a URL path or of a route pattern, for example `/profile/:userId` or `/docs/*`
- * @returns `true` when the path holds a `:param` or a `*` pattern syntax
- */
-export function isParameterizedPattern(path) {
-    return path.includes(":") || path.includes("*");
-}
-/**
- * The expression matches a `:param` name with a hyphen, for example `:cat-id` or
- * `:page-num?`. URLPattern requires a valid JS identifier as a parameter name.
- * Therefore the code must rewrite a name with a hyphen before the compilation.
- */
-const HYPHENATED_PARAM_RE = /:([A-Za-z][A-Za-z0-9]*(?:-[A-Za-z0-9]+)+)(\??)/g;
-/**
- * Normalizes a route path, so that each of its parameter names is a valid URLPattern
- * identifier.
- *
- * URLPattern requires a valid JS identifier as a parameter name, and such an
- * identifier holds no hyphen. Therefore the function replaces a name with a hyphen,
- * for example `:cat-id`, with the equivalent name with an underscore (`:cat_id`),
- * for the compilation step of URLPattern. A caller that needs the values of the
- * captured groups, and not a test of the match alone, must map each normalized group
- * name back to the original param name with {@link getNormalizedParamNameMap}.
- *
- * @example
- * normalizeParamNames("/docs/:cat-id/:page-num?")
- * // → "/docs/:cat_id/:page_num?"
- */
-export function normalizeParamNames(path) {
-    return path.replace(HYPHENATED_PARAM_RE, (_m, name, optional) => {
-        return `:${name.replace(/-/g, "_")}${optional}`;
-    });
-}
-/**
- * Builds the map from each normalized URLPattern group name back to the original
- * param name, which holds a hyphen, of a route pattern.
- *
- * The map holds only the params that {@link normalizeParamNames} rewrote. A param
- * with a valid identifier keeps its own name, and it needs no entry.
- *
- * @example
- * getNormalizedParamNameMap("/docs/:cat-id/:plain")
- * // → Map { "cat_id" → "cat-id" }
- */
-export function getNormalizedParamNameMap(path) {
-    const nameMap = new Map();
-    for (const match of path.matchAll(HYPHENATED_PARAM_RE)) {
-        const original = match[1];
-        nameMap.set(original.replace(/-/g, "_"), original);
-    }
-    return nameMap;
-}
-/**
- * The cache of the compiled URLPattern instances at the module level. The key is the
- * string of the pattern.
- *
- * The code compiles a route pattern on every lookup path of a navigation
- * (`extractRouteParams` and `findRouteByPath`), and also one time for each
- * `RouteMap` construction. A new compilation of the same route pattern each time is
- * lost work. The number of the different route patterns of the route maps of the
- * application limits the growth of the cache. The cache goes away when the
- * URLPattern constructor changes, and a test changes `globalThis.URLPattern`.
- */
-const compiledPatternCache = new Map();
-let compiledPatternCtor;
-/**
- * Compiles a route pattern into a `URLPattern`, and it uses the cache of the module
- * level again.
- *
- * {@link normalizeParamNames} normalizes the pattern before the compilation. A param
- * name with a hyphen (`:cat-id`) therefore becomes a valid URLPattern identifier
- * (`:cat_id`). A caller that reads the values of the groups must map each normalized
- * name back with {@link getNormalizedParamNameMap}.
- *
- * An error of the compilation from the URLPattern constructor goes to the caller
- * without a change. A caller that needs a typed error wraps this function in an
- * `InvalidRoutePatternError`.
- *
- * @param pattern - The string of the route pattern, for example `/profile/:userId`
- * @param Ctor - The URLPattern constructor, from {@link getURLPatternCtor}
- */
-/**
- * Reads EVERY declared `:param` name, and not the hyphenated ones alone.
- *
- * {@link assertNoParamNameCollision} needs the plain names too: `:cat_id` is the name
- * that `:cat-id` collides WITH, and it holds no hyphen of its own.
- */
-const ANY_PARAM_NAME_RE = /:([A-Za-z][A-Za-z0-9_]*(?:-[A-Za-z0-9_]+)*)/g;
-/**
- * Refuses a pattern whose params land on ONE URLPattern identifier.
- *
- * `normalizeParamNames` rewrites a hyphen to an underscore, so `:cat-id` compiles as
- * `:cat_id`. A pattern that declares `:cat-id` AND `:cat_id` therefore gives URLPattern
- * one group name two times, and URLPattern refuses it with
- * `TypeError: Failed to construct URLPattern`.
- *
- * The refusal is right, and the message was not: the pattern is valid as the caller
- * wrote it, and the fault is a rewrite that this library makes and that no caller asked
- * for. Name the two params and the rule instead.
- *
- * @throws {InvalidRoutePatternError} When two declared names give one identifier.
- */
-function assertNoParamNameCollision(pattern) {
-    const seen = new Map();
-    for (const match of pattern.matchAll(ANY_PARAM_NAME_RE)) {
-        const name = match[1] ?? "";
-        const normalized = name.replace(/-/g, "_");
-        const earlier = seen.get(normalized);
-        // An identical name two times is the duplicate of the caller, and URLPattern says
-        // so clearly enough. This guard is for two DIFFERENT names that meet.
-        if (earlier !== undefined && earlier !== name) {
-            throw new InvalidRoutePatternError(pattern, {
-                reason: `The params ":${earlier}" and ":${name}" both compile to the group ` +
-                    `":${normalized}", because URLPattern needs a name with no hyphen and this ` +
-                    `library rewrites each hyphen to an underscore. Rename one of the two.`,
-            });
-        }
-        seen.set(normalized, name);
-    }
-}
-export function getCompiledPattern(pattern, Ctor) {
-    if (Ctor !== compiledPatternCtor) {
-        compiledPatternCache.clear();
-        compiledPatternCtor = Ctor;
-    }
-    let compiled = compiledPatternCache.get(pattern);
-    if (compiled === undefined) {
-        assertNoParamNameCollision(pattern);
-        // The wrap belongs HERE, at the one place that compiles. `RouteMap` wrapped the
-        // call of its own and `extractRouteParams` wrapped nothing, so a consumer that read
-        // the params of a route the map never held received a bare
-        // `TypeError: Failed to construct URLPattern` — no error code, and a type that the
-        // error contract of this package does not name.
-        try {
-            compiled = new Ctor({ pathname: normalizeParamNames(pattern) });
-        }
-        catch (error) {
-            throw new InvalidRoutePatternError(pattern, { cause: error });
-        }
-        compiledPatternCache.set(pattern, compiled);
-    }
-    return compiled;
-}
-/**
- * Computes the key of the bucket index of a path or of a pattern.
- *
- * The key is the first path segment, for example `"settings"` of `"/settings/:id"`.
- * A first segment with a parameter (`:lang`) goes into the `"*"` wildcard bucket.
- * The root path `"/"` gives the key `"/"`.
- *
- * @param path - The string of a URL path or of a route pattern
- */
-export function getIndexKey(path) {
-    const trimmed = path.startsWith("/") ? path.slice(1) : path;
-    if (trimmed.length === 0)
-        return "/";
-    const segment = trimmed.split("/")[0];
-    if (segment === undefined || segment.startsWith(":"))
-        return "*";
-    return segment;
-}
-/**
- * Joins the bucket of the named segment and the wildcard bucket of one index key.
- * The order of the insertion stays, through the `order` field.
- *
- * @param patternBuckets - The map from a bucket key to its ordered pattern entries
- * @param indexKey - The key of the first segment, from `getIndexKey`
- */
-export function getCandidates(patternBuckets, indexKey) {
-    const bucket = patternBuckets.get(indexKey) ?? [];
-    const wildcardBucket = patternBuckets.get("*") ?? [];
-    if (bucket.length === 0)
-        return wildcardBucket;
-    if (wildcardBucket.length === 0)
-        return bucket;
-    const merged = [];
-    let b = 0;
-    let w = 0;
-    while (b < bucket.length && w < wildcardBucket.length) {
-        if (bucket[b].order < wildcardBucket[w].order) {
-            merged.push(bucket[b]);
-            b += 1;
-        }
-        else {
-            merged.push(wildcardBucket[w]);
-            w += 1;
-        }
-    }
-    while (b < bucket.length) {
-        merged.push(bucket[b]);
-        b += 1;
-    }
-    while (w < wildcardBucket.length) {
-        merged.push(wildcardBucket[w]);
-        w += 1;
-    }
-    return merged;
-}
-//# sourceMappingURL=url-pattern-utils.js.map