@xmachines/play-router 6.0.0 → 7.0.0

package/dist/xstate/query.js

@@ -1,229 +1,207 @@
-import { joinBasePath, normalizeBasePath, resolveBasePath, } from "@xmachines/play-url";
+import "../build-tree.js";
+import { joinBasePath, normalizeBasePath, resolveBasePath } from "@xmachines/play-url";
 import { getSuccessors, hasNode, hasPath } from "@statelyai/graph";
-import { ROOT_NODE_ID } from "../build-tree.js";
+//#region packages/play-router/src/xstate/query.ts
 /**
- * Returns the successor nodes of a state that have a route: the states of a direct
- * transition edge that hold a `meta.route` field.
- *
- * `getTransitionReachableStateIds` and `getTransitionReachableRoutes` share this
- * walk. The function returns the complete nodes. Therefore each caller reads the
- * field that it needs: the stateId, or the raw route string.
- */
-const getRoutableSuccessors = (graph, stateId) => 
-// A state ID without a graph node, for example a state without a route or a state
-// that a person removed, is a normal result of "nothing to reach". The code tests
-// that case explicitly, and it matches no message of an error from a throw.
-hasNode(graph, stateId)
-    ? getSuccessors(graph, stateId).filter((n) => n.data.route !== undefined)
-    : [];
+* Returns the successor nodes of a state that have a route: the states of a direct
+* transition edge that hold a `meta.route` field.
+*
+* `getTransitionReachableStateIds` and `getTransitionReachableRoutes` share this
+* walk. The function returns the complete nodes. Therefore each caller reads the
+* field that it needs: the stateId, or the raw route string.
+*/
+var getRoutableSuccessors = (graph, stateId) => hasNode(graph, stateId) ? getSuccessors(graph, stateId).filter((n) => n.data.route !== void 0) : [];
 /**
- * Returns every route of a navigation from the given state
- *
- * The function returns the child routes of the state. A later version also returns
- * the sibling routes of a transition.
- *
- * @param tree - The route tree, from extractMachineRoutes()
- * @param stateId - The ID of the current state
- * @returns The array of the route nodes that the state can reach
- *
- * @example
- * ```typescript
- * const tree = extractMachineRoutes(machine);
- * const routes = getNavigableRoutes(tree, 'dashboard');
- * // [{ id: 'overview', path: '/overview', ... }, { id: 'settings', ... }]
- * ```
- */
-export const getNavigableRoutes = (tree, stateId) => {
-    const node = tree.byStateId.get(stateId);
-    if (!node)
-        return [];
-    const results = [...node.children]; // The direct child routes
-    // With a graph, the result also holds each route that a transition can reach.
-    // The code looks each node up by its state ID: a graph node carries the RAW
-    // meta.route string, and that string can be relative, for example "detail". The
-    // keys of tree.byPath are the resolved fullPath values, for example
-    // "/section/detail". A lookup by the path therefore loses every relative route in
-    // silence. A state ID is unambiguous in both structures.
-    if (tree.graph) {
-        const reachableStateIds = getTransitionReachableStateIds(tree.graph, stateId);
-        const existingPaths = new Set(results.map((r) => r.fullPath));
-        for (const reachableStateId of reachableStateIds) {
-            const routeNode = tree.byStateId.get(reachableStateId);
-            if (routeNode && !existingPaths.has(routeNode.fullPath)) {
-                results.push(routeNode);
-                existingPaths.add(routeNode.fullPath);
-            }
-        }
-    }
-    return results;
+* Returns every route of a navigation from the given state
+*
+* The function returns the child routes of the state. A later version also returns
+* the sibling routes of a transition.
+*
+* @param tree - The route tree, from extractMachineRoutes()
+* @param stateId - The ID of the current state
+* @returns The array of the route nodes that the state can reach
+*
+* @example
+* ```typescript
+* const tree = extractMachineRoutes(machine);
+* const routes = getNavigableRoutes(tree, 'dashboard');
+* // [{ id: 'overview', path: '/overview', ... }, { id: 'settings', ... }]
+* ```
+*/
+var getNavigableRoutes = (tree, stateId) => {
+	const node = tree.byStateId.get(stateId);
+	if (!node) return [];
+	const results = [...node.children];
+	if (tree.graph) {
+		const reachableStateIds = getTransitionReachableStateIds(tree.graph, stateId);
+		const existingPaths = new Set(results.map((r) => r.fullPath));
+		for (const reachableStateId of reachableStateIds) {
+			const routeNode = tree.byStateId.get(reachableStateId);
+			if (routeNode && !existingPaths.has(routeNode.fullPath)) {
+				results.push(routeNode);
+				existingPaths.add(routeNode.fullPath);
+			}
+		}
+	}
+	return results;
 };
 /**
- * Returns the state IDs of the states with a route that a transition from a state
- * can reach.
- *
- * The walk is the same as the walk of `getTransitionReachableRoutes`, but this
- * function returns the state IDs, and not the raw `meta.route` strings. A caller
- * therefore resolves each node through `tree.byStateId`, with no doubt between a raw
- * path and a resolved path.
- */
-const getTransitionReachableStateIds = (graph, stateId) => {
-    return getRoutableSuccessors(graph, stateId).map((n) => n.data.stateId);
+* Returns the state IDs of the states with a route that a transition from a state
+* can reach.
+*
+* The walk is the same as the walk of `getTransitionReachableRoutes`, but this
+* function returns the state IDs, and not the raw `meta.route` strings. A caller
+* therefore resolves each node through `tree.byStateId`, with no doubt between a raw
+* path and a resolved path.
+*/
+var getTransitionReachableStateIds = (graph, stateId) => {
+	return getRoutableSuccessors(graph, stateId).map((n) => n.data.stateId);
 };
 /**
- * Returns every route of the tree that has a route, in one flat array
- *
- * The function returns each route with a `meta.route` field. It returns no state
- * without a route, and no synthetic root node. Use it to generate a router
- * configuration in a framework adapter dynamically.
- *
- * @param tree - The route tree, from extractMachineRoutes()
- * @returns The array of the route nodes with a route, with their path and their stateId
- *
- * @example
- * ```typescript
- * const tree = extractMachineRoutes(machine);
- * const routes = getRoutableRoutes(tree);
- * // [
- * //   { path: '/', stateId: '#home', ... },
- * //   { path: '/about', stateId: '#about', ... },
- * //   { path: '/profile/:userId', stateId: '#profile', ... }
- * // ]
- * ```
- */
-export const getRoutableRoutes = (tree) => {
-    const routes = [];
-    for (const node of tree.byStateId.values()) {
-        // Keep the nodes with a route, which means the nodes with a meta.route field, and skip the synthetic root
-        if (node.routable && node.id !== ROOT_NODE_ID) {
-            routes.push(node);
-        }
-    }
-    return routes;
+* Returns every route of the tree that has a route, in one flat array
+*
+* The function returns each route with a `meta.route` field. It returns no state
+* without a route, and no synthetic root node. Use it to generate a router
+* configuration in a framework adapter dynamically.
+*
+* @param tree - The route tree, from extractMachineRoutes()
+* @returns The array of the route nodes with a route, with their path and their stateId
+*
+* @example
+* ```typescript
+* const tree = extractMachineRoutes(machine);
+* const routes = getRoutableRoutes(tree);
+* // [
+* //   { path: '/', stateId: '#home', ... },
+* //   { path: '/about', stateId: '#about', ... },
+* //   { path: '/profile/:userId', stateId: '#profile', ... }
+* // ]
+* ```
+*/
+var getRoutableRoutes = (tree) => {
+	const routes = [];
+	for (const node of tree.byStateId.values()) if (node.routable && node.id !== "__root__") routes.push(node);
+	return routes;
 };
 /**
- * Tells you if a route path is in the tree
- *
- * The function tests if the path has a state with a `meta.route` field.
- *
- * @param tree - The route tree, from extractMachineRoutes()
- * @param path - The complete route path, for example '/dashboard/settings'
- * @returns true when the tree holds the path. In every other case, false
- */
-export const routeExists = (tree, path) => {
-    return tree.byPath.has(path);
+* Tells you if a route path is in the tree
+*
+* The function tests if the path has a state with a `meta.route` field.
+*
+* @param tree - The route tree, from extractMachineRoutes()
+* @param path - The complete route path, for example '/dashboard/settings'
+* @returns true when the tree holds the path. In every other case, false
+*/
+var routeExists = (tree, path) => {
+	return tree.byPath.has(path);
 };
 /**
- * Returns the routes that a transition from the current state can reach
- *
- * The function uses the successor algorithm of @statelyai/graph. It finds every
- * state of a direct transition edge from the given state, then it keeps the states
- * with a route.
- *
- * The values of the return are the RAW `meta.route` strings of the machine. The
- * function does NOT resolve a relative route, for example `"detail"`, to a complete
- * path, and such a value is therefore no key of `tree.byPath`. For a resolved
- * `RouteNode`, use `getNavigableRoutes`: that function resolves each state that the
- * transition reaches through `tree.byStateId`.
- *
- * @param graph - The machine graph, from RouteTree.graph
- * @param stateId - The ID of the current state, for example "test.home"
- * @returns The array of the raw route strings that a transition can reach
- *
- * @example
- * ```typescript
- * const tree = extractMachineRoutes(machine);
- * if (tree.graph) {
- *   const reachable = getTransitionReachableRoutes(tree.graph, 'auth.loggedIn');
- *   // ['/dashboard', '/settings'] — the routes that a transition can reach
- * }
- * ```
- */
-export const getTransitionReachableRoutes = (graph, stateId) => {
-    return getRoutableSuccessors(graph, stateId).map((n) => n.data.route);
+* Returns the routes that a transition from the current state can reach
+*
+* The function uses the successor algorithm of @statelyai/graph. It finds every
+* state of a direct transition edge from the given state, then it keeps the states
+* with a route.
+*
+* The values of the return are the RAW `meta.route` strings of the machine. The
+* function does NOT resolve a relative route, for example `"detail"`, to a complete
+* path, and such a value is therefore no key of `tree.byPath`. For a resolved
+* `RouteNode`, use `getNavigableRoutes`: that function resolves each state that the
+* transition reaches through `tree.byStateId`.
+*
+* @param graph - The machine graph, from RouteTree.graph
+* @param stateId - The ID of the current state, for example "test.home"
+* @returns The array of the raw route strings that a transition can reach
+*
+* @example
+* ```typescript
+* const tree = extractMachineRoutes(machine);
+* if (tree.graph) {
+*   const reachable = getTransitionReachableRoutes(tree.graph, 'auth.loggedIn');
+*   // ['/dashboard', '/settings'] — the routes that a transition can reach
+* }
+* ```
+*/
+var getTransitionReachableRoutes = (graph, stateId) => {
+	return getRoutableSuccessors(graph, stateId).map((n) => n.data.route);
 };
 /**
- * Tells you if a transition from the current state can reach a route
- *
- * The function uses the path search of @statelyai/graph. It decides if a chain of
- * transition edges is present from the state of the origin to the state of the
- * target.
- *
- * @param graph - The machine graph, from RouteTree.graph
- * @param fromStateId - The ID of the state of the origin
- * @param toStateId - The ID of the state of the target
- * @returns true when a transition path is present. In every other case, false
- *
- * @example
- * ```typescript
- * const tree = extractMachineRoutes(machine);
- * if (tree.graph) {
- *   const canReach = isRouteReachable(tree.graph, 'auth.login', 'auth.dashboard');
- *   // it is true when a transition path from login to dashboard is present
- * }
- * ```
- */
-export const isRouteReachable = (graph, fromStateId, toStateId) => {
-    // An absent endpoint is a normal result of "not reachable".
-    return hasNode(graph, fromStateId) && hasNode(graph, toStateId)
-        ? hasPath(graph, fromStateId, toStateId)
-        : false;
+* Tells you if a transition from the current state can reach a route
+*
+* The function uses the path search of @statelyai/graph. It decides if a chain of
+* transition edges is present from the state of the origin to the state of the
+* target.
+*
+* @param graph - The machine graph, from RouteTree.graph
+* @param fromStateId - The ID of the state of the origin
+* @param toStateId - The ID of the state of the target
+* @returns true when a transition path is present. In every other case, false
+*
+* @example
+* ```typescript
+* const tree = extractMachineRoutes(machine);
+* if (tree.graph) {
+*   const canReach = isRouteReachable(tree.graph, 'auth.login', 'auth.dashboard');
+*   // it is true when a transition path from login to dashboard is present
+* }
+* ```
+*/
+var isRouteReachable = (graph, fromStateId, toStateId) => {
+	return hasNode(graph, fromStateId) && hasNode(graph, toStateId) ? hasPath(graph, fromStateId, toStateId) : false;
 };
 /**
- * Returns the `{ stateId, path }` entries that a host router needs, so that it can
- * register the routes of a machine under a base path, and remove them again later.
- *
- * This function makes the routes dynamic. `getStateIdByPath` and `getPathByStateId`
- * answer the question "what is this URL?" at the moment of a navigation, but a host
- * that declares real route objects — a route tree of TanStack, a `RouteObject[]`, an
- * `addRoute` call of vue-router — needs the LIST in advance, and it needs that list
- * with the prefix of the mount. A registration of these paths, and a removal of them
- * when the machine unloads, keeps the route table of the host in step with the mount.
- *
- * `basePathParams` decides the form of each path, and both forms are useful:
- * - **Given** → a concrete path (`/abc123/play/profile/:userId`), for a route that
- *   the host adds at run time, after a loader resolved the mount.
- * - **Absent** → the pattern stays (`/:machineId/play/profile/:userId`), for a static
- *   route declaration of the host.
- *
- * The function ALWAYS keeps each `:param` segment that the machine declares itself:
- * those are the params that the route of the host must match.
- *
- * @param tree - The route tree of extractMachineRoutes()
- * @param options - The optional `{ basePath, basePathParams }`, the same option as the bridge takes.
- * Each `stateId` comes from the route tree, so it carries NO `#` prefix. A host that
- * keys its route table on the target of a `play.route` event adds the `#` itself,
- * because the event always carries the prefixed form.
- *
- * @returns One entry for each state with a route, in the order of the route tree.
- * @throws {InvalidBasePathError} For a base path that resolves to one concrete path never.
- * @throws {MissingBasePathParamError} When `basePathParams` is present and it omits a `:param`.
- *
- * @example
- * ```typescript
- * const tree = extractMachineRoutes(machine);
- *
- * // Concrete, for a route that the host adds after a loader resolved the mount
- * getRouteMappings(tree, { basePath: "/:machineId/play", basePathParams: { machineId: "abc123" } });
- * // [
- * //   { stateId: "app.home",    path: "/abc123/play" },
- * //   { stateId: "app.profile", path: "/abc123/play/profile/:userId" },
- * // ]
- *
- * // The pattern, for a static route declaration of the host
- * getRouteMappings(tree, { basePath: "/:machineId/play" });
- * // [{ stateId: "app.home", path: "/:machineId/play" }, ...]
- * ```
- */
-export const getRouteMappings = (tree, options) => {
-    // With the params, resolve the prefix to a concrete path. Without them, keep the
-    // pattern, so that a host declares its routes statically and substitutes each param
-    // itself.
-    const basePath = options?.basePathParams === undefined
-        ? normalizeBasePath(options?.basePath)
-        : resolveBasePath(options.basePath, options.basePathParams).path;
-    return getRoutableRoutes(tree).map((node) => ({
-        stateId: node.stateId,
-        path: joinBasePath(basePath, node.fullPath),
-    }));
+* Returns the `{ stateId, path }` entries that a host router needs, so that it can
+* register the routes of a machine under a base path, and remove them again later.
+*
+* This function makes the routes dynamic. `getStateIdByPath` and `getPathByStateId`
+* answer the question "what is this URL?" at the moment of a navigation, but a host
+* that declares real route objects — a route tree of TanStack, a `RouteObject[]`, an
+* `addRoute` call of vue-router — needs the LIST in advance, and it needs that list
+* with the prefix of the mount. A registration of these paths, and a removal of them
+* when the machine unloads, keeps the route table of the host in step with the mount.
+*
+* `basePathParams` decides the form of each path, and both forms are useful:
+* - **Given** → a concrete path (`/abc123/play/profile/:userId`), for a route that
+*   the host adds at run time, after a loader resolved the mount.
+* - **Absent** → the pattern stays (`/:machineId/play/profile/:userId`), for a static
+*   route declaration of the host.
+*
+* The function ALWAYS keeps each `:param` segment that the machine declares itself:
+* those are the params that the route of the host must match.
+*
+* @param tree - The route tree of extractMachineRoutes()
+* @param options - The optional `{ basePath, basePathParams }`, the same option as the bridge takes.
+* Each `stateId` comes from the route tree, so it carries NO `#` prefix. A host that
+* keys its route table on the target of a `play.route` event adds the `#` itself,
+* because the event always carries the prefixed form.
+*
+* @returns One entry for each state with a route, in the order of the route tree.
+* @throws {InvalidBasePathError} For a base path that resolves to one concrete path never.
+* @throws {MissingBasePathParamError} When `basePathParams` is present and it omits a `:param`.
+*
+* @example
+* ```typescript
+* const tree = extractMachineRoutes(machine);
+*
+* // Concrete, for a route that the host adds after a loader resolved the mount
+* getRouteMappings(tree, { basePath: "/:machineId/play", basePathParams: { machineId: "abc123" } });
+* // [
+* //   { stateId: "app.home",    path: "/abc123/play" },
+* //   { stateId: "app.profile", path: "/abc123/play/profile/:userId" },
+* // ]
+*
+* // The pattern, for a static route declaration of the host
+* getRouteMappings(tree, { basePath: "/:machineId/play" });
+* // [{ stateId: "app.home", path: "/:machineId/play" }, ...]
+* ```
+*/
+var getRouteMappings = (tree, options) => {
+	const basePath = options?.basePathParams === void 0 ? normalizeBasePath(options?.basePath) : resolveBasePath(options.basePath, options.basePathParams).path;
+	return getRoutableRoutes(tree).map((node) => ({
+		stateId: node.stateId,
+		path: joinBasePath(basePath, node.fullPath)
+	}));
 };
+//#endregion
+export { getNavigableRoutes, getRoutableRoutes, getRouteMappings, getTransitionReachableRoutes, isRouteReachable, routeExists };
+
 //# sourceMappingURL=query.js.map

package/dist/xstate/query.js.map

@@ -1 +1 @@
-{"version":3,"file":"query.js","sourceRoot":"","sources":["../../src/xstate/query.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"query.js","names":[],"sources":["../../src/xstate/query.ts"],"sourcesContent":["import {\n\tjoinBasePath,\n\tnormalizeBasePath,\n\tresolveBasePath,\n\ttype BasePathOptions,\n} from \"@xmachines/play-url\";\nimport type { Graph, GraphNode } from \"@statelyai/graph\";\nimport { getSuccessors, hasNode, hasPath } from \"@statelyai/graph\";\nimport { ROOT_NODE_ID } from \"../build-tree.js\";\nimport type { RouteTree, RouteNode } from \"../types.js\";\nimport type { MachineNodeData, MachineEdgeData } from \"./machine-types.js\";\nimport type { MachineGraph } from \"./machine-to-graph.js\";\nimport type { RouteMapping } from \"../base-route-map.js\";\n\n/** A graph node whose state declares a route. The filter below proves the `route` field. */\ntype RoutableNodeData = MachineNodeData & { route: string };\n\n/**\n * Returns the successor nodes of a state that have a route: the states of a direct\n * transition edge that hold a `meta.route` field.\n *\n * `getTransitionReachableStateIds` and `getTransitionReachableRoutes` share this\n * walk. The function returns the complete nodes. Therefore each caller reads the\n * field that it needs: the stateId, or the raw route string.\n */\nconst getRoutableSuccessors = (\n\tgraph: Graph<MachineNodeData, MachineEdgeData>,\n\tstateId: string,\n): GraphNode<RoutableNodeData>[] =>\n\t// A state ID without a graph node, for example a state without a route or a state\n\t// that a person removed, is a normal result of \"nothing to reach\". The code tests\n\t// that case explicitly, and it matches no message of an error from a throw.\n\thasNode(graph, stateId)\n\t\t? getSuccessors(graph, stateId).filter(\n\t\t\t\t(n): n is GraphNode<RoutableNodeData> => n.data.route !== undefined,\n\t\t\t)\n\t\t: [];\n\n/**\n * Returns every route of a navigation from the given state\n *\n * The function returns the child routes of the state. A later version also returns\n * the sibling routes of a transition.\n *\n * @param tree - The route tree, from extractMachineRoutes()\n * @param stateId - The ID of the current state\n * @returns The array of the route nodes that the state can reach\n *\n * @example\n * ```typescript\n * const tree = extractMachineRoutes(machine);\n * const routes = getNavigableRoutes(tree, 'dashboard');\n * // [{ id: 'overview', path: '/overview', ... }, { id: 'settings', ... }]\n * ```\n */\nexport const getNavigableRoutes = (tree: RouteTree<MachineGraph>, stateId: string): RouteNode[] => {\n\tconst node = tree.byStateId.get(stateId);\n\tif (!node) return [];\n\n\tconst results = [...node.children]; // The direct child routes\n\n\t// With a graph, the result also holds each route that a transition can reach.\n\t// The code looks each node up by its state ID: a graph node carries the RAW\n\t// meta.route string, and that string can be relative, for example \"detail\". The\n\t// keys of tree.byPath are the resolved fullPath values, for example\n\t// \"/section/detail\". A lookup by the path therefore loses every relative route in\n\t// silence. A state ID is unambiguous in both structures.\n\tif (tree.graph) {\n\t\tconst reachableStateIds = getTransitionReachableStateIds(tree.graph, stateId);\n\t\tconst existingPaths = new Set(results.map((r) => r.fullPath));\n\n\t\tfor (const reachableStateId of reachableStateIds) {\n\t\t\tconst routeNode = tree.byStateId.get(reachableStateId);\n\t\t\tif (routeNode && !existingPaths.has(routeNode.fullPath)) {\n\t\t\t\tresults.push(routeNode);\n\t\t\t\texistingPaths.add(routeNode.fullPath);\n\t\t\t}\n\t\t}\n\t}\n\n\treturn results;\n};\n\n/**\n * Returns the state IDs of the states with a route that a transition from a state\n * can reach.\n *\n * The walk is the same as the walk of `getTransitionReachableRoutes`, but this\n * function returns the state IDs, and not the raw `meta.route` strings. A caller\n * therefore resolves each node through `tree.byStateId`, with no doubt between a raw\n * path and a resolved path.\n */\nconst getTransitionReachableStateIds = (\n\tgraph: Graph<MachineNodeData, MachineEdgeData>,\n\tstateId: string,\n): string[] => {\n\treturn getRoutableSuccessors(graph, stateId).map((n) => n.data.stateId);\n};\n\n/**\n * Returns every route of the tree that has a route, in one flat array\n *\n * The function returns each route with a `meta.route` field. It returns no state\n * without a route, and no synthetic root node. Use it to generate a router\n * configuration in a framework adapter dynamically.\n *\n * @param tree - The route tree, from extractMachineRoutes()\n * @returns The array of the route nodes with a route, with their path and their stateId\n *\n * @example\n * ```typescript\n * const tree = extractMachineRoutes(machine);\n * const routes = getRoutableRoutes(tree);\n * // [\n * //   { path: '/', stateId: '#home', ... },\n * //   { path: '/about', stateId: '#about', ... },\n * //   { path: '/profile/:userId', stateId: '#profile', ... }\n * // ]\n * ```\n */\nexport const getRoutableRoutes = (tree: RouteTree): RouteNode[] => {\n\tconst routes: RouteNode[] = [];\n\n\tfor (const node of tree.byStateId.values()) {\n\t\t// Keep the nodes with a route, which means the nodes with a meta.route field, and skip the synthetic root\n\t\tif (node.routable && node.id !== ROOT_NODE_ID) {\n\t\t\troutes.push(node);\n\t\t}\n\t}\n\n\treturn routes;\n};\n\n/**\n * Tells you if a route path is in the tree\n *\n * The function tests if the path has a state with a `meta.route` field.\n *\n * @param tree - The route tree, from extractMachineRoutes()\n * @param path - The complete route path, for example '/dashboard/settings'\n * @returns true when the tree holds the path. In every other case, false\n */\nexport const routeExists = (tree: RouteTree, path: string): boolean => {\n\treturn tree.byPath.has(path);\n};\n\n/**\n * Returns the routes that a transition from the current state can reach\n *\n * The function uses the successor algorithm of @statelyai/graph. It finds every\n * state of a direct transition edge from the given state, then it keeps the states\n * with a route.\n *\n * The values of the return are the RAW `meta.route` strings of the machine. The\n * function does NOT resolve a relative route, for example `\"detail\"`, to a complete\n * path, and such a value is therefore no key of `tree.byPath`. For a resolved\n * `RouteNode`, use `getNavigableRoutes`: that function resolves each state that the\n * transition reaches through `tree.byStateId`.\n *\n * @param graph - The machine graph, from RouteTree.graph\n * @param stateId - The ID of the current state, for example \"test.home\"\n * @returns The array of the raw route strings that a transition can reach\n *\n * @example\n * ```typescript\n * const tree = extractMachineRoutes(machine);\n * if (tree.graph) {\n *   const reachable = getTransitionReachableRoutes(tree.graph, 'auth.loggedIn');\n *   // ['/dashboard', '/settings'] — the routes that a transition can reach\n * }\n * ```\n */\nexport const getTransitionReachableRoutes = (\n\tgraph: Graph<MachineNodeData, MachineEdgeData>,\n\tstateId: string,\n): string[] => {\n\treturn getRoutableSuccessors(graph, stateId).map((n) => n.data.route);\n};\n\n/**\n * Tells you if a transition from the current state can reach a route\n *\n * The function uses the path search of @statelyai/graph. It decides if a chain of\n * transition edges is present from the state of the origin to the state of the\n * target.\n *\n * @param graph - The machine graph, from RouteTree.graph\n * @param fromStateId - The ID of the state of the origin\n * @param toStateId - The ID of the state of the target\n * @returns true when a transition path is present. In every other case, false\n *\n * @example\n * ```typescript\n * const tree = extractMachineRoutes(machine);\n * if (tree.graph) {\n *   const canReach = isRouteReachable(tree.graph, 'auth.login', 'auth.dashboard');\n *   // it is true when a transition path from login to dashboard is present\n * }\n * ```\n */\nexport const isRouteReachable = (\n\tgraph: Graph<MachineNodeData, MachineEdgeData>,\n\tfromStateId: string,\n\ttoStateId: string,\n): boolean => {\n\t// An absent endpoint is a normal result of \"not reachable\".\n\treturn hasNode(graph, fromStateId) && hasNode(graph, toStateId)\n\t\t? hasPath(graph, fromStateId, toStateId)\n\t\t: false;\n};\n\n/**\n * Returns the `{ stateId, path }` entries that a host router needs, so that it can\n * register the routes of a machine under a base path, and remove them again later.\n *\n * This function makes the routes dynamic. `getStateIdByPath` and `getPathByStateId`\n * answer the question \"what is this URL?\" at the moment of a navigation, but a host\n * that declares real route objects — a route tree of TanStack, a `RouteObject[]`, an\n * `addRoute` call of vue-router — needs the LIST in advance, and it needs that list\n * with the prefix of the mount. A registration of these paths, and a removal of them\n * when the machine unloads, keeps the route table of the host in step with the mount.\n *\n * `basePathParams` decides the form of each path, and both forms are useful:\n * - **Given** → a concrete path (`/abc123/play/profile/:userId`), for a route that\n *   the host adds at run time, after a loader resolved the mount.\n * - **Absent** → the pattern stays (`/:machineId/play/profile/:userId`), for a static\n *   route declaration of the host.\n *\n * The function ALWAYS keeps each `:param` segment that the machine declares itself:\n * those are the params that the route of the host must match.\n *\n * @param tree - The route tree of extractMachineRoutes()\n * @param options - The optional `{ basePath, basePathParams }`, the same option as the bridge takes.\n * Each `stateId` comes from the route tree, so it carries NO `#` prefix. A host that\n * keys its route table on the target of a `play.route` event adds the `#` itself,\n * because the event always carries the prefixed form.\n *\n * @returns One entry for each state with a route, in the order of the route tree.\n * @throws {InvalidBasePathError} For a base path that resolves to one concrete path never.\n * @throws {MissingBasePathParamError} When `basePathParams` is present and it omits a `:param`.\n *\n * @example\n * ```typescript\n * const tree = extractMachineRoutes(machine);\n *\n * // Concrete, for a route that the host adds after a loader resolved the mount\n * getRouteMappings(tree, { basePath: \"/:machineId/play\", basePathParams: { machineId: \"abc123\" } });\n * // [\n * //   { stateId: \"app.home\",    path: \"/abc123/play\" },\n * //   { stateId: \"app.profile\", path: \"/abc123/play/profile/:userId\" },\n * // ]\n *\n * // The pattern, for a static route declaration of the host\n * getRouteMappings(tree, { basePath: \"/:machineId/play\" });\n * // [{ stateId: \"app.home\", path: \"/:machineId/play\" }, ...]\n * ```\n */\nexport const getRouteMappings = (tree: RouteTree, options?: BasePathOptions): RouteMapping[] => {\n\t// With the params, resolve the prefix to a concrete path. Without them, keep the\n\t// pattern, so that a host declares its routes statically and substitutes each param\n\t// itself.\n\tconst basePath =\n\t\toptions?.basePathParams === undefined\n\t\t\t? normalizeBasePath(options?.basePath)\n\t\t\t: resolveBasePath(options.basePath, options.basePathParams).path;\n\n\treturn getRoutableRoutes(tree).map((node) => ({\n\t\tstateId: node.stateId,\n\t\tpath: joinBasePath(basePath, node.fullPath),\n\t}));\n};\n"],"mappings":";;;;;;;;;;;;AAyBA,IAAM,yBACL,OACA,YAKA,QAAQ,OAAO,OAAO,IACnB,cAAc,OAAO,OAAO,CAAC,CAAC,QAC7B,MAAwC,EAAE,KAAK,UAAU,KAAA,CAC3D,IACC,CAAC;;;;;;;;;;;;;;;;;;AAmBL,IAAa,sBAAsB,MAA+B,YAAiC;CAClG,MAAM,OAAO,KAAK,UAAU,IAAI,OAAO;CACvC,IAAI,CAAC,MAAM,OAAO,CAAC;CAEnB,MAAM,UAAU,CAAC,GAAG,KAAK,QAAQ;CAQjC,IAAI,KAAK,OAAO;EACf,MAAM,oBAAoB,+BAA+B,KAAK,OAAO,OAAO;EAC5E,MAAM,gBAAgB,IAAI,IAAI,QAAQ,KAAK,MAAM,EAAE,QAAQ,CAAC;EAE5D,KAAK,MAAM,oBAAoB,mBAAmB;GACjD,MAAM,YAAY,KAAK,UAAU,IAAI,gBAAgB;GACrD,IAAI,aAAa,CAAC,cAAc,IAAI,UAAU,QAAQ,GAAG;IACxD,QAAQ,KAAK,SAAS;IACtB,cAAc,IAAI,UAAU,QAAQ;GACrC;EACD;CACD;CAEA,OAAO;AACR;;;;;;;;;;AAWA,IAAM,kCACL,OACA,YACc;CACd,OAAO,sBAAsB,OAAO,OAAO,CAAC,CAAC,KAAK,MAAM,EAAE,KAAK,OAAO;AACvE;;;;;;;;;;;;;;;;;;;;;;AAuBA,IAAa,qBAAqB,SAAiC;CAClE,MAAM,SAAsB,CAAC;CAE7B,KAAK,MAAM,QAAQ,KAAK,UAAU,OAAO,GAExC,IAAI,KAAK,YAAY,KAAK,OAAA,YACzB,OAAO,KAAK,IAAI;CAIlB,OAAO;AACR;;;;;;;;;;AAWA,IAAa,eAAe,MAAiB,SAA0B;CACtE,OAAO,KAAK,OAAO,IAAI,IAAI;AAC5B;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,IAAa,gCACZ,OACA,YACc;CACd,OAAO,sBAAsB,OAAO,OAAO,CAAC,CAAC,KAAK,MAAM,EAAE,KAAK,KAAK;AACrE;;;;;;;;;;;;;;;;;;;;;;AAuBA,IAAa,oBACZ,OACA,aACA,cACa;CAEb,OAAO,QAAQ,OAAO,WAAW,KAAK,QAAQ,OAAO,SAAS,IAC3D,QAAQ,OAAO,aAAa,SAAS,IACrC;AACJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDA,IAAa,oBAAoB,MAAiB,YAA8C;CAI/F,MAAM,WACL,SAAS,mBAAmB,KAAA,IACzB,kBAAkB,SAAS,QAAQ,IACnC,gBAAgB,QAAQ,UAAU,QAAQ,cAAc,CAAC,CAAC;CAE9D,OAAO,kBAAkB,IAAI,CAAC,CAAC,KAAK,UAAU;EAC7C,SAAS,KAAK;EACd,MAAM,aAAa,UAAU,KAAK,QAAQ;CAC3C,EAAE;AACH"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xmachines/play-router",
-  "version": "6.0.0",
+  "version": "7.0.0",
   "description": "Route maps, the router bridge base and the Routable capability of @xmachines/play. It names no state machine; the machine half is the ./xstate subpath.",
   "keywords": [
     "routing",
@@ -53,29 +53,29 @@
     "test:coverage": "vitest run --coverage"
   },
   "dependencies": {
-    "@xmachines/play-url": "6.0.0"
+    "@xmachines/play-url": "7.0.0"
   },
   "devDependencies": {
-    "@statelyai/graph": "^2.4.0",
+    "@statelyai/graph": "^2.5.0",
     "@testing-library/jest-dom": "^7.0.1",
-    "@types/node": "^26.6.2",
-    "@vitest/browser-playwright": "^5.0.1",
-    "@xmachines/core": "6.0.0",
-    "@xmachines/play": "6.0.0",
-    "@xmachines/play-atom": "6.0.0",
-    "@xmachines/play-view": "6.0.0",
-    "oxfmt": "^0.70.0",
-    "oxlint": "^1.85.0",
+    "@types/node": "^26.6.4",
+    "@vitest/browser-playwright": "^5.0.3",
+    "@xmachines/core": "7.0.0",
+    "@xmachines/play": "7.0.0",
+    "@xmachines/play-atom": "7.0.0",
+    "@xmachines/play-view": "7.0.0",
+    "oxfmt": "^0.71.0",
+    "oxlint": "^1.86.0",
     "typescript": "^5.9.3 || ^6.0.3",
-    "vite": "^8.3.0",
-    "vitest": "^5.0.1",
+    "vite": "^8.3.2",
+    "vitest": "^5.0.3",
     "xstate": "^5.33.0"
   },
   "peerDependencies": {
     "@statelyai/graph": "^2.4.0",
-    "@xmachines/core": "6.0.0",
-    "@xmachines/play": "6.0.0",
-    "@xmachines/play-atom": "6.0.0",
+    "@xmachines/core": "7.0.0",
+    "@xmachines/play": "7.0.0",
+    "@xmachines/play-atom": "7.0.0",
     "xstate": "^5.33.0"
   },
   "peerDependenciesMeta": {

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,mEAAmE;AACnE,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAG3D,wHAAwH;AACxH,OAAO,EAAE,mBAAmB,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAGzF,sBAAsB;AACtB,OAAO,EACN,mBAAmB,EACnB,mBAAmB,EACnB,qBAAqB,GACrB,MAAM,sBAAsB,CAAC;AAG9B,mFAAmF;AACnF,gFAAgF;AAChF,sFAAsF;AACtF,mBAAmB;AACnB,OAAO,EACN,iBAAiB,EACjB,eAAe,EACf,aAAa,EACb,YAAY,EACZ,YAAY,GACZ,MAAM,qBAAqB,CAAC;AAE7B,kFAAkF;AAClF,uFAAuF;AACvF,OAAO,EACN,oBAAoB,EACpB,cAAc,EACd,YAAY,EACZ,aAAa,EACb,sBAAsB,EACtB,gBAAgB,EAChB,aAAa,GAQb,MAAM,qBAAqB,CAAC;AAE7B,qFAAqF;AACrF,sFAAsF;AACtF,gFAAgF;AAChF,OAAO,EACN,iBAAiB,EACjB,QAAQ,EACR,sBAAsB,EACtB,kBAAkB,EAClB,qBAAqB,GACrB,MAAM,yBAAyB,CAAC;AAyBjC,8DAA8D;AAC9D,OAAO,EAAE,QAAQ,EAAqB,MAAM,qBAAqB,CAAC;AAElE,kFAAkF;AAClF,OAAO,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAEzE,mFAAmF;AACnF,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEjE,yFAAyF;AACzF,iFAAiF;AACjF,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/types.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/dist/xstate/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","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;AAGvD,OAAO,EACN,kBAAkB,EAClB,iBAAiB,EACjB,WAAW,EACX,4BAA4B,EAC5B,gBAAgB,EAChB,gBAAgB,GAChB,MAAM,YAAY,CAAC"}

package/dist/xstate/machine-types.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=machine-types.js.map

package/dist/xstate/machine-types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"machine-types.js","sourceRoot":"","sources":["../../src/xstate/machine-types.ts"],"names":[],"mappings":""}