@xmachines/play-router 6.1.0 → 7.0.0

package/dist/base-route-map.js

@@ -1,280 +1,250 @@
-/**
- * RouteMap — the shared base class of the route map for both directions
- *
- * The class gives you the pattern match on buckets, and every framework adapter
- * uses it. An adapter extends this class, and it therefore holds no copy of the
- * pattern match logic.
- *
- * The algorithm: an exact match in O(1) through a Map, then a pattern match on the
- * buckets in O(k), where k is the number of the routes in the bucket of the first
- * segment, and that number is much smaller than the number of all the routes. The
- * class matches a parameterized route with URLPattern.
- */
-import { createLruCache, getCandidates, getCompiledPattern, getIndexKey, parsePattern, splitLocation, } from "@xmachines/play-url";
 import { InvalidRoutePatternError } from "./errors.js";
+import { createLruCache, getCandidates, getCompiledPattern, getIndexKey, parsePattern, splitLocation } from "@xmachines/play-url";
+//#region packages/play-router/src/base-route-map.ts
+/**
+* RouteMap — the shared base class of the route map for both directions
+*
+* The class gives you the pattern match on buckets, and every framework adapter
+* uses it. An adapter extends this class, and it therefore holds no copy of the
+* pattern match logic.
+*
+* The algorithm: an exact match in O(1) through a Map, then a pattern match on the
+* buckets in O(k), where k is the number of the routes in the bucket of the first
+* segment, and that number is much smaller than the number of all the routes. The
+* class matches a parameterized route with URLPattern.
+*/
 /**
- * The canonical key of a stateId: the bare form, without a `#` at its start.
- *
- * `RouteMap` accepts a stateId in the form `"#stateId"` and in the form `"stateId"`,
- * on an insert and on a lookup. Inside the class, the key of every stateId is this
- * canonical bare form. Therefore a consumer writes no handler of the two forms. The
- * class keeps the *registered* form, and `getStateIdByPath` returns it. The map is
- * therefore honest about the declaration of each route.
- */
+* The canonical key of a stateId: the bare form, without a `#` at its start.
+*
+* `RouteMap` accepts a stateId in the form `"#stateId"` and in the form `"stateId"`,
+* on an insert and on a lookup. Inside the class, the key of every stateId is this
+* canonical bare form. Therefore a consumer writes no handler of the two forms. The
+* class keeps the *registered* form, and `getStateIdByPath` returns it. The map is
+* therefore honest about the declaration of each route.
+*/
 function canonicalStateIdKey(stateId) {
-    return stateId.startsWith("#") ? stateId.slice(1) : stateId;
+	return stateId.startsWith("#") ? stateId.slice(1) : stateId;
 }
 /**
- * The bound of the path cache that a map builds for itself.
- *
- * `createLruCache` keeps two generations, so the cache holds twice this number and one
- * more at most. A caller that wants another bound passes a cache: `createLruCache(5000)`
- * builds one. A separate size option would configure THIS cache alone and say so nowhere,
- * and it would do nothing at all beside a cache that the caller passed.
- */
-const DEFAULT_PATH_CACHE_SIZE = 500;
+* The bound of the path cache that a map builds for itself.
+*
+* `createLruCache` keeps two generations, so the cache holds twice this number and one
+* more at most. A caller that wants another bound passes a cache: `createLruCache(5000)`
+* builds one. A separate size option would configure THIS cache alone and say so nowhere,
+* and it would do nothing at all beside a cache that the caller passed.
+*/
+var DEFAULT_PATH_CACHE_SIZE = 500;
 /**
- * The id of one route table: a digest of its mappings, in order.
- *
- * It is the key space that each ROUTE TABLE owns inside a shared path cache. An entry of
- * that cache says which state a path resolves to, and the answer is a pure function of
- * the mappings and the path: two maps built from the SAME mappings resolve every path the
- * same way, and two maps built from different mappings do not. A map with no route for
- * `/settings/x` writes `null`, and a map that DOES hold `/settings/:s` then read that
- * `null` and reported no state for a route of its own.
- *
- * The key therefore names the TABLE, and not the instance. An instance counter kept the
- * two apart as well, and it also gave a server that rebuilds its map for each request a
- * cache that answered nothing: every request opened a key space of its own, and the dead
- * keys of the last one evicted the live entries of this one.
- *
- * Two maps built from the same mappings share the id, which is what a server that
- * rebuilds its map for each request needs, and two maps built from different mappings do
- * not — a map with no route for a path writes `null` for it, and a map that HOLDS one
- * must not read that.
- *
- * A REGISTER of the serialized tables answered this before, and it kept every table
- * string it had seen for the life of the process: a per-tenant table of fifty routes is a
- * few kilobytes, and a bounded register of them still retained megabytes in exactly the
- * per-request case that the cache exists for. A digest retains nothing.
- *
- * ## The collision
- *
- * Two DIFFERENT tables that share a digest share a key space, and the negative entries of
- * one then answer for the other. The digest is 64 bits over the full signature, so a
- * process that built ten thousand distinct route tables carries a chance of about 3 in
- * 10^12 of one collision — far below the chance of the bit flip that would corrupt the
- * cache anyway. This library already identifies by digest: an XMachines id is a Git OID.
- */
+* The id of one route table: a digest of its mappings, in order.
+*
+* It is the key space that each ROUTE TABLE owns inside a shared path cache. An entry of
+* that cache says which state a path resolves to, and the answer is a pure function of
+* the mappings and the path: two maps built from the SAME mappings resolve every path the
+* same way, and two maps built from different mappings do not. A map with no route for
+* `/settings/x` writes `null`, and a map that DOES hold `/settings/:s` then read that
+* `null` and reported no state for a route of its own.
+*
+* The key therefore names the TABLE, and not the instance. An instance counter kept the
+* two apart as well, and it also gave a server that rebuilds its map for each request a
+* cache that answered nothing: every request opened a key space of its own, and the dead
+* keys of the last one evicted the live entries of this one.
+*
+* Two maps built from the same mappings share the id, which is what a server that
+* rebuilds its map for each request needs, and two maps built from different mappings do
+* not — a map with no route for a path writes `null` for it, and a map that HOLDS one
+* must not read that.
+*
+* A REGISTER of the serialized tables answered this before, and it kept every table
+* string it had seen for the life of the process: a per-tenant table of fifty routes is a
+* few kilobytes, and a bounded register of them still retained megabytes in exactly the
+* per-request case that the cache exists for. A digest retains nothing.
+*
+* ## The collision
+*
+* Two DIFFERENT tables that share a digest share a key space, and the negative entries of
+* one then answer for the other. The digest is 64 bits over the full signature, so a
+* process that built ten thousand distinct route tables carries a chance of about 3 in
+* 10^12 of one collision — far below the chance of the bit flip that would corrupt the
+* cache anyway. This library already identifies by digest: an XMachines id is a Git OID.
+*/
 function routeTableId(mappings) {
-    // FNV-1a, in two 32-bit halves, because a bitwise operator of JavaScript truncates to
-    // 32 bits and `BigInt` costs an allocation for each character.
-    let hashLow = 0x811c9dc5;
-    let hashHigh = 0x811c9dc5;
-    for (const { stateId, path } of mappings) {
-        // The ORDER is significant: it gives the priority when more than one pattern matches,
-        // so the separators below keep `[{a, /x}, {b, /y}]` apart from `[{a, /x/b}, {/y}]`.
-        const entry = `${stateId}\u0000${path}\u0001`;
-        for (let index = 0; index < entry.length; index += 1) {
-            const code = entry.charCodeAt(index);
-            hashLow = Math.imul(hashLow ^ code, 0x01000193) >>> 0;
-            hashHigh = Math.imul(hashHigh ^ (code + index), 0x01000193) >>> 0;
-        }
-    }
-    return `${hashLow.toString(36)}.${hashHigh.toString(36)}`;
+	let hashLow = 2166136261;
+	let hashHigh = 2166136261;
+	for (const { stateId, path } of mappings) {
+		const entry = `${stateId}\u0000${path}\u0001`;
+		for (let index = 0; index < entry.length; index += 1) {
+			const code = entry.charCodeAt(index);
+			hashLow = Math.imul(hashLow ^ code, 16777619) >>> 0;
+			hashHigh = Math.imul(hashHigh ^ code + index, 16777619) >>> 0;
+		}
+	}
+	return `${hashLow.toString(36)}.${hashHigh.toString(36)}`;
 }
 /**
- * The shared base class of the route map for both directions.
- *
- * Every framework adapter uses this class as its route map. An adapter adds no logic
- * of its own, and it inherits the complete public API from here.
- *
- * **The strategy of a lookup:**
- * - A static path, without a `:param` → a `Map` lookup in O(1)
- * - A dynamic path → a scan of the bucket index in O(k), with `URLPattern`, where
- *   `k` is the number of the routes with the same first path segment
- * - The class keeps each result of a first match in an LRU cache. The default cache
- *   holds 1001 entries at most, and the `pathCache` constructor option replaces it
- *
- * **The syntax of a pattern:** the whole URLPattern pathname grammar. The forms used most
- * often are:
- * - `:param` — a necessary segment. It matches exactly one segment without a `/`
- * - `:param?` — an optional segment. It matches zero segments or one segment without a `/`
- * - `*` — a wildcard. It matches each number of segments, as URLPattern defines
- *
- * A `{…}` group, a `:param(\d+)` constraint, a `+` modifier and a `\:` escape are read
- * too. The [routing guide](../../docs/guides/routing.md) states every form, the prefix
- * rule, and the one divergence from the standard: a param name of this library can hold a
- * hyphen.
- *
- * **The forms of a stateId:** you can register a stateId, and you can look one up,
- * in the form `"#stateId"` or in the form `"stateId"`. `RouteMap` makes the
- * canonical form itself. `getStateIdByPath` returns the stateId exactly as you
- * registered it, and `getPathByStateId` accepts both forms. A registration of the
- * same stateId in both forms gives one entry, and the later registration wins for
- * the lookup in the other direction.
- *
- * @example
- * ```typescript
- * import { RouteMap } from "@xmachines/play-router";
- *
- * const map = new RouteMap([
- *   { stateId: "home",     path: "/" },
- *   { stateId: "profile",  path: "/profile/:userId" },
- *   { stateId: "settings", path: "/settings/:section?" },
- * ]);
- *
- * map.getStateIdByPath("/");               // "home"
- * map.getStateIdByPath("/profile/123");    // "profile"
- * map.getStateIdByPath("/settings");       // "settings"
- * map.getStateIdByPath("/unknown");        // null
- *
- * map.getPathByStateId("profile");         // "/profile/:userId"
- * map.getPathByStateId("missing");         // null
- * ```
- */
-export class RouteMap {
-    /** The key is the canonical stateId form, which is bare and without a `#`. */
-    stateIdToPath;
-    pathToStateId;
-    patternBuckets;
-    pathMatchCache;
-    /** The key space of this ROUTE TABLE inside {@link pathMatchCache}, which a caller may share. */
-    pathCacheKey;
-    /**
-     * The caches that every parse and every compilation of this map reads.
-     *
-     * Each default stays SHARED on purpose. A map that built one of its own would keep its
-     * patterns out of the cache that `find-route.ts` and `router-sync.ts` read, so the same
-     * pattern would parse two times. A caller that wants the isolation passes a cache.
-     */
-    compileOptions;
-    /**
-     * Builds a route map from an array of the mappings between a state ID and a path.
-     *
-     * The constructor puts each static path, which holds no `:param`, into a `Map` for a
-     * lookup in O(1). It compiles each parameterized path to a `URLPattern`, and it
-     * groups the patterns into the buckets of the first segment. The selection of the
-     * candidates is therefore efficient.
-     *
-     * @param mappings - The array of the `{ stateId, path }` entries. The order gives the
-     *   priority when more than one pattern can match the same path.
-     * @param options - See {@link RouteMapOptions}. A map holds TWO caches, so no option is
-     *   named `cache`: each one names the cache that it carries.
-     */
-    constructor(mappings, options = {}) {
-        const { pathCache, ...compileOptions } = options;
-        this.compileOptions = compileOptions;
-        this.stateIdToPath = new Map();
-        this.pathToStateId = new Map();
-        this.patternBuckets = new Map();
-        this.pathMatchCache = pathCache ?? createLruCache(DEFAULT_PATH_CACHE_SIZE);
-        // A map that BUILDS its own cache owns every key in it, and a prefix would only make
-        // each key longer. A map that RECEIVES one shares it, so its keys carry the prefix.
-        if (pathCache === undefined) {
-            this.pathCacheKey = (path) => path;
-        }
-        else {
-            const prefix = `${routeTableId(mappings)}\u0002`;
-            this.pathCacheKey = (path) => prefix + path;
-        }
-        let patternOrder = 0;
-        for (const { stateId, path } of mappings) {
-            // The key is the canonical bare form. Therefore getPathByStateId accepts
-            // "#stateId" and also "stateId". The map keeps the registered form for its return
-            // values.
-            this.stateIdToPath.set(canonicalStateIdKey(stateId), path);
-            // ONE parse answers both questions: is the path a pattern, and which bucket does
-            // it belong to. The key comes from that parse, and not from a split of the raw
-            // string. A pattern such as `/books{/:id}?` keeps the literal first segment
-            // `books`, and a split on `/` read the key `books{` and put the route in a bucket
-            // that the path `/books/1` reaches never.
-            const parsed = parsePattern(path, this.compileOptions);
-            if (parsed.parameterized) {
-                const bucketKey = parsed.indexKey;
-                const bucket = this.patternBuckets.get(bucketKey) ?? [];
-                try {
-                    bucket.push({
-                        pattern: getCompiledPattern(path, this.compileOptions),
-                        stateId,
-                        order: patternOrder++,
-                    });
-                }
-                catch (err) {
-                    // `getCompiledPattern` reports an invalid pattern itself, and with the REASON
-                    // when it knows one. A second wrap here replaced that message with the
-                    // generic one, so the explanation reached the caller never.
-                    if (err instanceof InvalidRoutePatternError)
-                        throw err;
-                    throw new InvalidRoutePatternError(path, { cause: err });
-                }
-                this.patternBuckets.set(bucketKey, bucket);
-            }
-            else {
-                this.pathToStateId.set(path, stateId);
-            }
-        }
-    }
-    /**
-     * Resolves a URL path to its state ID.
-     *
-     * The method removes the query string and the hash fragment before the match. It
-     * tries an exact lookup in O(1) first, then it uses the pattern match on the bucket
-     * index. It keeps each result of a first pattern match in the cache.
-     *
-     * @param path - The URL pathname. It can hold a query and a hash, for example `"/profile/123?ref=nav"`
-     * @returns The state ID of the path, or `null` when no route matches
-     *
-     * @example
-     * ```typescript
-     * map.getStateIdByPath("/profile/123");  // "profile"
-     * map.getStateIdByPath("/unknown");      // null
-     * ```
-     */
-    getStateIdByPath(path) {
-        // Remove the query string and the hash fragment before the match. `splitLocation` is
-        // the ONE answer to "where does a pathname end", and `RouterBridgeBase`,
-        // `framework-params.ts` and `sanitizePathname` read it too, so the four cannot
-        // disagree. Two splits allocated two arrays of every part on the hottest lookup of
-        // the library, and this function then read one element of each.
-        const cleanPath = splitLocation(path).pathname;
-        const exactMatch = this.pathToStateId.get(cleanPath);
-        if (exactMatch !== undefined)
-            return exactMatch;
-        const cacheKey = this.pathCacheKey(cleanPath);
-        const cachedMatch = this.pathMatchCache.get(cacheKey);
-        if (cachedMatch !== undefined)
-            return cachedMatch;
-        const candidates = getCandidates(this.patternBuckets, getIndexKey(cleanPath));
-        for (const { pattern, stateId } of candidates) {
-            const match = pattern.exec({ pathname: cleanPath });
-            if (match) {
-                this.pathMatchCache.set(cacheKey, stateId);
-                return stateId;
-            }
-        }
-        this.pathMatchCache.set(cacheKey, null);
-        return null;
-    }
-    /**
-     * Returns the path pattern of a state ID.
-     *
-     * The method accepts the stateId in the form `"#stateId"` and in the form
-     * `"stateId"`, and the form of the registration has no effect. The method makes the
-     * canonical form itself. Therefore a consumer tries never both forms.
-     *
-     * @param stateId - The state ID of the state machine, for example `"profile"` or `"#settings"`
-     * @returns The registered path pattern, or `null` when the state ID is unknown
-     *
-     * @example
-     * ```typescript
-     * map.getPathByStateId("profile");   // "/profile/:userId"
-     * map.getPathByStateId("#profile");  // "/profile/:userId" — the same entry
-     * map.getPathByStateId("missing");   // null
-     * ```
-     */
-    getPathByStateId(stateId) {
-        return this.stateIdToPath.get(canonicalStateIdKey(stateId)) ?? null;
-    }
-}
+* The shared base class of the route map for both directions.
+*
+* Every framework adapter uses this class as its route map. An adapter adds no logic
+* of its own, and it inherits the complete public API from here.
+*
+* **The strategy of a lookup:**
+* - A static path, without a `:param` → a `Map` lookup in O(1)
+* - A dynamic path → a scan of the bucket index in O(k), with `URLPattern`, where
+*   `k` is the number of the routes with the same first path segment
+* - The class keeps each result of a first match in an LRU cache. The default cache
+*   holds 1001 entries at most, and the `pathCache` constructor option replaces it
+*
+* **The syntax of a pattern:** the whole URLPattern pathname grammar. The forms used most
+* often are:
+* - `:param` — a necessary segment. It matches exactly one segment without a `/`
+* - `:param?` — an optional segment. It matches zero segments or one segment without a `/`
+* - `*` — a wildcard. It matches each number of segments, as URLPattern defines
+*
+* A `{…}` group, a `:param(\d+)` constraint, a `+` modifier and a `\:` escape are read
+* too. The [routing guide](../../docs/guides/routing.md) states every form, the prefix
+* rule, and the one divergence from the standard: a param name of this library can hold a
+* hyphen.
+*
+* **The forms of a stateId:** you can register a stateId, and you can look one up,
+* in the form `"#stateId"` or in the form `"stateId"`. `RouteMap` makes the
+* canonical form itself. `getStateIdByPath` returns the stateId exactly as you
+* registered it, and `getPathByStateId` accepts both forms. A registration of the
+* same stateId in both forms gives one entry, and the later registration wins for
+* the lookup in the other direction.
+*
+* @example
+* ```typescript
+* import { RouteMap } from "@xmachines/play-router";
+*
+* const map = new RouteMap([
+*   { stateId: "home",     path: "/" },
+*   { stateId: "profile",  path: "/profile/:userId" },
+*   { stateId: "settings", path: "/settings/:section?" },
+* ]);
+*
+* map.getStateIdByPath("/");               // "home"
+* map.getStateIdByPath("/profile/123");    // "profile"
+* map.getStateIdByPath("/settings");       // "settings"
+* map.getStateIdByPath("/unknown");        // null
+*
+* map.getPathByStateId("profile");         // "/profile/:userId"
+* map.getPathByStateId("missing");         // null
+* ```
+*/
+var RouteMap = class {
+	/** The key is the canonical stateId form, which is bare and without a `#`. */
+	stateIdToPath;
+	pathToStateId;
+	patternBuckets;
+	pathMatchCache;
+	/** The key space of this ROUTE TABLE inside {@link pathMatchCache}, which a caller may share. */
+	pathCacheKey;
+	/**
+	* The caches that every parse and every compilation of this map reads.
+	*
+	* Each default stays SHARED on purpose. A map that built one of its own would keep its
+	* patterns out of the cache that `find-route.ts` and `router-sync.ts` read, so the same
+	* pattern would parse two times. A caller that wants the isolation passes a cache.
+	*/
+	compileOptions;
+	/**
+	* Builds a route map from an array of the mappings between a state ID and a path.
+	*
+	* The constructor puts each static path, which holds no `:param`, into a `Map` for a
+	* lookup in O(1). It compiles each parameterized path to a `URLPattern`, and it
+	* groups the patterns into the buckets of the first segment. The selection of the
+	* candidates is therefore efficient.
+	*
+	* @param mappings - The array of the `{ stateId, path }` entries. The order gives the
+	*   priority when more than one pattern can match the same path.
+	* @param options - See {@link RouteMapOptions}. A map holds TWO caches, so no option is
+	*   named `cache`: each one names the cache that it carries.
+	*/
+	constructor(mappings, options = {}) {
+		const { pathCache, ...compileOptions } = options;
+		this.compileOptions = compileOptions;
+		this.stateIdToPath = /* @__PURE__ */ new Map();
+		this.pathToStateId = /* @__PURE__ */ new Map();
+		this.patternBuckets = /* @__PURE__ */ new Map();
+		this.pathMatchCache = pathCache ?? createLruCache(DEFAULT_PATH_CACHE_SIZE);
+		if (pathCache === void 0) this.pathCacheKey = (path) => path;
+		else {
+			const prefix = `${routeTableId(mappings)}\u0002`;
+			this.pathCacheKey = (path) => prefix + path;
+		}
+		let patternOrder = 0;
+		for (const { stateId, path } of mappings) {
+			this.stateIdToPath.set(canonicalStateIdKey(stateId), path);
+			const parsed = parsePattern(path, this.compileOptions);
+			if (parsed.parameterized) {
+				const bucketKey = parsed.indexKey;
+				const bucket = this.patternBuckets.get(bucketKey) ?? [];
+				try {
+					bucket.push({
+						pattern: getCompiledPattern(path, this.compileOptions),
+						stateId,
+						order: patternOrder++
+					});
+				} catch (err) {
+					if (err instanceof InvalidRoutePatternError) throw err;
+					throw new InvalidRoutePatternError(path, { cause: err });
+				}
+				this.patternBuckets.set(bucketKey, bucket);
+			} else this.pathToStateId.set(path, stateId);
+		}
+	}
+	/**
+	* Resolves a URL path to its state ID.
+	*
+	* The method removes the query string and the hash fragment before the match. It
+	* tries an exact lookup in O(1) first, then it uses the pattern match on the bucket
+	* index. It keeps each result of a first pattern match in the cache.
+	*
+	* @param path - The URL pathname. It can hold a query and a hash, for example `"/profile/123?ref=nav"`
+	* @returns The state ID of the path, or `null` when no route matches
+	*
+	* @example
+	* ```typescript
+	* map.getStateIdByPath("/profile/123");  // "profile"
+	* map.getStateIdByPath("/unknown");      // null
+	* ```
+	*/
+	getStateIdByPath(path) {
+		const cleanPath = splitLocation(path).pathname;
+		const exactMatch = this.pathToStateId.get(cleanPath);
+		if (exactMatch !== void 0) return exactMatch;
+		const cacheKey = this.pathCacheKey(cleanPath);
+		const cachedMatch = this.pathMatchCache.get(cacheKey);
+		if (cachedMatch !== void 0) return cachedMatch;
+		const candidates = getCandidates(this.patternBuckets, getIndexKey(cleanPath));
+		for (const { pattern, stateId } of candidates) if (pattern.exec({ pathname: cleanPath })) {
+			this.pathMatchCache.set(cacheKey, stateId);
+			return stateId;
+		}
+		this.pathMatchCache.set(cacheKey, null);
+		return null;
+	}
+	/**
+	* Returns the path pattern of a state ID.
+	*
+	* The method accepts the stateId in the form `"#stateId"` and in the form
+	* `"stateId"`, and the form of the registration has no effect. The method makes the
+	* canonical form itself. Therefore a consumer tries never both forms.
+	*
+	* @param stateId - The state ID of the state machine, for example `"profile"` or `"#settings"`
+	* @returns The registered path pattern, or `null` when the state ID is unknown
+	*
+	* @example
+	* ```typescript
+	* map.getPathByStateId("profile");   // "/profile/:userId"
+	* map.getPathByStateId("#profile");  // "/profile/:userId" — the same entry
+	* map.getPathByStateId("missing");   // null
+	* ```
+	*/
+	getPathByStateId(stateId) {
+		return this.stateIdToPath.get(canonicalStateIdKey(stateId)) ?? null;
+	}
+};
+//#endregion
+export { RouteMap };
+
 //# sourceMappingURL=base-route-map.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"base-route-map.js","sourceRoot":"","sources":["../src/base-route-map.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"base-route-map.js","names":[],"sources":["../src/base-route-map.ts"],"sourcesContent":["/**\n * RouteMap — the shared base class of the route map for both directions\n *\n * The class gives you the pattern match on buckets, and every framework adapter\n * uses it. An adapter extends this class, and it therefore holds no copy of the\n * pattern match logic.\n *\n * The algorithm: an exact match in O(1) through a Map, then a pattern match on the\n * buckets in O(k), where k is the number of the routes in the bucket of the first\n * segment, and that number is much smaller than the number of all the routes. The\n * class matches a parameterized route with URLPattern.\n */\n\nimport {\n\tcreateLruCache,\n\tgetCandidates,\n\tgetCompiledPattern,\n\tgetIndexKey,\n\tparsePattern,\n\tsplitLocation,\n\ttype CompileOptions,\n\ttype KeyValueCache,\n\ttype URLPatternLike,\n} from \"@xmachines/play-url\";\n\nimport { InvalidRoutePatternError } from \"./errors.js\";\nimport type { RouteMapOptions } from \"./types.js\";\n\n/**\n * The canonical key of a stateId: the bare form, without a `#` at its start.\n *\n * `RouteMap` accepts a stateId in the form `\"#stateId\"` and in the form `\"stateId\"`,\n * on an insert and on a lookup. Inside the class, the key of every stateId is this\n * canonical bare form. Therefore a consumer writes no handler of the two forms. The\n * class keeps the *registered* form, and `getStateIdByPath` returns it. The map is\n * therefore honest about the declaration of each route.\n */\nfunction canonicalStateIdKey(stateId: string): string {\n\treturn stateId.startsWith(\"#\") ? stateId.slice(1) : stateId;\n}\n\n/**\n * One entry of the map between a state ID and a path.\n *\n * Both fields are `readonly`, because a mapping is immutable after the caller gives\n * it to `RouteMap`. An adapter package re-exports a structurally compatible\n * `RouteMapping` type under its own name. `@xmachines/play-router` publishes this\n * type as `RouteMapping`, and its name therefore does not collide with such a local\n * type of an adapter.\n *\n * @example\n * ```typescript\n * const mapping: RouteMapping = { stateId: \"home\", path: \"/\" };\n * const paramMapping: RouteMapping = { stateId: \"profile\", path: \"/profile/:userId\" };\n * const optionalMapping: RouteMapping = { stateId: \"settings\", path: \"/settings/:section?\" };\n * ```\n */\nexport interface RouteMapping {\n\t/** The state ID of the state machine, for example `\"home\"` or `\"#profile\"` */\n\treadonly stateId: string;\n\t/** The pattern of the URL path, for example `\"/\"`, `\"/profile/:userId\"`, or `\"/settings/:section?\"` */\n\treadonly path: string;\n}\n\n/**\n * The bound of the path cache that a map builds for itself.\n *\n * `createLruCache` keeps two generations, so the cache holds twice this number and one\n * more at most. A caller that wants another bound passes a cache: `createLruCache(5000)`\n * builds one. A separate size option would configure THIS cache alone and say so nowhere,\n * and it would do nothing at all beside a cache that the caller passed.\n */\nconst DEFAULT_PATH_CACHE_SIZE = 500;\n\n/**\n * The id of one route table: a digest of its mappings, in order.\n *\n * It is the key space that each ROUTE TABLE owns inside a shared path cache. An entry of\n * that cache says which state a path resolves to, and the answer is a pure function of\n * the mappings and the path: two maps built from the SAME mappings resolve every path the\n * same way, and two maps built from different mappings do not. A map with no route for\n * `/settings/x` writes `null`, and a map that DOES hold `/settings/:s` then read that\n * `null` and reported no state for a route of its own.\n *\n * The key therefore names the TABLE, and not the instance. An instance counter kept the\n * two apart as well, and it also gave a server that rebuilds its map for each request a\n * cache that answered nothing: every request opened a key space of its own, and the dead\n * keys of the last one evicted the live entries of this one.\n *\n * Two maps built from the same mappings share the id, which is what a server that\n * rebuilds its map for each request needs, and two maps built from different mappings do\n * not — a map with no route for a path writes `null` for it, and a map that HOLDS one\n * must not read that.\n *\n * A REGISTER of the serialized tables answered this before, and it kept every table\n * string it had seen for the life of the process: a per-tenant table of fifty routes is a\n * few kilobytes, and a bounded register of them still retained megabytes in exactly the\n * per-request case that the cache exists for. A digest retains nothing.\n *\n * ## The collision\n *\n * Two DIFFERENT tables that share a digest share a key space, and the negative entries of\n * one then answer for the other. The digest is 64 bits over the full signature, so a\n * process that built ten thousand distinct route tables carries a chance of about 3 in\n * 10^12 of one collision — far below the chance of the bit flip that would corrupt the\n * cache anyway. This library already identifies by digest: an XMachines id is a Git OID.\n */\nfunction routeTableId(mappings: readonly RouteMapping[]): string {\n\t// FNV-1a, in two 32-bit halves, because a bitwise operator of JavaScript truncates to\n\t// 32 bits and `BigInt` costs an allocation for each character.\n\tlet hashLow = 0x811c9dc5;\n\tlet hashHigh = 0x811c9dc5;\n\tfor (const { stateId, path } of mappings) {\n\t\t// The ORDER is significant: it gives the priority when more than one pattern matches,\n\t\t// so the separators below keep `[{a, /x}, {b, /y}]` apart from `[{a, /x/b}, {/y}]`.\n\t\tconst entry = `${stateId}\\u0000${path}\\u0001`;\n\t\tfor (let index = 0; index < entry.length; index += 1) {\n\t\t\tconst code = entry.charCodeAt(index);\n\t\t\thashLow = Math.imul(hashLow ^ code, 0x01000193) >>> 0;\n\t\t\thashHigh = Math.imul(hashHigh ^ (code + index), 0x01000193) >>> 0;\n\t\t}\n\t}\n\treturn `${hashLow.toString(36)}.${hashHigh.toString(36)}`;\n}\n\n/**\n * The shared base class of the route map for both directions.\n *\n * Every framework adapter uses this class as its route map. An adapter adds no logic\n * of its own, and it inherits the complete public API from here.\n *\n * **The strategy of a lookup:**\n * - A static path, without a `:param` → a `Map` lookup in O(1)\n * - A dynamic path → a scan of the bucket index in O(k), with `URLPattern`, where\n *   `k` is the number of the routes with the same first path segment\n * - The class keeps each result of a first match in an LRU cache. The default cache\n *   holds 1001 entries at most, and the `pathCache` constructor option replaces it\n *\n * **The syntax of a pattern:** the whole URLPattern pathname grammar. The forms used most\n * often are:\n * - `:param` — a necessary segment. It matches exactly one segment without a `/`\n * - `:param?` — an optional segment. It matches zero segments or one segment without a `/`\n * - `*` — a wildcard. It matches each number of segments, as URLPattern defines\n *\n * A `{…}` group, a `:param(\\d+)` constraint, a `+` modifier and a `\\:` escape are read\n * too. The [routing guide](../../docs/guides/routing.md) states every form, the prefix\n * rule, and the one divergence from the standard: a param name of this library can hold a\n * hyphen.\n *\n * **The forms of a stateId:** you can register a stateId, and you can look one up,\n * in the form `\"#stateId\"` or in the form `\"stateId\"`. `RouteMap` makes the\n * canonical form itself. `getStateIdByPath` returns the stateId exactly as you\n * registered it, and `getPathByStateId` accepts both forms. A registration of the\n * same stateId in both forms gives one entry, and the later registration wins for\n * the lookup in the other direction.\n *\n * @example\n * ```typescript\n * import { RouteMap } from \"@xmachines/play-router\";\n *\n * const map = new RouteMap([\n *   { stateId: \"home\",     path: \"/\" },\n *   { stateId: \"profile\",  path: \"/profile/:userId\" },\n *   { stateId: \"settings\", path: \"/settings/:section?\" },\n * ]);\n *\n * map.getStateIdByPath(\"/\");               // \"home\"\n * map.getStateIdByPath(\"/profile/123\");    // \"profile\"\n * map.getStateIdByPath(\"/settings\");       // \"settings\"\n * map.getStateIdByPath(\"/unknown\");        // null\n *\n * map.getPathByStateId(\"profile\");         // \"/profile/:userId\"\n * map.getPathByStateId(\"missing\");         // null\n * ```\n */\nexport class RouteMap {\n\t/** The key is the canonical stateId form, which is bare and without a `#`. */\n\tprivate stateIdToPath: Map<string, string>;\n\tprivate pathToStateId: Map<string, string>;\n\tprivate patternBuckets: Map<\n\t\tstring,\n\t\tArray<{ pattern: URLPatternLike; stateId: string; order: number }>\n\t>;\n\tprivate pathMatchCache: KeyValueCache<string | null>;\n\t/** The key space of this ROUTE TABLE inside {@link pathMatchCache}, which a caller may share. */\n\tprivate readonly pathCacheKey: (path: string) => string;\n\t/**\n\t * The caches that every parse and every compilation of this map reads.\n\t *\n\t * Each default stays SHARED on purpose. A map that built one of its own would keep its\n\t * patterns out of the cache that `find-route.ts` and `router-sync.ts` read, so the same\n\t * pattern would parse two times. A caller that wants the isolation passes a cache.\n\t */\n\tprivate compileOptions: CompileOptions;\n\n\t/**\n\t * Builds a route map from an array of the mappings between a state ID and a path.\n\t *\n\t * The constructor puts each static path, which holds no `:param`, into a `Map` for a\n\t * lookup in O(1). It compiles each parameterized path to a `URLPattern`, and it\n\t * groups the patterns into the buckets of the first segment. The selection of the\n\t * candidates is therefore efficient.\n\t *\n\t * @param mappings - The array of the `{ stateId, path }` entries. The order gives the\n\t *   priority when more than one pattern can match the same path.\n\t * @param options - See {@link RouteMapOptions}. A map holds TWO caches, so no option is\n\t *   named `cache`: each one names the cache that it carries.\n\t */\n\tconstructor(mappings: RouteMapping[], options: RouteMapOptions = {}) {\n\t\tconst { pathCache, ...compileOptions } = options;\n\t\tthis.compileOptions = compileOptions;\n\t\tthis.stateIdToPath = new Map();\n\t\tthis.pathToStateId = new Map();\n\t\tthis.patternBuckets = new Map();\n\t\tthis.pathMatchCache = pathCache ?? createLruCache<string | null>(DEFAULT_PATH_CACHE_SIZE);\n\t\t// A map that BUILDS its own cache owns every key in it, and a prefix would only make\n\t\t// each key longer. A map that RECEIVES one shares it, so its keys carry the prefix.\n\t\tif (pathCache === undefined) {\n\t\t\tthis.pathCacheKey = (path) => path;\n\t\t} else {\n\t\t\tconst prefix = `${routeTableId(mappings)}\\u0002`;\n\t\t\tthis.pathCacheKey = (path) => prefix + path;\n\t\t}\n\t\tlet patternOrder = 0;\n\n\t\tfor (const { stateId, path } of mappings) {\n\t\t\t// The key is the canonical bare form. Therefore getPathByStateId accepts\n\t\t\t// \"#stateId\" and also \"stateId\". The map keeps the registered form for its return\n\t\t\t// values.\n\t\t\tthis.stateIdToPath.set(canonicalStateIdKey(stateId), path);\n\n\t\t\t// ONE parse answers both questions: is the path a pattern, and which bucket does\n\t\t\t// it belong to. The key comes from that parse, and not from a split of the raw\n\t\t\t// string. A pattern such as `/books{/:id}?` keeps the literal first segment\n\t\t\t// `books`, and a split on `/` read the key `books{` and put the route in a bucket\n\t\t\t// that the path `/books/1` reaches never.\n\t\t\tconst parsed = parsePattern(path, this.compileOptions);\n\t\t\tif (parsed.parameterized) {\n\t\t\t\tconst bucketKey = parsed.indexKey;\n\t\t\t\tconst bucket = this.patternBuckets.get(bucketKey) ?? [];\n\t\t\t\ttry {\n\t\t\t\t\tbucket.push({\n\t\t\t\t\t\tpattern: getCompiledPattern(path, this.compileOptions),\n\t\t\t\t\t\tstateId,\n\t\t\t\t\t\torder: patternOrder++,\n\t\t\t\t\t});\n\t\t\t\t} catch (err) {\n\t\t\t\t\t// `getCompiledPattern` reports an invalid pattern itself, and with the REASON\n\t\t\t\t\t// when it knows one. A second wrap here replaced that message with the\n\t\t\t\t\t// generic one, so the explanation reached the caller never.\n\t\t\t\t\tif (err instanceof InvalidRoutePatternError) throw err;\n\t\t\t\t\tthrow new InvalidRoutePatternError(path, { cause: err });\n\t\t\t\t}\n\t\t\t\tthis.patternBuckets.set(bucketKey, bucket);\n\t\t\t} else {\n\t\t\t\tthis.pathToStateId.set(path, stateId);\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * Resolves a URL path to its state ID.\n\t *\n\t * The method removes the query string and the hash fragment before the match. It\n\t * tries an exact lookup in O(1) first, then it uses the pattern match on the bucket\n\t * index. It keeps each result of a first pattern match in the cache.\n\t *\n\t * @param path - The URL pathname. It can hold a query and a hash, for example `\"/profile/123?ref=nav\"`\n\t * @returns The state ID of the path, or `null` when no route matches\n\t *\n\t * @example\n\t * ```typescript\n\t * map.getStateIdByPath(\"/profile/123\");  // \"profile\"\n\t * map.getStateIdByPath(\"/unknown\");      // null\n\t * ```\n\t */\n\tgetStateIdByPath(path: string): string | null {\n\t\t// Remove the query string and the hash fragment before the match. `splitLocation` is\n\t\t// the ONE answer to \"where does a pathname end\", and `RouterBridgeBase`,\n\t\t// `framework-params.ts` and `sanitizePathname` read it too, so the four cannot\n\t\t// disagree. Two splits allocated two arrays of every part on the hottest lookup of\n\t\t// the library, and this function then read one element of each.\n\t\tconst cleanPath = splitLocation(path).pathname;\n\n\t\tconst exactMatch = this.pathToStateId.get(cleanPath);\n\t\tif (exactMatch !== undefined) return exactMatch;\n\n\t\tconst cacheKey = this.pathCacheKey(cleanPath);\n\t\tconst cachedMatch = this.pathMatchCache.get(cacheKey);\n\t\tif (cachedMatch !== undefined) return cachedMatch;\n\n\t\tconst candidates = getCandidates(this.patternBuckets, getIndexKey(cleanPath));\n\t\tfor (const { pattern, stateId } of candidates) {\n\t\t\tconst match = pattern.exec({ pathname: cleanPath });\n\t\t\tif (match) {\n\t\t\t\tthis.pathMatchCache.set(cacheKey, stateId);\n\t\t\t\treturn stateId;\n\t\t\t}\n\t\t}\n\n\t\tthis.pathMatchCache.set(cacheKey, null);\n\t\treturn null;\n\t}\n\n\t/**\n\t * Returns the path pattern of a state ID.\n\t *\n\t * The method accepts the stateId in the form `\"#stateId\"` and in the form\n\t * `\"stateId\"`, and the form of the registration has no effect. The method makes the\n\t * canonical form itself. Therefore a consumer tries never both forms.\n\t *\n\t * @param stateId - The state ID of the state machine, for example `\"profile\"` or `\"#settings\"`\n\t * @returns The registered path pattern, or `null` when the state ID is unknown\n\t *\n\t * @example\n\t * ```typescript\n\t * map.getPathByStateId(\"profile\");   // \"/profile/:userId\"\n\t * map.getPathByStateId(\"#profile\");  // \"/profile/:userId\" — the same entry\n\t * map.getPathByStateId(\"missing\");   // null\n\t * ```\n\t */\n\tgetPathByStateId(stateId: string): string | null {\n\t\treturn this.stateIdToPath.get(canonicalStateIdKey(stateId)) ?? null;\n\t}\n}\n"],"mappings":"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"}