@xmachines/play-router 6.1.0 → 7.0.0

package/dist/build-tree.js

@@ -1,101 +1,89 @@
 import { detectDuplicateRoutes } from "./validate-routes.js";
+//#region packages/play-router/src/build-tree.ts
 /**
- * The ID and the state ID of the synthetic root node of every `RouteTree`.
- *
- * `buildRouteTree` always makes this node, and no state of a machine declares it. It
- * gives the tree one parent for each absolute route, and it holds `routable: false`.
- *
- * A consumer that walks a tree must SKIP this node. `createRouteMapFromTree` skips it,
- * and `getRoutableRoutes` of `@xmachines/play-router/xstate` skips it. A walk that keeps
- * it maps the path `/` to a state that the machine does not hold.
- */
-export const ROOT_NODE_ID = "__root__";
+* The ID and the state ID of the synthetic root node of every `RouteTree`.
+*
+* `buildRouteTree` always makes this node, and no state of a machine declares it. It
+* gives the tree one parent for each absolute route, and it holds `routable: false`.
+*
+* A consumer that walks a tree must SKIP this node. `createRouteMapFromTree` skips it,
+* and `getRoutableRoutes` of `@xmachines/play-router/xstate` skips it. A walk that keeps
+* it maps the path `/` to a state that the machine does not hold.
+*/
+var ROOT_NODE_ID = "__root__";
 /**
- * Builds the hierarchical route tree from the flat list of the routes
- *
- * The function makes a nested tree, and it keeps the parent-child relation of the
- * states. An absolute route becomes a route of the top level, and a relative route
- * goes below its parent. The function also makes the maps of both directions, for
- * the lookup between a state ID and a path.
- *
- * The detection of a duplicate runs here, after the function resolved each relative
- * route against the complete path of its parent. Therefore two relative routes with
- * the same raw string below two different parents are valid, and two different raw
- * strings that resolve to the same complete path are not: those two overwrite each
- * other in `byPath` in silence.
- *
- * `TGraph` names the type of the graph that a CALLER attaches afterwards. The builder
- * attaches none: it reads a list of routes and writes the maps of the tree.
- * `extractMachineRoutes` of `@xmachines/play-router/xstate` binds it to `MachineGraph`.
- *
- * @param routes - The flat list of the RouteInfo objects, from the extraction
- * @returns The RouteTree, with its root, its byStateId map, and its byPath map
- * @throws {DuplicateRoutePathError} When two states resolve to the same complete path
- */
-export const buildRouteTree = (routes) => {
-    // 1. Create the root node
-    const root = {
-        id: ROOT_NODE_ID,
-        path: "/",
-        fullPath: "/",
-        stateId: ROOT_NODE_ID,
-        routable: false, // The root is a state without a route
-        children: [],
-        parent: null,
-        metadata: "", // The synthetic root has no route, and therefore no real route metadata
-    };
-    // 2. Initialize the maps
-    const byStateId = new Map([[root.stateId, root]]);
-    const byPath = new Map([[root.fullPath, root]]);
-    // 3. Sort the routes by their depth. The shallowest route comes first, for the link to each parent
-    const sorted = routes.toSorted((a, b) => a.statePath.length - b.statePath.length);
-    // 4. Build the tree, and collect each node for the detection of a duplicate resolved path
-    const insertedNodes = [];
-    for (const route of sorted) {
-        // Find the parent, and walk up the state path.
-        // Each entry of statePath is a complete dotted stateId, for example
-        // "chain.app.section". Therefore the code tests each ancestor stateId directly,
-        // from the end of the list.
-        let parentNode = root;
-        for (let i = route.statePath.length - 2; i >= 0; i--) {
-            const parentStateId = route.statePath[i]; // nosemgrep: gitlab.eslint.detect-object-injection
-            if (parentStateId === undefined)
-                continue;
-            const candidate = byStateId.get(parentStateId);
-            if (candidate !== undefined) {
-                parentNode = candidate;
-                break;
-            }
-        }
-        // Build the complete path
-        const fullPath = route.isAbsolute
-            ? route.routePath
-            : `${parentNode.fullPath}/${route.routePath}`.replace(/\/+/g, "/");
-        // Create the node
-        const node = {
-            id: route.stateId,
-            path: route.routePath,
-            fullPath,
-            stateId: route.stateId,
-            routable: route.routable,
-            children: [],
-            parent: parentNode,
-            metadata: route.metadata,
-        };
-        // Add the pattern, when one is present
-        if (route.pattern) {
-            node.pattern = route.pattern;
-        }
-        // Link the node to its parent
-        parentNode.children.push(node);
-        // Put the node in the maps, for the lookup in both directions
-        byStateId.set(node.stateId, node);
-        byPath.set(node.fullPath, node);
-        insertedNodes.push(node);
-    }
-    // 5. Refuse a collision of two resolved complete paths. A silent overwrite in
-    // byPath leaves one state without a URL.
-    detectDuplicateRoutes(insertedNodes);
-    return { root, byStateId, byPath };
+* Builds the hierarchical route tree from the flat list of the routes
+*
+* The function makes a nested tree, and it keeps the parent-child relation of the
+* states. An absolute route becomes a route of the top level, and a relative route
+* goes below its parent. The function also makes the maps of both directions, for
+* the lookup between a state ID and a path.
+*
+* The detection of a duplicate runs here, after the function resolved each relative
+* route against the complete path of its parent. Therefore two relative routes with
+* the same raw string below two different parents are valid, and two different raw
+* strings that resolve to the same complete path are not: those two overwrite each
+* other in `byPath` in silence.
+*
+* `TGraph` names the type of the graph that a CALLER attaches afterwards. The builder
+* attaches none: it reads a list of routes and writes the maps of the tree.
+* `extractMachineRoutes` of `@xmachines/play-router/xstate` binds it to `MachineGraph`.
+*
+* @param routes - The flat list of the RouteInfo objects, from the extraction
+* @returns The RouteTree, with its root, its byStateId map, and its byPath map
+* @throws {DuplicateRoutePathError} When two states resolve to the same complete path
+*/
+var buildRouteTree = (routes) => {
+	const root = {
+		id: ROOT_NODE_ID,
+		path: "/",
+		fullPath: "/",
+		stateId: ROOT_NODE_ID,
+		routable: false,
+		children: [],
+		parent: null,
+		metadata: ""
+	};
+	const byStateId = /* @__PURE__ */ new Map([[root.stateId, root]]);
+	const byPath = /* @__PURE__ */ new Map([[root.fullPath, root]]);
+	const sorted = routes.toSorted((a, b) => a.statePath.length - b.statePath.length);
+	const insertedNodes = [];
+	for (const route of sorted) {
+		let parentNode = root;
+		for (let i = route.statePath.length - 2; i >= 0; i--) {
+			const parentStateId = route.statePath[i];
+			if (parentStateId === void 0) continue;
+			const candidate = byStateId.get(parentStateId);
+			if (candidate !== void 0) {
+				parentNode = candidate;
+				break;
+			}
+		}
+		const fullPath = route.isAbsolute ? route.routePath : `${parentNode.fullPath}/${route.routePath}`.replace(/\/+/g, "/");
+		const node = {
+			id: route.stateId,
+			path: route.routePath,
+			fullPath,
+			stateId: route.stateId,
+			routable: route.routable,
+			children: [],
+			parent: parentNode,
+			metadata: route.metadata
+		};
+		if (route.pattern) node.pattern = route.pattern;
+		parentNode.children.push(node);
+		byStateId.set(node.stateId, node);
+		byPath.set(node.fullPath, node);
+		insertedNodes.push(node);
+	}
+	detectDuplicateRoutes(insertedNodes);
+	return {
+		root,
+		byStateId,
+		byPath
+	};
 };
+//#endregion
+export { ROOT_NODE_ID, buildRouteTree };
+
 //# sourceMappingURL=build-tree.js.map

package/dist/build-tree.js.map

@@ -1 +1 @@
-{"version":3,"file":"build-tree.js","sourceRoot":"","sources":["../src/build-tree.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"build-tree.js","names":[],"sources":["../src/build-tree.ts"],"sourcesContent":["import type { RouteInfo, RouteNode, RouteTree } from \"./types.js\";\nimport { detectDuplicateRoutes } from \"./validate-routes.js\";\n\n/**\n * The ID and the state ID of the synthetic root node of every `RouteTree`.\n *\n * `buildRouteTree` always makes this node, and no state of a machine declares it. It\n * gives the tree one parent for each absolute route, and it holds `routable: false`.\n *\n * A consumer that walks a tree must SKIP this node. `createRouteMapFromTree` skips it,\n * and `getRoutableRoutes` of `@xmachines/play-router/xstate` skips it. A walk that keeps\n * it maps the path `/` to a state that the machine does not hold.\n */\nexport const ROOT_NODE_ID = \"__root__\";\n\n/**\n * Builds the hierarchical route tree from the flat list of the routes\n *\n * The function makes a nested tree, and it keeps the parent-child relation of the\n * states. An absolute route becomes a route of the top level, and a relative route\n * goes below its parent. The function also makes the maps of both directions, for\n * the lookup between a state ID and a path.\n *\n * The detection of a duplicate runs here, after the function resolved each relative\n * route against the complete path of its parent. Therefore two relative routes with\n * the same raw string below two different parents are valid, and two different raw\n * strings that resolve to the same complete path are not: those two overwrite each\n * other in `byPath` in silence.\n *\n * `TGraph` names the type of the graph that a CALLER attaches afterwards. The builder\n * attaches none: it reads a list of routes and writes the maps of the tree.\n * `extractMachineRoutes` of `@xmachines/play-router/xstate` binds it to `MachineGraph`.\n *\n * @param routes - The flat list of the RouteInfo objects, from the extraction\n * @returns The RouteTree, with its root, its byStateId map, and its byPath map\n * @throws {DuplicateRoutePathError} When two states resolve to the same complete path\n */\nexport const buildRouteTree = <TGraph = unknown>(routes: RouteInfo[]): RouteTree<TGraph> => {\n\t// 1. Create the root node\n\tconst root: RouteNode = {\n\t\tid: ROOT_NODE_ID,\n\t\tpath: \"/\",\n\t\tfullPath: \"/\",\n\t\tstateId: ROOT_NODE_ID,\n\t\troutable: false, // The root is a state without a route\n\t\tchildren: [],\n\t\tparent: null,\n\t\tmetadata: \"\", // The synthetic root has no route, and therefore no real route metadata\n\t};\n\n\t// 2. Initialize the maps\n\tconst byStateId = new Map<string, RouteNode>([[root.stateId, root]]);\n\tconst byPath = new Map<string, RouteNode>([[root.fullPath, root]]);\n\n\t// 3. Sort the routes by their depth. The shallowest route comes first, for the link to each parent\n\tconst sorted = routes.toSorted((a, b) => a.statePath.length - b.statePath.length);\n\n\t// 4. Build the tree, and collect each node for the detection of a duplicate resolved path\n\tconst insertedNodes: RouteNode[] = [];\n\tfor (const route of sorted) {\n\t\t// Find the parent, and walk up the state path.\n\t\t// Each entry of statePath is a complete dotted stateId, for example\n\t\t// \"chain.app.section\". Therefore the code tests each ancestor stateId directly,\n\t\t// from the end of the list.\n\t\tlet parentNode = root;\n\t\tfor (let i = route.statePath.length - 2; i >= 0; i--) {\n\t\t\tconst parentStateId = route.statePath[i]; // nosemgrep: gitlab.eslint.detect-object-injection\n\t\t\tif (parentStateId === undefined) continue;\n\t\t\tconst candidate = byStateId.get(parentStateId);\n\t\t\tif (candidate !== undefined) {\n\t\t\t\tparentNode = candidate;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\n\t\t// Build the complete path\n\t\tconst fullPath = route.isAbsolute\n\t\t\t? route.routePath\n\t\t\t: `${parentNode.fullPath}/${route.routePath}`.replace(/\\/+/g, \"/\");\n\n\t\t// Create the node\n\t\tconst node: RouteNode = {\n\t\t\tid: route.stateId,\n\t\t\tpath: route.routePath,\n\t\t\tfullPath,\n\t\t\tstateId: route.stateId,\n\t\t\troutable: route.routable,\n\t\t\tchildren: [],\n\t\t\tparent: parentNode,\n\t\t\tmetadata: route.metadata,\n\t\t};\n\n\t\t// Add the pattern, when one is present\n\t\tif (route.pattern) {\n\t\t\tnode.pattern = route.pattern;\n\t\t}\n\n\t\t// Link the node to its parent\n\t\tparentNode.children.push(node);\n\n\t\t// Put the node in the maps, for the lookup in both directions\n\t\tbyStateId.set(node.stateId, node);\n\t\tbyPath.set(node.fullPath, node);\n\t\tinsertedNodes.push(node);\n\t}\n\n\t// 5. Refuse a collision of two resolved complete paths. A silent overwrite in\n\t// byPath leaves one state without a URL.\n\tdetectDuplicateRoutes(insertedNodes);\n\n\treturn { root, byStateId, byPath };\n};\n"],"mappings":";;;;;;;;;;;;AAaA,IAAa,eAAe;;;;;;;;;;;;;;;;;;;;;;;AAwB5B,IAAa,kBAAoC,WAA2C;CAE3F,MAAM,OAAkB;EACvB,IAAI;EACJ,MAAM;EACN,UAAU;EACV,SAAS;EACT,UAAU;EACV,UAAU,CAAC;EACX,QAAQ;EACR,UAAU;CACX;CAGA,MAAM,4BAAY,IAAI,IAAuB,CAAC,CAAC,KAAK,SAAS,IAAI,CAAC,CAAC;CACnE,MAAM,yBAAS,IAAI,IAAuB,CAAC,CAAC,KAAK,UAAU,IAAI,CAAC,CAAC;CAGjE,MAAM,SAAS,OAAO,UAAU,GAAG,MAAM,EAAE,UAAU,SAAS,EAAE,UAAU,MAAM;CAGhF,MAAM,gBAA6B,CAAC;CACpC,KAAK,MAAM,SAAS,QAAQ;EAK3B,IAAI,aAAa;EACjB,KAAK,IAAI,IAAI,MAAM,UAAU,SAAS,GAAG,KAAK,GAAG,KAAK;GACrD,MAAM,gBAAgB,MAAM,UAAU;GACtC,IAAI,kBAAkB,KAAA,GAAW;GACjC,MAAM,YAAY,UAAU,IAAI,aAAa;GAC7C,IAAI,cAAc,KAAA,GAAW;IAC5B,aAAa;IACb;GACD;EACD;EAGA,MAAM,WAAW,MAAM,aACpB,MAAM,YACN,GAAG,WAAW,SAAS,GAAG,MAAM,YAAY,QAAQ,QAAQ,GAAG;EAGlE,MAAM,OAAkB;GACvB,IAAI,MAAM;GACV,MAAM,MAAM;GACZ;GACA,SAAS,MAAM;GACf,UAAU,MAAM;GAChB,UAAU,CAAC;GACX,QAAQ;GACR,UAAU,MAAM;EACjB;EAGA,IAAI,MAAM,SACT,KAAK,UAAU,MAAM;EAItB,WAAW,SAAS,KAAK,IAAI;EAG7B,UAAU,IAAI,KAAK,SAAS,IAAI;EAChC,OAAO,IAAI,KAAK,UAAU,IAAI;EAC9B,cAAc,KAAK,IAAI;CACxB;CAIA,sBAAsB,aAAa;CAEnC,OAAO;EAAE;EAAM;EAAW;CAAO;AAClC"}

package/dist/create-route-map-from-tree.js

@@ -1,51 +1,54 @@
 import { RouteMap } from "./base-route-map.js";
-import { ROOT_NODE_ID } from "./build-tree.js";
+import "./build-tree.js";
+//#region packages/play-router/src/create-route-map-from-tree.ts
 /**
- * Creates a `RouteMap` from the node structure of a `RouteTree`.
- *
- * A framework router adapter uses this function when it holds a `RouteTree`, for example
- * from `extractMachineRoutes()` of `@xmachines/play-router/xstate`, and not when it calls
- * `createRouteMap()` of that package directly.
- *
- * The function walks every node, and it collects the pairs
- * `{ stateId: node.id, path: node.fullPath }`. `node.fullPath` is always the
- * absolute resolved path, for example `"/dashboard/overview"`, and `RouteMap` needs
- * that path for the match of a browser URL. `createRouteMap(machine)` behaves in the
- * same way, because it also uses `node.fullPath`.
- *
- * The walk SKIPS the synthetic root node. `buildRouteTree` makes that node to hold each
- * absolute route, and no state of a machine declares it. `createRouteMap` skips it as
- * well, through `getRoutableRoutes`, and the two functions therefore answer the same map
- * for the same tree.
- *
- * @param routeTree - A `RouteTree`, as `extractMachineRoutes()` returns it.
- * @param options - The optional configuration, for example `{ pathCache }` to replace the LRU cache of the resolved paths.
- * @returns A `RouteMap` for each adapter on `RouterBridgeBase`.
- *
- * @example
- * ```typescript
- * // The preferred form — one call for an XState machine:
- * import { createRouteMap } from '@xmachines/play-router/xstate';
- * const routeMap = createRouteMap(machine); // it takes an AnyStateMachine
- *
- * // The two-step form, for a framework adapter that works with a route tree:
- * import { createRouteMapFromTree } from '@xmachines/play-router';
- * import { extractMachineRoutes } from '@xmachines/play-router/xstate';
- * const routeTree = extractMachineRoutes(machine);
- * const routeMap = createRouteMapFromTree(routeTree); // it uses node.fullPath, which is absolute
- * ```
- */
-export function createRouteMapFromTree(routeTree, options) {
-    const routes = [];
-    function traverse(node) {
-        if (node.id && node.fullPath && node.id !== ROOT_NODE_ID) {
-            routes.push({ stateId: node.id, path: node.fullPath });
-        }
-        if (node.children) {
-            node.children.forEach(traverse);
-        }
-    }
-    traverse(routeTree.root);
-    return new RouteMap(routes, options);
+* Creates a `RouteMap` from the node structure of a `RouteTree`.
+*
+* A framework router adapter uses this function when it holds a `RouteTree`, for example
+* from `extractMachineRoutes()` of `@xmachines/play-router/xstate`, and not when it calls
+* `createRouteMap()` of that package directly.
+*
+* The function walks every node, and it collects the pairs
+* `{ stateId: node.id, path: node.fullPath }`. `node.fullPath` is always the
+* absolute resolved path, for example `"/dashboard/overview"`, and `RouteMap` needs
+* that path for the match of a browser URL. `createRouteMap(machine)` behaves in the
+* same way, because it also uses `node.fullPath`.
+*
+* The walk SKIPS the synthetic root node. `buildRouteTree` makes that node to hold each
+* absolute route, and no state of a machine declares it. `createRouteMap` skips it as
+* well, through `getRoutableRoutes`, and the two functions therefore answer the same map
+* for the same tree.
+*
+* @param routeTree - A `RouteTree`, as `extractMachineRoutes()` returns it.
+* @param options - The optional configuration, for example `{ pathCache }` to replace the LRU cache of the resolved paths.
+* @returns A `RouteMap` for each adapter on `RouterBridgeBase`.
+*
+* @example
+* ```typescript
+* // The preferred form — one call for an XState machine:
+* import { createRouteMap } from '@xmachines/play-router/xstate';
+* const routeMap = createRouteMap(machine); // it takes an AnyStateMachine
+*
+* // The two-step form, for a framework adapter that works with a route tree:
+* import { createRouteMapFromTree } from '@xmachines/play-router';
+* import { extractMachineRoutes } from '@xmachines/play-router/xstate';
+* const routeTree = extractMachineRoutes(machine);
+* const routeMap = createRouteMapFromTree(routeTree); // it uses node.fullPath, which is absolute
+* ```
+*/
+function createRouteMapFromTree(routeTree, options) {
+	const routes = [];
+	function traverse(node) {
+		if (node.id && node.fullPath && node.id !== "__root__") routes.push({
+			stateId: node.id,
+			path: node.fullPath
+		});
+		if (node.children) node.children.forEach(traverse);
+	}
+	traverse(routeTree.root);
+	return new RouteMap(routes, options);
 }
+//#endregion
+export { createRouteMapFromTree };
+
 //# sourceMappingURL=create-route-map-from-tree.js.map

package/dist/create-route-map-from-tree.js.map

@@ -1 +1 @@
-{"version":3,"file":"create-route-map-from-tree.js","sourceRoot":"","sources":["../src/create-route-map-from-tree.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,UAAU,sBAAsB,CAAC,SAAoB,EAAE,OAAyB;IACrF,MAAM,MAAM,GAA6C,EAAE,CAAC;IAE5D,SAAS,QAAQ,CAAC,IAAe;QAChC,IAAI,IAAI,CAAC,EAAE,IAAI,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,EAAE,KAAK,YAAY,EAAE,CAAC;YAC1D,MAAM,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC;QACxD,CAAC;QACD,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;YACnB,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QACjC,CAAC;IACF,CAAC;IAED,QAAQ,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;IACzB,OAAO,IAAI,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AACtC,CAAC"}
+{"version":3,"file":"create-route-map-from-tree.js","names":[],"sources":["../src/create-route-map-from-tree.ts"],"sourcesContent":["import type { RouteTree, RouteNode, RouteMapOptions } from \"./types.js\";\nimport { RouteMap } from \"./base-route-map.js\";\nimport { ROOT_NODE_ID } from \"./build-tree.js\";\n\n/**\n * Creates a `RouteMap` from the node structure of a `RouteTree`.\n *\n * A framework router adapter uses this function when it holds a `RouteTree`, for example\n * from `extractMachineRoutes()` of `@xmachines/play-router/xstate`, and not when it calls\n * `createRouteMap()` of that package directly.\n *\n * The function walks every node, and it collects the pairs\n * `{ stateId: node.id, path: node.fullPath }`. `node.fullPath` is always the\n * absolute resolved path, for example `\"/dashboard/overview\"`, and `RouteMap` needs\n * that path for the match of a browser URL. `createRouteMap(machine)` behaves in the\n * same way, because it also uses `node.fullPath`.\n *\n * The walk SKIPS the synthetic root node. `buildRouteTree` makes that node to hold each\n * absolute route, and no state of a machine declares it. `createRouteMap` skips it as\n * well, through `getRoutableRoutes`, and the two functions therefore answer the same map\n * for the same tree.\n *\n * @param routeTree - A `RouteTree`, as `extractMachineRoutes()` returns it.\n * @param options - The optional configuration, for example `{ pathCache }` to replace the LRU cache of the resolved paths.\n * @returns A `RouteMap` for each adapter on `RouterBridgeBase`.\n *\n * @example\n * ```typescript\n * // The preferred form — one call for an XState machine:\n * import { createRouteMap } from '@xmachines/play-router/xstate';\n * const routeMap = createRouteMap(machine); // it takes an AnyStateMachine\n *\n * // The two-step form, for a framework adapter that works with a route tree:\n * import { createRouteMapFromTree } from '@xmachines/play-router';\n * import { extractMachineRoutes } from '@xmachines/play-router/xstate';\n * const routeTree = extractMachineRoutes(machine);\n * const routeMap = createRouteMapFromTree(routeTree); // it uses node.fullPath, which is absolute\n * ```\n */\nexport function createRouteMapFromTree(routeTree: RouteTree, options?: RouteMapOptions): RouteMap {\n\tconst routes: Array<{ stateId: string; path: string }> = [];\n\n\tfunction traverse(node: RouteNode): void {\n\t\tif (node.id && node.fullPath && node.id !== ROOT_NODE_ID) {\n\t\t\troutes.push({ stateId: node.id, path: node.fullPath });\n\t\t}\n\t\tif (node.children) {\n\t\t\tnode.children.forEach(traverse);\n\t\t}\n\t}\n\n\ttraverse(routeTree.root);\n\treturn new RouteMap(routes, options);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,SAAgB,uBAAuB,WAAsB,SAAqC;CACjG,MAAM,SAAmD,CAAC;CAE1D,SAAS,SAAS,MAAuB;EACxC,IAAI,KAAK,MAAM,KAAK,YAAY,KAAK,OAAA,YACpC,OAAO,KAAK;GAAE,SAAS,KAAK;GAAI,MAAM,KAAK;EAAS,CAAC;EAEtD,IAAI,KAAK,UACR,KAAK,SAAS,QAAQ,QAAQ;CAEhC;CAEA,SAAS,UAAU,IAAI;CACvB,OAAO,IAAI,SAAS,QAAQ,OAAO;AACpC"}

package/dist/errors.js

@@ -1,141 +1,132 @@
 import { PlayError } from "@xmachines/play/errors";
-// The errors of the URL language live in `@xmachines/play-url`, with the parser that
-// raises them. They are re-exported here, so that a consumer of this package sorts every
-// routing error from one import, exactly as before the split.
-//
-// The specifier is the `./errors` subpath, and not the root barrel. A consumer that
-// imports `@xmachines/play-router/errors` to name a fault in a `catch` then loads the
-// three classes alone: no pattern parser, no base path, and no `urlpattern-polyfill`. The
-// root barrel of this package reaches the rest of `@xmachines/play-url` for the consumer
-// that needs it.
-export { InvalidRoutePatternError, InvalidBasePathError, MissingBasePathParamError, } from "@xmachines/play-url/errors";
+import { InvalidBasePathError, InvalidRoutePatternError, MissingBasePathParamError } from "@xmachines/play-url/errors";
+//#region packages/play-router/src/errors.ts
 /**
- * The bridge throws this error when `RouterBridgeBase.syncActorFromRouter()`
- * cannot process a location change of the router and send the `play.route` event to
- * the actor.
- *
- * The `cause` property holds the original error.
- *
- * **Error code:** `PLAY_ROUTER_SYNC_FAILED`
- *
- * @example
- * ```typescript
- * import { RouterSyncError } from "@xmachines/play-router/errors";
- *
- * try {
- *   bridge.connect();
- * } catch (err) {
- *   if (err instanceof RouterSyncError) {
- *     console.error("Router sync failed:", err.message, err.cause);
- *   }
- * }
- * ```
- */
-export class RouterSyncError extends PlayError {
-    constructor(message, options) {
-        super("RouterBridgeBase", "PLAY_ROUTER_SYNC_FAILED", message, options);
-        this.name = "RouterSyncError";
-    }
-}
+* The bridge throws this error when `RouterBridgeBase.syncActorFromRouter()`
+* cannot process a location change of the router and send the `play.route` event to
+* the actor.
+*
+* The `cause` property holds the original error.
+*
+* **Error code:** `PLAY_ROUTER_SYNC_FAILED`
+*
+* @example
+* ```typescript
+* import { RouterSyncError } from "@xmachines/play-router/errors";
+*
+* try {
+*   bridge.connect();
+* } catch (err) {
+*   if (err instanceof RouterSyncError) {
+*     console.error("Router sync failed:", err.message, err.cause);
+*   }
+* }
+* ```
+*/
+var RouterSyncError = class extends PlayError {
+	constructor(message, options) {
+		super("RouterBridgeBase", "PLAY_ROUTER_SYNC_FAILED", message, options);
+		this.name = "RouterSyncError";
+	}
+};
 /**
- * `RouterBridgeBase.connect()` throws this error when a second bridge connects to an
- * actor with an active bridge connection.
- *
- * One actor can hold one router bridge at a time. Two bridges of the same actor both
- * receive and process every navigation event of the router. They therefore send two
- * `play.route` events to the actor, and their `lastSyncedPath` values of the echo
- * suppression contradict each other.
- *
- * **The remedy:** call `bridge.disconnect()` on the first bridge before you connect
- * the second one. You can also permit one active `connectRouter()` call for each
- * actor at a time.
- *
- * **Error code:** `PLAY_ROUTER_DUPLICATE_BRIDGE`
- *
- * @example
- * ```typescript
- * import { DuplicateBridgeError } from "@xmachines/play-router/errors";
- *
- * try {
- *   bridge.connect();
- * } catch (err) {
- *   if (err instanceof DuplicateBridgeError) {
- *     console.error("Actor already has an active router bridge — disconnect first.");
- *   }
- * }
- * ```
- */
-export class DuplicateBridgeError extends PlayError {
-    constructor() {
-        super("RouterBridgeBase", "PLAY_ROUTER_DUPLICATE_BRIDGE", "An actor can only be connected to one router bridge at a time. " +
-            "Call disconnect() on the existing bridge before connecting a new one.");
-        this.name = "DuplicateBridgeError";
-    }
-}
+* `RouterBridgeBase.connect()` throws this error when a second bridge connects to an
+* actor with an active bridge connection.
+*
+* One actor can hold one router bridge at a time. Two bridges of the same actor both
+* receive and process every navigation event of the router. They therefore send two
+* `play.route` events to the actor, and their `lastSyncedPath` values of the echo
+* suppression contradict each other.
+*
+* **The remedy:** call `bridge.disconnect()` on the first bridge before you connect
+* the second one. You can also permit one active `connectRouter()` call for each
+* actor at a time.
+*
+* **Error code:** `PLAY_ROUTER_DUPLICATE_BRIDGE`
+*
+* @example
+* ```typescript
+* import { DuplicateBridgeError } from "@xmachines/play-router/errors";
+*
+* try {
+*   bridge.connect();
+* } catch (err) {
+*   if (err instanceof DuplicateBridgeError) {
+*     console.error("Actor already has an active router bridge — disconnect first.");
+*   }
+* }
+* ```
+*/
+var DuplicateBridgeError = class extends PlayError {
+	constructor() {
+		super("RouterBridgeBase", "PLAY_ROUTER_DUPLICATE_BRIDGE", "An actor can only be connected to one router bridge at a time. Call disconnect() on the existing bridge before connecting a new one.");
+		this.name = "DuplicateBridgeError";
+	}
+};
 /**
- * `validateRouteFormat()` throws this error when a state declares a `meta.route`
- * field with an empty string as its path.
- *
- * **Error code:** `PLAY_ROUTE_EMPTY_PATH`
- */
-export class EmptyRoutePathError extends PlayError {
-    /** The state ID with the empty route path. */
-    stateId;
-    constructor(stateId) {
-        super("RouteMap", "PLAY_ROUTE_EMPTY_PATH", `Empty route path in state "${stateId}": routes must have a non-empty path`);
-        this.name = "EmptyRoutePathError";
-        this.stateId = stateId;
-    }
-}
+* `validateRouteFormat()` throws this error when a state declares a `meta.route`
+* field with an empty string as its path.
+*
+* **Error code:** `PLAY_ROUTE_EMPTY_PATH`
+*/
+var EmptyRoutePathError = class extends PlayError {
+	/** The state ID with the empty route path. */
+	stateId;
+	constructor(stateId) {
+		super("RouteMap", "PLAY_ROUTE_EMPTY_PATH", `Empty route path in state "${stateId}": routes must have a non-empty path`);
+		this.name = "EmptyRoutePathError";
+		this.stateId = stateId;
+	}
+};
 /**
- * `validateStateExists()` throws this error when a route names a state ID that the
- * machine graph does not hold.
- *
- * **Error code:** `PLAY_ROUTE_INVALID_STATE_ID`
- */
-export class InvalidStateIdError extends PlayError {
-    /** The state ID of the reference. The graph does not hold it. */
-    stateId;
-    constructor(stateId) {
-        super("RouteMap", "PLAY_ROUTE_INVALID_STATE_ID", `Route references non-existent state ID: ${stateId}`);
-        this.name = "InvalidStateIdError";
-        this.stateId = stateId;
-    }
-}
+* `validateStateExists()` throws this error when a route names a state ID that the
+* machine graph does not hold.
+*
+* **Error code:** `PLAY_ROUTE_INVALID_STATE_ID`
+*/
+var InvalidStateIdError = class extends PlayError {
+	/** The state ID of the reference. The graph does not hold it. */
+	stateId;
+	constructor(stateId) {
+		super("RouteMap", "PLAY_ROUTE_INVALID_STATE_ID", `Route references non-existent state ID: ${stateId}`);
+		this.name = "InvalidStateIdError";
+		this.stateId = stateId;
+	}
+};
 /**
- * `detectDuplicateRoutes()` throws this error when two states or more hold the same
- * URL path.
- *
- * **Error code:** `PLAY_ROUTE_DUPLICATE_PATH`
- */
-export class DuplicateRoutePathError extends PlayError {
-    /** The list of the path → state-ID mappings of the conflict, for a person to read. */
-    duplicates;
-    constructor(duplicates) {
-        super("RouteMap", "PLAY_ROUTE_DUPLICATE_PATH", `Duplicate route paths detected:\n${duplicates.join("\n")}\n\n` +
-            `Each route path must map to exactly one state.\n` +
-            `Use different paths (e.g., /dashboard vs /) or conditional rendering within a single state.`);
-        this.name = "DuplicateRoutePathError";
-        this.duplicates = duplicates;
-    }
-}
+* `detectDuplicateRoutes()` throws this error when two states or more hold the same
+* URL path.
+*
+* **Error code:** `PLAY_ROUTE_DUPLICATE_PATH`
+*/
+var DuplicateRoutePathError = class extends PlayError {
+	/** The list of the path → state-ID mappings of the conflict, for a person to read. */
+	duplicates;
+	constructor(duplicates) {
+		super("RouteMap", "PLAY_ROUTE_DUPLICATE_PATH", `Duplicate route paths detected:\n${duplicates.join("\n")}\n\nEach route path must map to exactly one state.\nUse different paths (e.g., /dashboard vs /) or conditional rendering within a single state.`);
+		this.name = "DuplicateRoutePathError";
+		this.duplicates = duplicates;
+	}
+};
 /**
- * `machineToGraph()` throws this error when an XState state node has a `.type` value
- * that the package does not know.
- *
- * **Error code:** `PLAY_ROUTE_UNKNOWN_STATE_TYPE`
- */
-export class UnknownStateTypeError extends PlayError {
-    /** The string of the state type that the package does not know. */
-    stateType;
-    /** The ID of the state node with the unknown type. */
-    nodeId;
-    constructor(stateType, nodeId, validTypes) {
-        super("machineToGraph", "PLAY_ROUTE_UNKNOWN_STATE_TYPE", `Unknown XState state type "${stateType}" on node "${nodeId}". ` +
-            `Expected one of: ${validTypes.join(", ")}.`);
-        this.name = "UnknownStateTypeError";
-        this.stateType = stateType;
-        this.nodeId = nodeId;
-    }
-}
+* `machineToGraph()` throws this error when an XState state node has a `.type` value
+* that the package does not know.
+*
+* **Error code:** `PLAY_ROUTE_UNKNOWN_STATE_TYPE`
+*/
+var UnknownStateTypeError = class extends PlayError {
+	/** The string of the state type that the package does not know. */
+	stateType;
+	/** The ID of the state node with the unknown type. */
+	nodeId;
+	constructor(stateType, nodeId, validTypes) {
+		super("machineToGraph", "PLAY_ROUTE_UNKNOWN_STATE_TYPE", `Unknown XState state type "${stateType}" on node "${nodeId}". Expected one of: ${validTypes.join(", ")}.`);
+		this.name = "UnknownStateTypeError";
+		this.stateType = stateType;
+		this.nodeId = nodeId;
+	}
+};
+//#endregion
+export { DuplicateBridgeError, DuplicateRoutePathError, EmptyRoutePathError, InvalidBasePathError, InvalidRoutePatternError, InvalidStateIdError, MissingBasePathParamError, RouterSyncError, UnknownStateTypeError };
+
 //# sourceMappingURL=errors.js.map