@xmachines/play-router 1.0.0-beta.8 → 1.0.0

package/dist/router-sync.d.ts

@@ -0,0 +1,95 @@
+import type { PlayRouteEvent } from "./types.js";
+export interface RouteMatch {
+    to: string | null | undefined;
+    params?: Record<string, string>;
+}
+export interface BuildPlayRouteEventOptions {
+    pathname: string;
+    search?: string | undefined;
+    match: (sanitizedPathname: string) => RouteMatch;
+}
+export interface RouterStateIdMap {
+    getStateIdByPath(path: string): string | null | undefined;
+    getPathByStateId(id: string): string | null | undefined;
+}
+/**
+ * Match a sanitized pathname against a route map and extract any matched params.
+ *
+ * Shared by low-level and framework router sync paths to keep route-map matching
+ * semantics aligned.
+ */
+export declare function matchRouteMap(pathname: string, routeMap: RouterStateIdMap, extractParams: (pathname: string, stateId: string) => Record<string, string>): RouteMatch;
+/**
+ * Normalize a pathname before route-map lookup.
+ *
+ * This strips query/hash fragments, collapses duplicate slashes, and rejects
+ * implausibly long paths that should never enter route resolution.
+ *
+ * Returns `null` for paths exceeding 2048 characters (malformed/adversarial input).
+ * Adapters that bypass `RouterBridgeBase.syncActorFromRouter()` (e.g. `VueRouterBridge`)
+ * must call this function directly and return early on `null` to apply the same
+ * defense-in-depth security guarantee as the shared base class.
+ *
+ * @param pathname - Raw path string from router navigation event.
+ * @returns Normalized path string, or `null` if the path is malformed/too long.
+ *
+ * @example
+ * ```typescript
+ * import { sanitizePathname } from "@xmachines/play-router";
+ *
+ * const clean = sanitizePathname(to.path);
+ * if (clean === null) return; // reject malformed path
+ * ```
+ */
+export declare function sanitizePathname(pathname: string): string | null;
+/**
+ * Extract named path parameters from a URL using the URLPattern API.
+ *
+ * Takes the pattern string directly — use this when the pattern is already known.
+ * For extraction via a state ID lookup, see `RouterBridgeBase.extractParams`.
+ *
+ * Undefined values (unmatched optional segments, e.g. `/settings` against
+ * `/settings/:section?`) are omitted from the returned object.
+ *
+ * The pattern is normalized with the same rules `RouteMap` uses for matching
+ * (hyphenated names like `:cat-id` become `:cat_id` for URLPattern), and the
+ * extracted group names are mapped back to the original param names, so
+ * `/docs/123` against `/docs/:cat-id` yields `{ "cat-id": "123" }`.
+ *
+ * Values are percent-decoded (`john%20doe` → `john doe`), matching framework
+ * router semantics (e.g. vue-router). Malformed sequences are kept raw.
+ *
+ * @param pathname - The concrete URL pathname (e.g. `/profile/alice`)
+ * @param pattern  - The URL pattern template (e.g. `/profile/:username`)
+ * @returns A record of extracted parameter values, or `{}` for static patterns.
+ * @throws {URLPatternUnavailableError} When `URLPattern` is absent and the pattern is parameterized.
+ *
+ * @example
+ * ```typescript
+ * import { extractRouteParams } from "@xmachines/play-router";
+ *
+ * extractRouteParams("/profile/alice", "/profile/:username")
+ * // → { username: "alice" }
+ *
+ * extractRouteParams("/settings", "/settings/:section?")
+ * // → {}  (optional param absent — not included)
+ * ```
+ */
+export declare function extractRouteParams(pathname: string, pattern: string): Record<string, string>;
+/**
+ * Parse a URL search string into the plain object shape expected by
+ * `play.route` events.
+ */
+export declare function extractQuery(search: string): Record<string, string>;
+/**
+ * Build a normalized `play.route` event from raw router/browser input.
+ *
+ * Both `connectRouter()` (from `@xmachines/play-dom-router`) and `RouterBridgeBase`
+ * use this helper so low-level and framework adapters share the same pathname
+ * sanitization, route matching, and query extraction behavior.
+ */
+export declare function buildPlayRouteEvent(options: BuildPlayRouteEventOptions): {
+    pathname: string;
+    event: PlayRouteEvent;
+} | null;
+//# sourceMappingURL=router-sync.d.ts.map

package/dist/router-sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"router-sync.d.ts","sourceRoot":"","sources":["../src/router-sync.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAWjD,MAAM,WAAW,UAAU;IAC1B,EAAE,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAC9B,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAChC;AAED,MAAM,WAAW,0BAA0B;IAC1C,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,KAAK,EAAE,CAAC,iBAAiB,EAAE,MAAM,KAAK,UAAU,CAAC;CACjD;AAED,MAAM,WAAW,gBAAgB;IAChC,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAC1D,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;CACxD;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAC5B,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,gBAAgB,EAC1B,aAAa,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC1E,UAAU,CAUZ;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAKhE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAmB5F;AAcD;;;GAGG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAUnE;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAClC,OAAO,EAAE,0BAA0B,GACjC;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,cAAc,CAAA;CAAE,GAAG,IAAI,CAqBpD"}

package/dist/router-sync.js

@@ -0,0 +1,161 @@
+import { getURLPatternCtor, getNormalizedParamNameMap, getCompiledPattern, isParameterizedPattern, } from "./url-pattern-utils.js";
+import { URLPatternUnavailableError } from "./errors.js";
+/**
+ * Match a sanitized pathname against a route map and extract any matched params.
+ *
+ * Shared by low-level and framework router sync paths to keep route-map matching
+ * semantics aligned.
+ */
+export function matchRouteMap(pathname, routeMap, extractParams) {
+    const stateId = routeMap.getStateIdByPath(pathname);
+    if (!stateId) {
+        return { to: null, params: {} };
+    }
+    return {
+        to: stateId,
+        params: extractParams(pathname, stateId),
+    };
+}
+/**
+ * Normalize a pathname before route-map lookup.
+ *
+ * This strips query/hash fragments, collapses duplicate slashes, and rejects
+ * implausibly long paths that should never enter route resolution.
+ *
+ * Returns `null` for paths exceeding 2048 characters (malformed/adversarial input).
+ * Adapters that bypass `RouterBridgeBase.syncActorFromRouter()` (e.g. `VueRouterBridge`)
+ * must call this function directly and return early on `null` to apply the same
+ * defense-in-depth security guarantee as the shared base class.
+ *
+ * @param pathname - Raw path string from router navigation event.
+ * @returns Normalized path string, or `null` if the path is malformed/too long.
+ *
+ * @example
+ * ```typescript
+ * import { sanitizePathname } from "@xmachines/play-router";
+ *
+ * const clean = sanitizePathname(to.path);
+ * if (clean === null) return; // reject malformed path
+ * ```
+ */
+export function sanitizePathname(pathname) {
+    if (pathname.length > 2048)
+        return null;
+    const withoutQuery = pathname.split("?")[0];
+    const withoutHash = withoutQuery.split("#")[0];
+    return withoutHash.replace(/\/+/g, "/");
+}
+/**
+ * Extract named path parameters from a URL using the URLPattern API.
+ *
+ * Takes the pattern string directly — use this when the pattern is already known.
+ * For extraction via a state ID lookup, see `RouterBridgeBase.extractParams`.
+ *
+ * Undefined values (unmatched optional segments, e.g. `/settings` against
+ * `/settings/:section?`) are omitted from the returned object.
+ *
+ * The pattern is normalized with the same rules `RouteMap` uses for matching
+ * (hyphenated names like `:cat-id` become `:cat_id` for URLPattern), and the
+ * extracted group names are mapped back to the original param names, so
+ * `/docs/123` against `/docs/:cat-id` yields `{ "cat-id": "123" }`.
+ *
+ * Values are percent-decoded (`john%20doe` → `john doe`), matching framework
+ * router semantics (e.g. vue-router). Malformed sequences are kept raw.
+ *
+ * @param pathname - The concrete URL pathname (e.g. `/profile/alice`)
+ * @param pattern  - The URL pattern template (e.g. `/profile/:username`)
+ * @returns A record of extracted parameter values, or `{}` for static patterns.
+ * @throws {URLPatternUnavailableError} When `URLPattern` is absent and the pattern is parameterized.
+ *
+ * @example
+ * ```typescript
+ * import { extractRouteParams } from "@xmachines/play-router";
+ *
+ * extractRouteParams("/profile/alice", "/profile/:username")
+ * // → { username: "alice" }
+ *
+ * extractRouteParams("/settings", "/settings/:section?")
+ * // → {}  (optional param absent — not included)
+ * ```
+ */
+export function extractRouteParams(pathname, pattern) {
+    const Ctor = getURLPatternCtor();
+    if (!Ctor)
+        throw new URLPatternUnavailableError();
+    if (!isParameterizedPattern(pattern))
+        return {};
+    // Compile with the SAME normalization RouteMap uses for matching — otherwise
+    // URLPattern parses ":cat-id" as group ":cat" + literal "-id" and extraction
+    // disagrees with the map that matched the path in the first place.
+    const urlPattern = getCompiledPattern(pattern, Ctor);
+    const match = urlPattern.exec({ pathname });
+    if (!match?.pathname.groups)
+        return {};
+    // Map normalized group names (":cat_id") back to the original param names ("cat-id").
+    const nameMap = getNormalizedParamNameMap(pattern);
+    const params = {};
+    for (const [key, value] of Object.entries(match.pathname.groups)) {
+        if (value !== undefined) {
+            params[nameMap.get(key) ?? key] = decodeParamValue(value); // nosemgrep: gitlab.eslint.detect-object-injection
+        }
+    }
+    return params;
+}
+/**
+ * Percent-decode a URLPattern group value, keeping the raw value when the
+ * sequence is malformed (`decodeURIComponent` would throw `URIError`).
+ */
+function decodeParamValue(value) {
+    try {
+        return decodeURIComponent(value);
+    }
+    catch {
+        return value;
+    }
+}
+/**
+ * Parse a URL search string into the plain object shape expected by
+ * `play.route` events.
+ */
+export function extractQuery(search) {
+    try {
+        const params = {};
+        new URLSearchParams(search).forEach((value, key) => {
+            params[key] = value; // nosemgrep: gitlab.eslint.detect-object-injection
+        });
+        return params;
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Build a normalized `play.route` event from raw router/browser input.
+ *
+ * Both `connectRouter()` (from `@xmachines/play-dom-router`) and `RouterBridgeBase`
+ * use this helper so low-level and framework adapters share the same pathname
+ * sanitization, route matching, and query extraction behavior.
+ */
+export function buildPlayRouteEvent(options) {
+    const pathname = sanitizePathname(options.pathname);
+    if (pathname === null)
+        return null;
+    const match = options.match(pathname);
+    if (!match.to)
+        return null;
+    // Single canonicalization point for the emitted event shape: `play.route`
+    // events always carry a '#'-prefixed target. Route maps may legitimately
+    // register (and return) bare stateIds — RouteMap preserves the registered
+    // form — so the event target is formatted here, and only here.
+    const to = match.to.startsWith("#") ? match.to : `#${match.to}`;
+    return {
+        pathname,
+        event: {
+            type: "play.route",
+            to,
+            params: match.params ?? {},
+            query: extractQuery(options.search ?? ""),
+        },
+    };
+}
+//# sourceMappingURL=router-sync.js.map

package/dist/router-sync.js.map

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

package/dist/types.d.ts

@@ -1,4 +1,30 @@
-import type { StateNode } from "xstate";
+import type { Graph } from "@statelyai/graph";
+import type { Signal } from "@xmachines/play-signals";
+import type { PlaySpec } from "@xmachines/play-actor";
+/**
+ * Data attached to each node in the machine graph representation.
+ * Captures the essential state metadata needed for route extraction and queries.
+ */
+export interface MachineNodeData {
+    /** XState state ID (e.g., "test.dashboard.overview") */
+    stateId: string;
+    /** State type from XState */
+    type: "atomic" | "compound" | "parallel" | "final" | "history";
+    /** Original state meta object */
+    meta?: Record<string, unknown>;
+    /** Extracted route path from meta.route (string form) */
+    route?: string;
+}
+/**
+ * Data attached to each edge in the machine graph representation.
+ * Captures transition event and guard information.
+ */
+export interface MachineEdgeData {
+    /** The event type that triggers this transition */
+    eventType: string;
+    /** String representation of guard (if any) */
+    guardType?: string;
+}
 /**
  * Routing protocol type definitions for @xmachines/play-router
  *
@@ -18,17 +44,6 @@ export interface RouteObject {
  * Route metadata from state machine `meta.route` field.
  */
 export type RouteMetadata = string | RouteObject;
-/**
- * Represents a visit to a state node during graph crawling
- */
-export interface StateVisit {
-    /** The state node being visited */
-    node: StateNode;
-    /** Path from root to this state (e.g., ['dashboard', 'overview']) */
-    path: string[];
-    /** Parent state node (null for root) */
-    parent: StateNode | null;
-}
 /**
  * Extracted route information from a state node
  */
@@ -57,9 +72,16 @@ export interface RouteInfo {
 export interface RouteNode {
     /** Unique identifier (state ID) */
     id: string;
-    /** Route path segment (relative or absolute) */
+    /**
+     * The raw route path segment as declared in `meta.route` — may be relative (e.g. `"overview"`)
+     * or absolute (e.g. `"/dashboard"`). Do not use this for URL matching; use `fullPath` instead.
+     */
     path: string;
-    /** Full resolved path from root */
+    /**
+     * The fully resolved absolute path from the root (e.g. `"/dashboard/overview"`).
+     * Always use `fullPath` for browser URL matching and route map construction.
+     * `createRouteMapFromTree` and `createRouteMap` both use this field.
+     */
     fullPath: string;
     /** Route pattern with parameters (e.g., /profile/:userId) if path contains params */
     pattern?: string;
@@ -75,7 +97,7 @@ export interface RouteNode {
     /** Parent route (null for root) */
     parent: RouteNode | null;
     /** Original meta.route metadata */
-    metadata: unknown;
+    metadata: RouteMetadata;
 }
 /**
  * Complete route tree with lookup maps
@@ -97,6 +119,18 @@ export interface RouteTree {
      * Used to look up state ID from URL path for play.route event targeting
      */
     byPath: Map<string, RouteNode>;
+    /**
+     * Graph representation of the state machine for advanced queries.
+     * Populated by extractMachineRoutes() — use for hierarchy queries, reachability checks,
+     * and transition-aware navigation via @statelyai/graph algorithms.
+     *
+     * @example
+     * ```typescript
+     * import { getSuccessors, hasPath } from "@statelyai/graph";
+     * const successors = getSuccessors(tree.graph!, "myMachine.home");
+     * ```
+     */
+    graph?: Graph<MachineNodeData, MachineEdgeData>;
 }
 /**
  * Enhanced routing event with parameter and query support
@@ -116,7 +150,7 @@ export interface RouteTree {
  *
  * @param type - Event discriminator (always "play.route")
  * @param to - Target state ID with # prefix (e.g., '#home', '#profile')
- * @param params - Merged path + query parameters (path parameters win conflicts)
+ * @param params - Path-only route parameters extracted from the URL path (e.g., `{ userId: '123' }` from `/profile/123`). Query parameters are kept separate in `query`.
  * @param query - Query parameters only (isolated from path params)
  * @param match - Full URLPattern match result for debugging/observability (optional)
  *
@@ -165,14 +199,14 @@ export interface RouteTree {
  * const event: PlayRouteEvent = {
  *   type: 'play.route',
  *   to: '#settings',
- *   params: { section: 'profile' },  // Merged: path + query
+ *   params: { section: 'profile' },  // Path-only route parameter
  *   query: { tab: 'security' }        // Query-only
  * };
  * actor.send(event);
  * // Resolves to route: /settings/profile?tab=security
  * ```
  *
- * @see {@link https://gitlab.com/xmachin-es/rfc/-/blob/main/src/play-v1.md | RFC Play v1}
+ * @see [Play RFC](../../docs/rfc/play.md)
  *
  * @remarks
  * Use `play.route` when you need parameter-aware navigation with the `route: {}`
@@ -187,10 +221,76 @@ export interface PlayRouteEvent {
     readonly match?: unknown;
     [key: string]: unknown;
 }
+/**
+ * Minimal actor interface required by `RouterBridgeBase` and all framework router
+ * adapters.
+ *
+ * Using this interface instead of `AbstractActor<AnyActorLogic> & Routable` lets
+ * `RouterBridgeBase.actor.send` be typed to accept `PlayRouteEvent` directly —
+ * eliminating the unsafe `(actor.send as (e: PlayRouteEvent) => void)` cast that
+ * existed when the actor was typed with the weaker `EventObject` constraint.
+ *
+ * All `AbstractActor` subclasses satisfy this interface structurally because:
+ * - `AbstractActor` implements `send(event: TEvent): void` where `TEvent` accepts
+ *   any `EventObject`, so `PlayRouteEvent` (a subtype) is always accepted.
+ * - `Routable` provides `currentRoute` and `initialRoute`.
+ *
+ * @example
+ * ```typescript
+ * import type { RoutableActor } from "@xmachines/play-router";
+ *
+ * class MyBridge extends RouterBridgeBase {
+ *   constructor(actor: RoutableActor, routeMap: RouteMap) {
+ *     super(actor, routeMap);
+ *   }
+ * }
+ * ```
+ */
+export interface RoutableActor {
+    /** TC39 Signal exposing the actor's current URL path (or state ID). */
+    readonly currentRoute: Signal.Computed<string | null>;
+    /**
+     * The route derived from the machine's initial state — fixed at construction.
+     * Router bridges compare this against the browser URL to distinguish a deep-link
+     * (router wins) from a session restore (actor wins).
+     */
+    readonly initialRoute: string | null;
+    /** Send a route navigation event to the actor. */
+    send(event: PlayRouteEvent): void;
+}
+/**
+ * Full actor shape used by `PlayRouterProvider` components across all framework
+ * adapters (`play-solid-router`, `play-vue-router`, `play-react-router`, and the
+ * adapters built on the shared framework-router bridge bases).
+ *
+ * Extends `RoutableActor` with `currentView` — the provider renders the current
+ * view spec in addition to synchronizing routes, so it needs both capabilities.
+ *
+ * - Use `RoutableActor` when only routing is needed (e.g. `RouterBridgeBase` subclasses,
+ *   `connectRouter`).
+ * - Use `PlayActor` when the component also renders the current view spec
+ *   (e.g. `PlayRouterProvider` renderer callback parameter, `PlayRenderer`).
+ *
+ * All `AbstractActor` subclasses that implement both `Routable` and `Viewable`
+ * satisfy this interface structurally.
+ *
+ * @example
+ * ```typescript
+ * import type { PlayActor } from "@xmachines/play-router";
+ *
+ * function MyRouterProvider({ actor }: { actor: PlayActor }) {
+ *   // access actor.currentRoute (routing) and actor.currentView (rendering)
+ * }
+ * ```
+ */
+export interface PlayActor extends RoutableActor {
+    /** TC39 Signal exposing the actor's current view spec, or `null` when inactive. */
+    readonly currentView: Signal.State<PlaySpec | null>;
+}
 /**
  * RouterBridge interface for runtime infrastructure adapters
  *
- * Defines the lifecycle connection between Infrastructure (e.g., TanStack Router) and
+ * Defines the lifecycle connection between Infrastructure (e.g., a framework router) and
  * the Actor. Infrastructure "bridges" to the Actor by observing its signals and
  * managing its own lifecycle accordingly.
  *
@@ -199,12 +299,12 @@ export interface PlayRouteEvent {
  * (currentRoute, currentView, state) and reflects changes without making state decisions.
  *
  * @example
- * TanStack Router bridge implementation
+ * Framework router bridge implementation
  * ```typescript
  * import type { RouterBridge } from "@xmachines/play-router";
  * import { Signal } from "@xmachines/play-signals";
  *
- * class TanStackRouterBridge implements RouterBridge {
+ * class MyRouterBridge implements RouterBridge {
  *   private watcher: Signal.Watcher | null = null;
  *
  *   async connect(): Promise<void> {
@@ -224,7 +324,7 @@ export interface PlayRouteEvent {
  * }
  * ```
  *
- * @see {@link https://gitlab.com/xmachin-es/rfc/-/blob/main/src/play-v1.md | RFC Play v1 - Invariant INV-04}
+ * @see [Play RFC](../../docs/rfc/play.md) - Invariant INV-04
  */
 export interface RouterBridge {
     /**
@@ -259,4 +359,45 @@ export interface RouterBridge {
      */
     disconnect(): void | Promise<void>;
 }
+/**
+ * Minimal window interface required by adapters that subscribe to DOM events
+ * (e.g. `hashchange`). Injectable for SSR and testing — pass a mock instead of
+ * the global `window` when the DOM is unavailable.
+ *
+ * Defined structurally (no `Window` reference) so this package compiles without
+ * the DOM lib.
+ *
+ * @example
+ * ```typescript
+ * // Normal usage — global window (default)
+ * connectRouter({ actor, routeMap });
+ *
+ * // SSR / test — injected mock
+ * const mockWin: WindowLike = { addEventListener: vi.fn(), removeEventListener: vi.fn() };
+ * connectRouter({ actor, routeMap, window: mockWin });
+ * ```
+ */
+export interface WindowLike {
+    addEventListener(type: string, listener: (event: Event) => void): void;
+    removeEventListener(type: string, listener: (event: Event) => void): void;
+}
+/**
+ * Minimal location interface required by adapters that read the current URL at
+ * `connect()` time. Injectable for SSR and testing — pass a mock instead of the
+ * global `location` when the DOM is unavailable.
+ *
+ * Defined structurally (no `Location` reference) so this package compiles without
+ * the DOM lib.
+ *
+ * @example
+ * ```typescript
+ * // SSR / test — injected mock
+ * const mockLoc: LocationLike = { pathname: "/dashboard", search: "?tab=posts" };
+ * connectRouter({ actor, routeMap, location: mockLoc });
+ * ```
+ */
+export interface LocationLike {
+    readonly pathname: string;
+    readonly search: string;
+}
 //# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC;AAExC;;;;;GAKG;AAEH;;GAEG;AACH,MAAM,WAAW,WAAW;IAC3B,8CAA8C;IAC9C,IAAI,EAAE,MAAM,CAAC;IACb,0DAA0D;IAC1D,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,WAAW,CAAC;AAEjD;;GAEG;AACH,MAAM,WAAW,UAAU;IAC1B,mCAAmC;IACnC,IAAI,EAAE,SAAS,CAAC;IAChB,qEAAqE;IACrE,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,wCAAwC;IACxC,MAAM,EAAE,SAAS,GAAG,IAAI,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,SAAS;IACzB,mDAAmD;IACnD,OAAO,EAAE,MAAM,CAAC;IAChB,oCAAoC;IACpC,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,2CAA2C;IAC3C,SAAS,EAAE,MAAM,CAAC;IAClB,0FAA0F;IAC1F,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,qDAAqD;IACrD,UAAU,EAAE,OAAO,CAAC;IACpB;;;OAGG;IACH,QAAQ,EAAE,OAAO,CAAC;IAClB,8BAA8B;IAC9B,QAAQ,EAAE,aAAa,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,SAAS;IACzB,mCAAmC;IACnC,EAAE,EAAE,MAAM,CAAC;IACX,gDAAgD;IAChD,IAAI,EAAE,MAAM,CAAC;IACb,mCAAmC;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,qFAAqF;IACrF,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,yCAAyC;IACzC,OAAO,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,QAAQ,EAAE,OAAO,CAAC;IAClB,mBAAmB;IACnB,QAAQ,EAAE,SAAS,EAAE,CAAC;IACtB,mCAAmC;IACnC,MAAM,EAAE,SAAS,GAAG,IAAI,CAAC;IACzB,mCAAmC;IACnC,QAAQ,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,SAAS;IACzB,sBAAsB;IACtB,IAAI,EAAE,SAAS,CAAC;IAChB;;;OAGG;IACH,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAClC;;;OAGG;IACH,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgFG;AACH,MAAM,WAAW,cAAc;IAC9B,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxC,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IACzB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACvB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,MAAM,WAAW,YAAY;IAC5B;;;;;;;;;;;;;;OAcG;IACH,OAAO,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEhC;;;;;;;;;;;;;OAaG;IACH,UAAU,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACnC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,117 @@
+/**
+ * Shared URLPattern utilities — internal module, NOT exported from index.ts
+ *
+ * Provides the common URLPattern plumbing shared by:
+ * - `create-route-map.ts`
+ * - `base-route-map.ts`
+ * - `find-route.ts`
+ * - `router-bridge-base.ts`
+ *
+ * URLPattern is accessed via globalThis — consumers must load a polyfill on
+ * environments without native support (Node < 24, older browsers).
+ *
+ * @internal
+ */
+/**
+ * Minimal structural type for the subset of URLPattern we use.
+ * Avoids a hard dependency on the full URLPattern type declaration.
+ */
+export type URLPatternLike = {
+    exec(input: {
+        pathname: string;
+    }): {
+        pathname: {
+            groups: Record<string, string | undefined>;
+        };
+    } | null;
+    test(input: {
+        pathname: string;
+    }): boolean;
+};
+/** Constructor type for URLPatternLike instances. */
+export type URLPatternCtor = new (init: {
+    pathname: string;
+}) => URLPatternLike;
+/**
+ * Retrieve the URLPattern constructor from `globalThis`, or `undefined` if
+ * it is not available (Node < 24, older browsers without a polyfill).
+ */
+export declare function getURLPatternCtor(): URLPatternCtor | undefined;
+/**
+ * Check whether a route path is a parameterized pattern rather than a concrete URL.
+ *
+ * A pattern contains `:param` segments (required or optional) and/or the `*`
+ * wildcard — both require URLPattern matching and carry no concrete values, so
+ * they can never be pushed to a browser URL verbatim.
+ *
+ * This is THE single source of truth for "is this path a pattern?" — used by
+ * `RouteMap` to decide static-map vs pattern-bucket indexing and by
+ * `RouterBridgeBase.resolveNavigationPath` to skip non-navigable routes, so the
+ * two checks can never drift apart.
+ *
+ * @param path - URL path or route pattern string (e.g. `/profile/:userId`, `/docs/*`)
+ * @returns `true` if the path contains `:param` or `*` pattern syntax
+ */
+export declare function isParameterizedPattern(path: string): boolean;
+/**
+ * Normalize a route path so its parameter names are valid URLPattern identifiers.
+ *
+ * URLPattern requires parameter names to be valid JS identifiers (no hyphens).
+ * Hyphenated names like `:cat-id` are replaced with underscored equivalents
+ * (`:cat_id`) for the URLPattern compilation step. Callers that need the captured
+ * group values (not just a match test) must map the normalized group names back to
+ * the original param names via {@link getNormalizedParamNameMap}.
+ *
+ * @example
+ * normalizeParamNames("/docs/:cat-id/:page-num?")
+ * // → "/docs/:cat_id/:page_num?"
+ */
+export declare function normalizeParamNames(path: string): string;
+/**
+ * Build a map from normalized URLPattern group names back to the original
+ * (hyphenated) param names for a route pattern.
+ *
+ * Only params rewritten by {@link normalizeParamNames} appear in the map —
+ * params that are already valid identifiers keep their own name and need no entry.
+ *
+ * @example
+ * getNormalizedParamNameMap("/docs/:cat-id/:plain")
+ * // → Map { "cat_id" → "cat-id" }
+ */
+export declare function getNormalizedParamNameMap(path: string): Map<string, string>;
+/**
+ * Compile a route pattern to a `URLPattern`, reusing the module-level cache.
+ *
+ * The pattern is normalized with {@link normalizeParamNames} before compilation
+ * so hyphenated param names (`:cat-id`) become valid URLPattern identifiers
+ * (`:cat_id`). Callers that extract group values must map the normalized names
+ * back via {@link getNormalizedParamNameMap}.
+ *
+ * Compilation errors from the URLPattern constructor propagate as-is — callers
+ * that need a typed error wrap this in `InvalidRoutePatternError`.
+ *
+ * @param pattern - Route pattern string (e.g. `/profile/:userId`)
+ * @param Ctor - URLPattern constructor retrieved via {@link getURLPatternCtor}
+ */
+export declare function getCompiledPattern(pattern: string, Ctor: URLPatternCtor): URLPatternLike;
+/**
+ * Compute the bucket index key for a given path or pattern.
+ *
+ * The key is the first path segment (e.g. `"settings"` for `"/settings/:id"`).
+ * Parameterised first segments (`:lang`) fall into the `"*"` wildcard bucket.
+ * The root path `"/"` maps to the key `"/"`.
+ *
+ * @param path - URL path or route pattern string
+ */
+export declare function getIndexKey(path: string): string;
+/**
+ * Merge the named-segment bucket and the wildcard bucket for a given index key,
+ * preserving insertion order (by `order` field).
+ *
+ * @param patternBuckets - Map of bucket key → ordered pattern entries
+ * @param indexKey - First-segment key computed by `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

@@ -0,0 +1 @@
+{"version":3,"file":"url-pattern-utils.d.ts","sourceRoot":"","sources":["../src/url-pattern-utils.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH;;;GAGG;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,qDAAqD;AACrD,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;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE5D;AASD;;;;;;;;;;;;GAYG;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;AAeD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,cAAc,GAAG,cAAc,CAWxF;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"}