@xmachines/play-router 3.0.0 → 5.0.0

package/dist/types.d.ts

@@ -1,48 +1,146 @@
-import type { Graph } from "@statelyai/graph";
-import type { BasePathOptions } from "./base-path.js";
-import type { Signal } from "@xmachines/play-signals";
-import type { PlaySpec } from "@xmachines/play-actor";
+import type { BasePathOptions, CompileOptions, PatternCache } from "@xmachines/play-url";
+import type { ReadonlyAtom } from "@xmachines/play-atom";
 /**
- * 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.
+ * The type definitions of the routing protocol of @xmachines/play-router
+ *
+ * PlayRouteEvent, RouterBridge, RouteMetadata, and RouteObject are here. The routing
+ * therefore stays separate from the base event protocol of @xmachines/play.
  */
-export interface MachineNodeData {
-    /** The XState state ID, for example "test.dashboard.overview" */
-    stateId: string;
-    /** The state type of XState */
-    type: "atomic" | "compound" | "parallel" | "final" | "history";
-    /** The original meta object of the state */
-    meta?: Record<string, unknown>;
-    /** The route path of meta.route, in its string form */
-    route?: string;
-}
 /**
- * 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.
+ * The resolved extra data of a route. It reaches the consumer on the `data` field of a
+ * `play.route` event.
  */
-export interface MachineEdgeData {
-    /** The event type that starts this transition */
-    eventType: string;
-    /**
-     * The guard as a string, when a guard is present
-     *
-     * @deprecated Will be removed in the next major.
-     */
-    guardType?: string;
-}
+export type RouteData = Record<string, unknown>;
 /**
- * The type definitions of the routing protocol of @xmachines/play-router
+ * The function form of {@link RouteObject.data}.
  *
- * PlayRouteEvent, RouterBridge, RouteMetadata, and RouteObject are here. The routing
- * therefore stays separate from the base event protocol of @xmachines/play.
+ * The signature mirrors `WithDynamicParams` of XState: the resolver reads the context
+ * of the machine and the event that asks for the route, and it returns the data.
+ *
+ * The resolver reads every field of the event, and `event.data` among them: that field
+ * carries what the SENDER of the event supplied, and the resolver decides how it
+ * combines with what the state declares. The `data` that the resolver RETURNS goes to
+ * `context.data`, and it does not go back onto the event.
  */
+export type RouteDataResolver = (args: {
+    context: unknown;
+    event: PlayRouteEvent;
+}) => RouteData;
 /**
  * A route object, with more metadata.
  */
 export interface RouteObject {
-    /** The template of the route path, for example '/user/:id' */
+    /** The template of the route path, for example `"/user/:id"`. */
     path: string;
-    /** The additional metadata of the route: a title, a breadcrumb, and so on */
+    /**
+     * The `reenter` flag of the generated `play.route` transition.
+     *
+     * The default is `false`, which is also the default of XState.
+     *
+     * The flag spares the DOMAIN of the transition, and not every ancestor that stays
+     * active. Under the default placement `handler: "root"` the domain is the root of
+     * the machine, so `false` spares the root alone: each ancestor BETWEEN the root and
+     * the target still runs its `exit` and its `entry` actions, because XState re-enters
+     * every descendant of the domain that lies on the path to the target. A move between
+     * two siblings therefore still runs the `entry` action of their shared parent.
+     *
+     * {@link RouteObject.handler} is the field that spares those intermediate ancestors:
+     * `"local"` and `"both"` move the domain down to the parent of the state. Use the
+     * two fields together where an `entry` action must run one time for each state that
+     * the actor really enters.
+     *
+     * Set the field to `true` where the domain must run its `entry` actions again on
+     * every route to a descendant.
+     *
+     * The flag does not decide the destination. The value of the machine after a route
+     * is identical under both settings. A route to a state that has children still
+     * enters the `initial` child of that state, because the generated transition targets
+     * the state by its id, and XState enters the initial child of an id target under
+     * both settings.
+     *
+     * @see [Play RFC](../../docs/rfc/play.md)
+     */
+    reenter?: boolean;
+    /**
+     * Where the generated `play.route` transition sits.
+     *
+     * `"root"` is the default, and it is what XState does: `formatRouteTransitions`
+     * installs every route transition on the ROOT of the machine, and each one targets
+     * its state by the ID. A route from any state therefore reaches this state. The cost
+     * is that the root is the domain of the transition, so XState re-enters each
+     * ancestor on the path to the target, and those ancestors run their `entry` actions
+     * again although they stay active.
+     *
+     * `"local"` installs the transition on the PARENT of this state instead, and it
+     * targets this state relatively. XState offers the transitions of the deepest active
+     * state node first, so the parent answers the event itself and runs its `exit` and
+     * its `entry` actions NOT again.
+     *
+     * `"both"` installs one transition in each place. The local one answers while the
+     * parent is active, and the root one answers a route that arrives from outside the
+     * parent. Use `"both"` where an ancestor holds an `entry` action that must run one
+     * time for each real entry, such as an analytics event or an audit record.
+     *
+     * CAUTION: `"local"` makes this state reachable by a route ONLY while its parent is
+     * active. A `play.route` event that arrives from anywhere else matches no transition
+     * and the actor does not move. A browser URL for this state therefore leaves the URL
+     * and the actor divergent. Choose `"local"` to SCOPE a route on purpose, for example
+     * a step that a person reaches only inside its wizard. Choose `"both"` where the
+     * state must stay reachable from everywhere.
+     *
+     * The field has no effect on a state whose parent IS the root: the root transition
+     * of such a state is already local to its parent, so all three values agree.
+     */
+    handler?: "root" | "local" | "both";
+    /**
+     * The extra data that the state threads into its `play.route` event.
+     *
+     * The shape follows `WithDynamicParams` of XState, which is how XState itself
+     * parameterizes an action and a guard: the field holds a literal value, OR a
+     * function of `{ context, event }` that returns one.
+     *
+     * ```ts
+     * // The literal form. It survives a serialization of the machine.
+     * meta: { route: { path: "/doc/:docId", data: { titleKey: "doc.view" } } }
+     *
+     * // The function form, for a value that depends on the route.
+     * meta: {
+     *   route: {
+     *     path: "/doc/:docId",
+     *     data: ({ event }) => ({ title: `Document ${event.params?.docId}` }),
+     *   },
+     * }
+     * ```
+     *
+     * The generated transition resolves the value and assigns it to the `data` field of
+     * the context, beside `params` and `query`. The data of a state does NOT merge with
+     * the data of its ancestors: each state declares the whole value that its own route
+     * carries.
+     *
+     * This field and {@link PlayRouteEvent.data} are two different things, and they meet
+     * in the resolver. This field is what the STATE declares, in its machine.
+     * `PlayRouteEvent.data` is what the SENDER of the event supplies, such as a router
+     * bridge or the code of an application. A resolver reads `event.data` and returns
+     * whatever mix of the two the state needs.
+     *
+     * CAUTION: the function form holds a function inside `meta`, and a function does not
+     * survive `JSON.stringify`. A machine that Stately Studio reads, or that a process
+     * sends over a wire, must use the literal form.
+     */
+    data?: RouteData | RouteDataResolver;
+    /**
+     * The additional metadata of the route: a title, a breadcrumb, and so on.
+     *
+     * CAUTION: `path`, `handler`, `reenter` and `data` are RESERVED. The routing layer
+     * reads those four names, and a release before this one read `path` alone. A state
+     * that carries its own `handler` value now throws an `InvalidRouteHandlerError` from
+     * `formatPlayRouteTransitions`, so the machine builds never; a state that carries its
+     * own `data` value now writes that value to `context.data`, where the `/context`
+     * projection of every view reads it. A `reenter` value is read as the FLAG of the
+     * generated transition, and the literal `true` alone turns the reentry on: the
+     * default is `false`, and a release before this one generated every transition with
+     * `reenter: true`. Give such a field another name.
+     */
     [key: string]: unknown;
 }
 /**
@@ -112,7 +210,7 @@ export interface RouteNode {
  * - 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 {
+export interface RouteTree<TGraph = unknown> {
     /** The root node of the routes */
     root: RouteNode;
     /**
@@ -127,17 +225,20 @@ export interface RouteTree {
     byPath: Map<string, RouteNode>;
     /**
      * 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.
+     *
+     * `TGraph` carries its type, and this package names none: a route tree is a map from a
+     * path to a state, and the graph of a MACHINE belongs to the package that reads a
+     * machine. `extractMachineRoutes` of `@xmachines/play-router/xstate` answers
+     * `RouteTree<MachineGraph>`, so a consumer of that function loses no type.
      *
      * @example
      * ```typescript
      * import { getSuccessors, hasPath } from "@statelyai/graph";
+     * // `tree` comes from `extractMachineRoutes` of `@xmachines/play-router/xstate`
      * const successors = getSuccessors(tree.graph!, "myMachine.home");
      * ```
      */
-    graph?: Graph<MachineNodeData, MachineEdgeData>;
+    graph?: TGraph;
 }
 /**
  * The routing event, with its parameters and its query
@@ -231,23 +332,43 @@ export interface PlayRouteEvent {
     readonly to: string;
     readonly params?: Record<string, string>;
     readonly query?: Record<string, string>;
+    /**
+     * The extra data that the SENDER of this event supplies: a router bridge, or the
+     * code of an application. It is not what the target state declares — that is
+     * {@link RouteObject.data}, and a resolver there reads this field.
+     */
+    readonly data?: RouteData;
     readonly match?: unknown;
-    [key: string]: unknown;
+}
+/**
+ * An optional capability: the routing support
+ */
+export interface Routable {
+    readonly currentRoute: ReadonlyAtom<string | null>;
+    readonly initialRoute: string | null;
 }
 /**
  * The minimal actor interface that `RouterBridgeBase` and every framework router
  * adapter require.
  *
- * 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.
+ * It names `send` itself, and it therefore gives `RouterBridgeBase.actor.send` a type that
+ * accepts a `PlayRouteEvent` directly. That removes the unsafe cast
+ * `(actor.send as (e: PlayRouteEvent) => void)`.
+ *
+ * It is {@link Routable} with `send`. The two members of the capability are declared once,
+ * in `Routable`, and this interface extends it. A copy of them here drifts the day that
+ * one of the two files changes.
  *
- * 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`.
+ * **It names the view NOWHERE. Routing implies no rendering.** No file of this package,
+ * and no file of any of the eight router adapters, ever reads `currentView`. A provider
+ * whose renderer callback reads the view binds its own `TActor`, and a constraint keeps
+ * the concrete type of the actor whole, so that callback still reads the exact spec of
+ * that actor.
+ *
+ * Every `PlayActor` of `@xmachines/play-actor` that also implements `Routable`, and whose
+ * event union holds `PlayRouteEvent`, satisfies this interface structurally. A machine
+ * that declares no route event does NOT satisfy it, and that refusal is correct: a bridge
+ * cannot navigate an actor that receives no route event.
  *
  * @example
  * ```typescript
@@ -260,84 +381,43 @@ export interface PlayRouteEvent {
  * }
  * ```
  */
-export interface RoutableActor {
-    /** The TC39 Signal of the current URL path of the actor, or of its state ID. */
-    readonly currentRoute: Signal.Computed<string | null>;
-    /**
-     * 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;
+export interface RoutableActor extends Routable {
     /** Sends a route navigation event to the actor. */
     send(event: PlayRouteEvent): void;
 }
-/**
- * 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.
- *
- * 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 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`.
- *
- * 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 }) {
- *   // it reads actor.currentRoute for the routing, and actor.currentView for the render
- * }
- * ```
- */
-export interface PlayActor extends RoutableActor {
-    /** The TC39 Signal of the current view spec of the actor, or `null` when no view is active. */
-    readonly currentView: Signal.State<PlaySpec | null>;
-}
 /**
  * The RouterBridge interface of a runtime infrastructure adapter
  *
  * 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
+ * to the Actor: it observes the atoms of the Actor, and it manages its own
  * lifecycle accordingly.
  *
  * **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
+ * connects to observe the atoms of the Actor (currentRoute, currentView, and
  * state), and it reflects each change. It makes no decision about the state.
  *
  * @example
  * The implementation of a framework router bridge
  * ```typescript
  * import type { RouterBridge } from "@xmachines/play-router";
- * import { Signal } from "@xmachines/play-signals";
+ * import { watchAtom, type Cleanup } from "@xmachines/play-atom";
  *
  * class MyRouterBridge implements RouterBridge {
- *   private watcher: Signal.Watcher | null = null;
+ *   private stop: Cleanup | null = null;
  *
  *   async connect(): Promise<void> {
- *     // Start the observation of the actor.currentRoute signal
- *     this.watcher = new Signal.subtle.Watcher(() => {
- *       const route = actor.currentRoute.get();
+ *     // Start the observation of the actor.currentRoute atom
+ *     this.stop = watchAtom(actor.currentRoute, (route) => {
  *       if (route) router.navigate(route);
  *     });
- *     this.watcher.watch(actor.currentRoute);
  *   }
  *
  *   async disconnect(): Promise<void> {
- *     // Stop the observation, and clean the watchers up
- *     this.watcher?.unwatch(actor.currentRoute);
- *     this.watcher = null;
+ *     // Stop the observation, and release the subscription
+ *     this.stop?.();
+ *     this.stop = null;
  *   }
  * }
  * ```
@@ -349,7 +429,7 @@ export interface RouterBridge {
      * Connects the router bridge to the Actor
      *
      * 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
+     * atoms, and when it must bring its own state, for example the browser URL, in line
      * with the Actor state.
      *
      * @returns The promise that resolves after the connection, or void for a synchronous connection
@@ -358,7 +438,7 @@ export interface RouterBridge {
      * ```typescript
      * const bridge: RouterBridge = createBridge(actor, router);
      * await bridge.connect();
-     * // The bridge observes the actor.currentRoute signal now
+     * // The bridge observes the actor.currentRoute atom now
      * ```
      */
     connect(): void | Promise<void>;
@@ -366,7 +446,7 @@ export interface RouterBridge {
      * Disconnects the router bridge from the Actor
      *
      * The infrastructure calls it when it must stop the observation and free its
-     * resources, for example a signal watcher and an event listener.
+     * resources, for example an atom watcher and an event listener.
      *
      * @returns The promise that resolves after the disconnection, or void for a synchronous disconnection
      *
@@ -462,4 +542,28 @@ export interface LocationLike {
     readonly pathname: string;
     readonly search: string;
 }
+/**
+ * The options of `createRouteMap` and of `createRouteMapFromTree`.
+ */
+export interface RouteMapOptions extends CompileOptions {
+    /**
+     * The cache of the state that a VISITED PATH resolves to, or `null` for a path that
+     * resolves to none.
+     *
+     * The default is a cache of this map alone, of 500 entries in each of two generations.
+     * Pass one to raise that bound, to share the resolution across maps, or to give it an
+     * eviction policy of your own: `createPatternCache(5000)` builds one, and so does any
+     * object with a `get` and a `set`.
+     *
+     * A cache that a caller passes is keyed by the ROUTE TABLE. Two maps built from the
+     * same mappings, in the same order, therefore read each other's answers — which is
+     * what a server that rebuilds its map for each request wants — and two maps built from
+     * different mappings never do, because a map with no route for a path writes `null`
+     * for it and a map that holds one must not read that.
+     *
+     * The keys are the paths that a visitor reaches, so the key space is unbounded: a
+     * cache with no bound of its own grows for the life of the process.
+     */
+    pathCache?: PatternCache<string | null>;
+}
 //# 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":"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"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,30 @@
+import type { AnyStateMachine } from "xstate";
+import { RouteMap } from "../base-route-map.js";
+import type { RouteMapOptions } from "../types.js";
+/**
+ * Creates a `RouteMap` from an XState state machine.
+ *
+ * The function reads every state with a route, which means each state with a
+ * `meta.route` field. It keeps the routable states alone, and it drops the synthetic
+ * root of the tree. `createRouteMapFromTree` of the main entry point drops the same
+ * node, and the two functions therefore answer the same map for the same machine. It then builds the lookup structure between a path and a
+ * stateId, for both directions. A subclass of `RouterBridgeBase` uses the map: it
+ * converts each change of the browser URL into a `play.route` actor event, and each
+ * actor route into a URL.
+ *
+ * @param machine - The XState v5 state machine, with a `meta.route` annotation on each state with a route.
+ * @param options - The optional configuration. Give `{ pathCache }` to replace the
+ *   default LRU cache of the parameterized path lookups with one that you own.
+ * @returns A `RouteMap` for each adapter on `RouterBridgeBase`.
+ *
+ * @example
+ * ```typescript
+ * import { createRouteMap } from '@xmachines/play-router/xstate';
+ * import { connectRouter } from '@xmachines/play-dom-router';
+ *
+ * const routeMap = createRouteMap(myMachine);
+ * const disconnect = connectRouter({ actor, router, routeMap });
+ * ```
+ */
+export declare function createRouteMap(machine: AnyStateMachine, options?: RouteMapOptions): RouteMap;
+//# sourceMappingURL=create-route-map.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create-route-map.d.ts","sourceRoot":"","sources":["../../src/xstate/create-route-map.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,QAAQ,CAAC;AAG9C,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAChD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,eAAe,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,QAAQ,CAa5F"}

package/dist/{create-route-map.js → xstate/create-route-map.js}

@@ -1,23 +1,25 @@
 import { extractMachineRoutes } from "./extract-routes.js";
 import { getRoutableRoutes } from "./query.js";
-import { RouteMap } from "./base-route-map.js";
+import { RouteMap } from "../base-route-map.js";
 /**
  * Creates a `RouteMap` from an XState state machine.
  *
  * The function reads every state with a route, which means each state with a
- * `meta.route` field. It then builds the lookup structure between a path and a
+ * `meta.route` field. It keeps the routable states alone, and it drops the synthetic
+ * root of the tree. `createRouteMapFromTree` of the main entry point drops the same
+ * node, and the two functions therefore answer the same map for the same machine. It then builds the lookup structure between a path and a
  * stateId, for both directions. A subclass of `RouterBridgeBase` uses the map: it
  * converts each change of the browser URL into a `play.route` actor event, and each
  * actor route into a URL.
  *
  * @param machine - The XState v5 state machine, with a `meta.route` annotation on each state with a route.
- * @param options - The optional configuration. Give `{ cacheSize }` to change the
- *   default size of the LRU cache of the parameterized path lookups.
+ * @param options - The optional configuration. Give `{ pathCache }` to replace the
+ *   default LRU cache of the parameterized path lookups with one that you own.
  * @returns A `RouteMap` for each adapter on `RouterBridgeBase`.
  *
  * @example
  * ```typescript
- * import { createRouteMap } from '@xmachines/play-router';
+ * import { createRouteMap } from '@xmachines/play-router/xstate';
  * import { connectRouter } from '@xmachines/play-dom-router';
  *
  * const routeMap = createRouteMap(myMachine);
@@ -25,7 +27,10 @@ import { RouteMap } from "./base-route-map.js";
  * ```
  */
 export function createRouteMap(machine, options) {
-    const routeTree = extractMachineRoutes(machine);
+    // The options reach the EXTRACTION too. `extractMachineRoutes` parses the route of
+    // every node, so a caller that passes a cache for the isolation of a tenant would
+    // otherwise write each of those patterns into the shared default cache.
+    const routeTree = extractMachineRoutes(machine, options);
     const routes = getRoutableRoutes(routeTree);
     return new RouteMap(routes.map((node) => ({
         stateId: node.stateId,

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

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

package/dist/{extract-routes.d.ts → xstate/extract-routes.d.ts}

@@ -1,5 +1,7 @@
+import type { ParseOptions } from "@xmachines/play-url";
 import type { AnyStateMachine } from "xstate";
-import type { RouteTree } from "./types.js";
+import type { RouteTree } from "../types.js";
+import { type MachineGraph } from "./machine-to-graph.js";
 /**
  * Reads the complete route tree from the graph of a state machine
  *
@@ -12,5 +14,5 @@ import type { RouteTree } from "./types.js";
  * @param machine - The XState v5 state machine
  * @returns The route tree, with its root, its byStateId map, its byPath map, and its graph
  */
-export declare const extractMachineRoutes: (machine: AnyStateMachine) => RouteTree;
+export declare const extractMachineRoutes: (machine: AnyStateMachine, options?: ParseOptions) => RouteTree<MachineGraph>;
 //# sourceMappingURL=extract-routes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"extract-routes.d.ts","sourceRoot":"","sources":["../../src/xstate/extract-routes.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,QAAQ,CAAC;AAE9C,OAAO,KAAK,EAAE,SAAS,EAA4B,MAAM,aAAa,CAAC;AAEvE,OAAO,EAAkB,KAAK,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAiF1E;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,oBAAoB,GAChC,SAAS,eAAe,EACxB,UAAU,YAAY,KACpB,SAAS,CAAC,YAAY,CAoBxB,CAAC"}

package/dist/{extract-routes.js → xstate/extract-routes.js}

@@ -1,6 +1,7 @@
+import { parsePattern } from "@xmachines/play-url";
 import { machineToGraph } from "./machine-to-graph.js";
-import { validateRouteFormat, validateStateExists } from "./validate-routes.js";
-import { buildRouteTree } from "./build-tree.js";
+import { validateRouteFormat, validateStateExists } from "../validate-routes.js";
+import { buildRouteTree } from "../build-tree.js";
 /**
  * Builds the statePath of a graph node, and it walks the chain of the parentId
  * values.
@@ -26,7 +27,7 @@ const buildStatePath = (graphNode, graphNodeMap) => {
  * Reads the route information of the MachineNodeData object of a graph node.
  * The function returns null when the node has no route.
  */
-const extractRouteFromNode = (graphNode, stateIds, graphNodeMap) => {
+const extractRouteFromNode = (graphNode, stateIds, graphNodeMap, options) => {
     const { stateId, route, meta } = graphNode.data;
     // The node has no route
     if (!route)
@@ -37,7 +38,11 @@ const extractRouteFromNode = (graphNode, stateIds, graphNodeMap) => {
     validateStateExists(stateId, stateIds);
     // Build the statePath from the chain of the parentId values. This works for an explicit ID and also for a generated one
     const statePath = buildStatePath(graphNode, graphNodeMap);
-    const pattern = route.includes(":") ? route : undefined;
+    // The parse answers this, and not a search for a ":". `route.includes(":")` was the
+    // last expression that read the grammar on its own: it reported no pattern for
+    // `/docs/*`, for `/books{/:id}?` and for an escaped literal, so a consumer that reads
+    // `node.pattern` learned that a parameterized route is a literal path.
+    const pattern = parsePattern(route, options).parameterized ? route : undefined;
     // Build the original shape of the metadata again, from the data of the graph
     const metadata = meta && typeof meta === "object" && "route" in meta
         ? meta["route"]
@@ -66,7 +71,7 @@ const extractRouteFromNode = (graphNode, stateIds, graphNodeMap) => {
  * @param machine - The XState v5 state machine
  * @returns The route tree, with its root, its byStateId map, its byPath map, and its graph
  */
-export const extractMachineRoutes = (machine) => {
+export const extractMachineRoutes = (machine, options) => {
     // 1. Convert the machine into a graph
     const graph = machineToGraph(machine);
     // 2. Build the set of the state IDs, for the check, and the node map, for a parent lookup in O(1)
@@ -74,7 +79,7 @@ export const extractMachineRoutes = (machine) => {
     const graphNodeMap = new Map(graph.nodes.map((n) => [n.id, n]));
     // 3. Read the routes of the graph nodes
     const routes = graph.nodes
-        .map((node) => extractRouteFromNode(node, stateIds, graphNodeMap))
+        .map((node) => extractRouteFromNode(node, stateIds, graphNodeMap, options))
         .filter((r) => r !== null);
     // 4. Build the hierarchical tree, and attach the graph.
     // buildRouteTree finds each duplicate route, AFTER it resolved each relative route

package/dist/xstate/extract-routes.js.map

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

package/dist/xstate/index.d.ts

@@ -0,0 +1,35 @@
+/**
+ * `@xmachines/play-router/xstate` - the routes of an XState machine
+ *
+ * A route of XMachines is a fact about a STATE. This entry point reads that fact out of an
+ * XState v5 machine: it walks the machine, collects each `meta.route`, builds the route
+ * tree, and answers the questions that the tree can be asked — which routes are reachable,
+ * which are navigable from a state, and which path maps to which state id.
+ *
+ * The MAIN entry point holds what happens AFTERWARDS: the route map, the match of a
+ * location, the bridge, and the provider lifecycle. It names no machine, and it reads this
+ * module never. `xstate` is therefore an OPTIONAL peer of this package, and a bundler drops
+ * `@statelyai/graph` for a consumer that imports this entry point nowhere.
+ *
+ * This is the same shape as `@xmachines/play-xstate/routing` and
+ * `@xmachines/play-xstate/view`: an optional capability behind its own entry point, with
+ * its own dependency.
+ *
+ * @example
+ * ```typescript
+ * import { createRouteMap } from "@xmachines/play-router/xstate";
+ * import { connectRouter } from "@xmachines/play-dom-router";
+ *
+ * const routeMap = createRouteMap(myMachine);
+ * ```
+ *
+ * @packageDocumentation
+ * @see [Routing guide](../../../docs/guides/routing.md)
+ */
+export { extractMachineRoutes } from "./extract-routes.js";
+export { createRouteMap } from "./create-route-map.js";
+export { machineToGraph } from "./machine-to-graph.js";
+export type { MachineGraph } from "./machine-to-graph.js";
+export type { MachineNodeData, MachineEdgeData } from "./machine-types.js";
+export { getNavigableRoutes, getRoutableRoutes, routeExists, getTransitionReachableRoutes, isRouteReachable, getRouteMappings, } from "./query.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/xstate/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/xstate/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,YAAY,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAC1D,YAAY,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAC3E,OAAO,EACN,kBAAkB,EAClB,iBAAiB,EACjB,WAAW,EACX,4BAA4B,EAC5B,gBAAgB,EAChB,gBAAgB,GAChB,MAAM,YAAY,CAAC"}