@xmachines/play-router 2.0.0-alpha.1 → 2.1.0

package/dist/types.d.ts

@@ -2,146 +2,133 @@ 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.
+ * The data on each node of the graph that represents the machine.
+ * It holds the state metadata that the route extraction and the queries need.
  */
 export interface MachineNodeData {
-    /** XState state ID (e.g., "test.dashboard.overview") */
+    /** The XState state ID, for example "test.dashboard.overview" */
     stateId: string;
-    /** State type from XState */
+    /** The state type of XState */
     type: "atomic" | "compound" | "parallel" | "final" | "history";
-    /** Original state meta object */
+    /** The original meta object of the state */
     meta?: Record<string, unknown>;
-    /** Extracted route path from meta.route (string form) */
+    /** The route path of meta.route, in its string form */
     route?: string;
 }
 /**
- * Data attached to each edge in the machine graph representation.
- * Captures transition event and guard information.
+ * The data on each edge of the graph that represents the machine.
+ * It holds the event of the transition and the information of its guard.
  */
 export interface MachineEdgeData {
-    /** The event type that triggers this transition */
+    /** The event type that starts this transition */
     eventType: string;
     /**
-     * @deprecated Never populated under XState v6: every guard (including
-     * JSON-layer guard names via `createMachineFromConfig`) compiles to a
-     * function, so guard identity is unrecoverable statically. Use
-     * {@link MachineEdgeData.guarded} instead.
+     * The guard as a string, when a guard is present
+     *
+     * @deprecated Will be removed in the next major.
      */
     guardType?: string;
-    /**
-     * True when a guard function gates this transition. XState v6 compiles all
-     * guards to functions (authored predicates, JSON-layer names, and the
-     * route-matching guard synthesized on native route transitions), so only
-     * the presence of a guard — not its identity — is statically knowable.
-     */
-    guarded?: boolean;
-    /**
-     * True when the transition is an XState v6 function transition: the function
-     * acts as its own guard/resolver, so its target and conditionality are
-     * dynamic and unknowable statically (the edge's target falls back to the
-     * source state).
-     */
-    dynamic?: boolean;
 }
 /**
- * Routing protocol type definitions for @xmachines/play-router
+ * The type definitions of the routing protocol of @xmachines/play-router
  *
- * PlayRouteEvent, RouterBridge, RouteMetadata, and RouteObject live here to keep
- * routing concerns separate from the base event protocol in @xmachines/play.
+ * PlayRouteEvent, RouterBridge, RouteMetadata, and RouteObject are here. The routing
+ * therefore stays separate from the base event protocol of @xmachines/play.
  */
 /**
- * Route object with additional metadata.
+ * A route object, with more metadata.
  */
 export interface RouteObject {
-    /** Route path template (e.g., '/user/:id') */
+    /** The template of the route path, for example '/user/:id' */
     path: string;
-    /** Additional route metadata (title, breadcrumb, etc.) */
+    /** The additional metadata of the route: a title, a breadcrumb, and so on */
     [key: string]: unknown;
 }
 /**
- * Route metadata from state machine `meta.route` field.
+ * The route metadata of the `meta.route` field of a state machine.
  */
 export type RouteMetadata = string | RouteObject;
 /**
- * Extracted route information from a state node
+ * The route information of a state node
  */
 export interface RouteInfo {
-    /** State identifier (node.id or path.join('.')) */
+    /** The identifier of the state: node.id, or path.join('.') */
     stateId: string;
-    /** State path segments from root */
+    /** The segments of the state path, from the root */
     statePath: string[];
-    /** Route path extracted from meta.route */
+    /** The route path of meta.route */
     routePath: string;
-    /** Route pattern with parameters (e.g., /profile/:userId) if routePath contains params */
+    /** The route pattern with its parameters, for example /profile/:userId, when routePath holds a parameter */
     pattern?: string;
-    /** Whether route path is absolute (starts with /) */
+    /** It tells you if the route path is absolute, which means that it starts with / */
     isAbsolute: boolean;
     /**
-     * Whether this state is routable (has meta.route)
-     * true = has meta.route, can receive play.route events
+     * It tells you if this state has a route, which means that it has a meta.route field.
+     * true = it has a meta.route field, and it can receive a play.route event
      */
     routable: boolean;
-    /** Original route metadata */
+    /** The original route metadata */
     metadata: RouteMetadata;
 }
 /**
- * Node in the route tree representing a single route
+ * A node of the route tree. It represents one route
  */
 export interface RouteNode {
-    /** Unique identifier (state ID) */
+    /** The unique identifier, which is the state ID */
     id: string;
     /**
-     * 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.
+     * The raw segment of the route path, as `meta.route` declares it. It is relative,
+     * for example `"overview"`, or absolute, for example `"/dashboard"`. Never use it for
+     * a match of a URL: use `fullPath` for that.
      */
     path: string;
     /**
-     * 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.
+     * The complete absolute path from the root, for example `"/dashboard/overview"`.
+     * Always use `fullPath` for a match of a browser URL and for the construction of a
+     * route map. `createRouteMapFromTree` and `createRouteMap` both use this field.
      */
     fullPath: string;
-    /** Route pattern with parameters (e.g., /profile/:userId) if path contains params */
+    /** The route pattern with its parameters, for example /profile/:userId, when path holds a parameter */
     pattern?: string;
-    /** XState state ID this route maps to */
+    /** The XState state ID of this route */
     stateId: string;
     /**
-     * Whether this state is routable (has meta.route)
-     * States with meta.route can receive play.route events
+     * It tells you if this state has a route, which means that it has a meta.route field.
+     * A state with a meta.route field can receive a play.route event
      */
     routable: boolean;
-    /** Child routes */
+    /** The child routes */
     children: RouteNode[];
-    /** Parent route (null for root) */
+    /** The parent route. It is null for the root */
     parent: RouteNode | null;
-    /** Original meta.route metadata */
+    /** The original meta.route metadata */
     metadata: RouteMetadata;
 }
 /**
- * Complete route tree with lookup maps
+ * The complete route tree, with its lookup maps
  *
- * Provides bidirectional mapping between state IDs and URL paths:
- * - byStateId: Maps state IDs to route nodes (for play.route event targeting)
- * - byPath: Maps URL paths to route nodes (for browser navigation)
+ * It gives you the map between a state ID and a URL path, in both directions:
+ * - byStateId: it maps each state ID to its route node, for the target of a play.route event
+ * - byPath: it maps each URL path to its route node, for the browser navigation
  */
 export interface RouteTree {
-    /** Root route node */
+    /** The root node of the routes */
     root: RouteNode;
     /**
-     * Map state ID -> route node
-     * Used to look up URL path from state ID for browser URL sync
+     * The map from a state ID to its route node.
+     * It gives you the URL path of a state ID, for the update of the browser URL
      */
     byStateId: Map<string, RouteNode>;
     /**
-     * Map full path -> route node
-     * Used to look up state ID from URL path for play.route event targeting
+     * The map from a complete path to its route node.
+     * It gives you the state ID of a URL path, for the target of a play.route event
      */
     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.
+     * The graph of the state machine, for an advanced query.
+     * extractMachineRoutes() fills it. Use it for a query of the hierarchy, for a test of
+     * the reachability, and for a navigation that knows the transitions, through the
+     * algorithms of @statelyai/graph.
      *
      * @example
      * ```typescript
@@ -152,31 +139,36 @@ export interface RouteTree {
     graph?: Graph<MachineNodeData, MachineEdgeData>;
 }
 /**
- * Enhanced routing event with parameter and query support
- *
- * Unified routing event used throughout the Play architecture. Supports parameter-aware
- * navigation patterns (e.g., `/profile/:userId`) for dynamic route segments.
- *
- * **Architectural Context:** Implements **Passive Infrastructure (INV-04)** by representing
- * user navigation intent that the Actor evaluates through guards. Infrastructure proposes
- * via `play.route` events, Actor decides via state machine transitions.
- *
- * **Browser Navigation Flow:**
- * 1. Browser fires `popstate`
- * 2. Router adapter resolves URL to route target
- * 3. Adapter sends `PlayRouteEvent` to Actor
- * 4. Actor validates transition via state machine guards
- *
- * @param type - Event discriminator (always "play.route")
- * @param to - Target state ID with # prefix (e.g., '#home', '#profile')
- * @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)
- *
- * @returns N/A - Interface defines event shape only
+ * The routing event, with its parameters and its query
+ *
+ * This is the one routing event of the complete Play architecture. It supports a
+ * navigation that knows the parameters, for example `/profile/:userId`, for a dynamic
+ * route segment.
+ *
+ * **Architectural context:** the event implements **Passive Infrastructure
+ * (INV-04)**, because it holds the navigation intent of the user, and the Actor then
+ * evaluates that intent with its guards. The infrastructure makes a request with a
+ * `play.route` event, and the Actor decides with a transition of its state machine.
+ *
+ * **The flow of a browser navigation:**
+ * 1. The browser fires `popstate`
+ * 2. The router adapter resolves the URL to a route target
+ * 3. The adapter sends a `PlayRouteEvent` to the Actor
+ * 4. The Actor checks the transition with the guards of its state machine
+ *
+ * @param type - The discriminator of the event. It is always "play.route"
+ * @param to - The target state ID, with a # prefix, for example '#home' or '#profile'
+ * @param params - The route parameters of the path only, from the URL path, for
+ *   example `{ userId: '123' }` of `/profile/123`. The `query` field holds the query
+ *   parameters separately.
+ * @param query - The query parameters only. They stay separate from the params of the path
+ * @param match - The complete match result of URLPattern, for the debug work and for
+ *   the observability. It is optional
+ *
+ * @returns Nothing. This interface defines the shape of the event only
  *
  * @example
- * Combining base and routing events
+ * The base event and the routing event together
  * ```typescript
  * import type { PlayEvent } from "@xmachines/play";
  * import type { PlayRouteEvent } from "@xmachines/play-router";
@@ -185,7 +177,7 @@ export interface RouteTree {
  * ```
  *
  * @example
- * Basic navigation to a route
+ * A basic navigation to a route
  * ```typescript
  * import type { PlayRouteEvent } from "@xmachines/play-router";
  *
@@ -197,7 +189,7 @@ export interface RouteTree {
  * ```
  *
  * @example
- * Navigation with route parameters
+ * A navigation with route parameters
  * ```typescript
  * import type { PlayRouteEvent } from "@xmachines/play-router";
  *
@@ -207,30 +199,31 @@ export interface RouteTree {
  *   params: { userId: '123' }
  * };
  * actor.send(event);
- * // Resolves to route: /profile/123
+ * // It resolves to the route /profile/123
  * ```
  *
  * @example
- * Navigation with query parameters
+ * A navigation with query parameters
  * ```typescript
  * import type { PlayRouteEvent } from "@xmachines/play-router";
  *
  * const event: PlayRouteEvent = {
  *   type: 'play.route',
  *   to: '#settings',
- *   params: { section: 'profile' },  // Path-only route parameter
- *   query: { tab: 'security' }        // Query-only
+ *   params: { section: 'profile' },  // a route parameter of the path only
+ *   query: { tab: 'security' }        // the query only
  * };
  * actor.send(event);
- * // Resolves to route: /settings/profile?tab=security
+ * // It resolves to the route /settings/profile?tab=security
  * ```
  *
  * @see [Play RFC](../../docs/rfc/play.md)
  *
  * @remarks
- * Use `play.route` when you need parameter-aware navigation with the `route: {}`
- * config pattern on your state machine nodes. The `match` field exposes the full
- * URLPatternResult for advanced use cases (debugging, pattern analysis).
+ * Use `play.route` when you need a navigation that knows the parameters, with the
+ * `route: {}` config pattern on the nodes of your state machine. The `match` field
+ * gives you the complete URLPatternResult, for an advanced use such as a debug or an
+ * analysis of the pattern.
  */
 export interface PlayRouteEvent {
     readonly type: "play.route";
@@ -241,18 +234,19 @@ export interface PlayRouteEvent {
     [key: string]: unknown;
 }
 /**
- * Minimal actor interface required by `RouterBridgeBase` and all framework router
- * adapters.
+ * The minimal actor interface that `RouterBridgeBase` and every framework router
+ * adapter require.
  *
- * 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.
+ * This interface, and not `AbstractActor<AnyActorLogic> & Routable`, gives
+ * `RouterBridgeBase.actor.send` the type that accepts a `PlayRouteEvent` directly.
+ * It therefore removes the unsafe cast `(actor.send as (e: PlayRouteEvent) => void)`,
+ * which the weaker `EventObject` constraint of the actor type needed before.
  *
- * 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`.
+ * Every `AbstractActor` subclass satisfies this interface structurally, for two
+ * reasons:
+ * - `AbstractActor` implements `send(event: TEvent): void`, and `TEvent` accepts each
+ *   `EventObject`. Therefore it always accepts a `PlayRouteEvent`, which is a subtype.
+ * - `Routable` gives `currentRoute` and `initialRoute`.
  *
  * @example
  * ```typescript
@@ -266,59 +260,63 @@ export interface PlayRouteEvent {
  * ```
  */
 export interface RoutableActor {
-    /** TC39 Signal exposing the actor's current URL path (or state ID). */
+    /** The TC39 Signal of the current URL path of the actor, or of its 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).
+     * The route of the initial state of the machine. The constructor fixes it.
+     * A router bridge compares it with the browser URL. It therefore separates a deep
+     * link, where the router wins, from a restore of a session, where the actor wins.
      */
     readonly initialRoute: string | null;
-    /** Send a route navigation event to the actor. */
+    /** Sends 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).
+ * The complete actor shape of the `PlayRouterProvider` component of each framework
+ * adapter: `play-solid-router`, `play-vue-router`, `play-react-router`, and each
+ * adapter 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.
+ * The shape extends `RoutableActor` with `currentView`, because the provider renders
+ * the current view spec and also keeps the routes in step. It therefore 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`).
+ * - Use `RoutableActor` when you need the routing alone, for example in a
+ *   `RouterBridgeBase` subclass, or in `connectRouter`.
+ * - Use `PlayActor` when the component also renders the current view spec, for
+ *   example for the renderer callback parameter of `PlayRouterProvider`, and in
+ *   `PlayRenderer`.
  *
- * All `AbstractActor` subclasses that implement both `Routable` and `Viewable`
- * satisfy this interface structurally.
+ * Every `AbstractActor` subclass that implements both `Routable` and `Viewable`
+ * satisfies 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)
+ *   // it reads actor.currentRoute for the routing, and actor.currentView for the render
  * }
  * ```
  */
 export interface PlayActor extends RoutableActor {
-    /** TC39 Signal exposing the actor's current view spec, or `null` when inactive. */
+    /** The TC39 Signal of the current view spec of the actor, or `null` when no view is active. */
     readonly currentView: Signal.State<PlaySpec | null>;
 }
 /**
- * RouterBridge interface for runtime infrastructure adapters
+ * The RouterBridge interface of a runtime infrastructure adapter
  *
- * 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.
+ * The interface defines the connection of the lifecycle between the infrastructure,
+ * for example a framework router, and the Actor. The infrastructure builds a "bridge"
+ * to the Actor: it observes the signals of the Actor, and it manages its own
+ * lifecycle accordingly.
  *
- * **Architectural Context:** Implements **Passive Infrastructure (INV-04)** by establishing
- * a unidirectional observation pattern. Infrastructure connects to observe Actor signals
- * (currentRoute, currentView, state) and reflects changes without making state decisions.
+ * **Architectural context:** the interface implements **Passive Infrastructure
+ * (INV-04)**, because it gives an observation in one direction. The infrastructure
+ * connects to observe the signals of the Actor (currentRoute, currentView, and
+ * state), and it reflects each change. It makes no decision about the state.
  *
  * @example
- * Framework router bridge implementation
+ * The implementation of a framework router bridge
  * ```typescript
  * import type { RouterBridge } from "@xmachines/play-router";
  * import { Signal } from "@xmachines/play-signals";
@@ -327,7 +325,7 @@ export interface PlayActor extends RoutableActor {
  *   private watcher: Signal.Watcher | null = null;
  *
  *   async connect(): Promise<void> {
- *     // Start observing actor.currentRoute signal
+ *     // Start the observation of the actor.currentRoute signal
  *     this.watcher = new Signal.subtle.Watcher(() => {
  *       const route = actor.currentRoute.get();
  *       if (route) router.navigate(route);
@@ -336,62 +334,63 @@ export interface PlayActor extends RoutableActor {
  *   }
  *
  *   async disconnect(): Promise<void> {
- *     // Stop observing, cleanup watchers
+ *     // Stop the observation, and clean the watchers up
  *     this.watcher?.unwatch(actor.currentRoute);
  *     this.watcher = null;
  *   }
  * }
  * ```
  *
- * @see [Play RFC](../../docs/rfc/play.md) - Invariant INV-04
+ * @see [Play RFC](../../docs/rfc/play.md) - invariant INV-04
  */
 export interface RouterBridge {
     /**
-     * Connect the router bridge to the Actor
+     * Connects the router bridge to the Actor
      *
-     * Called when Infrastructure should begin observing Actor signals and
-     * synchronizing its state (e.g., browser URL) with Actor state.
+     * The infrastructure calls it when it must start the observation of the Actor
+     * signals, and when it must bring its own state, for example the browser URL, in line
+     * with the Actor state.
      *
-     * @returns Promise that resolves when connection is established, or void for synchronous connection
+     * @returns The promise that resolves after the connection, or void for a synchronous connection
      *
      * @example
      * ```typescript
      * const bridge: RouterBridge = createBridge(actor, router);
      * await bridge.connect();
-     * // Bridge now observing actor.currentRoute signal
+     * // The bridge observes the actor.currentRoute signal now
      * ```
      */
     connect(): void | Promise<void>;
     /**
-     * Disconnect the router bridge from the Actor
+     * Disconnects the router bridge from the Actor
      *
-     * Called when Infrastructure should stop observing and clean up resources
-     * (e.g., signal watchers, event listeners).
+     * The infrastructure calls it when it must stop the observation and free its
+     * resources, for example a signal watcher and an event listener.
      *
-     * @returns Promise that resolves when disconnection is complete, or void for synchronous disconnection
+     * @returns The promise that resolves after the disconnection, or void for a synchronous disconnection
      *
      * @example
      * ```typescript
      * await bridge.disconnect();
-     * // Bridge stopped observing, resources cleaned up
+     * // The bridge stopped its observation, and it freed its resources
      * ```
      */
     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.
+ * The minimal window interface of an adapter that subscribes to a DOM event, for
+ * example to `hashchange`. You can inject it for SSR and for a test: give a mock in
+ * place of the global `window` when no DOM is available.
  *
- * Defined structurally (no `Window` reference) so this package compiles without
- * the DOM lib.
+ * The definition is structural, and it holds no reference to `Window`. This package
+ * therefore compiles without the DOM lib.
  *
  * @example
  * ```typescript
- * // Normal usage — global window (default)
+ * // The normal use — the global window, which is the default
  * connectRouter({ actor, routeMap });
  *
- * // SSR / test — injected mock
+ * // SSR or a test — an injected mock
  * const mockWin: WindowLike = { addEventListener: vi.fn(), removeEventListener: vi.fn() };
  * connectRouter({ actor, routeMap, window: mockWin });
  * ```
@@ -401,16 +400,16 @@ export interface WindowLike {
     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.
+ * The minimal location interface of an adapter that reads the current URL at the
+ * moment of `connect()`. You can inject it for SSR and for a test: give a mock in
+ * place of the global `location` when no DOM is available.
  *
- * Defined structurally (no `Location` reference) so this package compiles without
- * the DOM lib.
+ * The definition is structural, and it holds no reference to `Location`. This package
+ * therefore compiles without the DOM lib.
  *
  * @example
  * ```typescript
- * // SSR / test — injected mock
+ * // SSR or a test — an injected mock
  * const mockLoc: LocationLike = { pathname: "/dashboard", search: "?tab=posts" };
  * connectRouter({ actor, routeMap, location: mockLoc });
  * ```

package/dist/types.d.ts.map

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