@xmachines/play-router 6.1.0 → 7.0.0

package/dist/router-sync.js.map

@@ -1 +1 @@
-{"version":3,"file":"router-sync.js","sourceRoot":"","sources":["../src/router-sync.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"router-sync.js","names":[],"sources":["../src/router-sync.ts"],"sourcesContent":["import {\n\tgetCompiledPattern,\n\tparsePattern,\n\tsanitizePathname,\n\ttype CompileOptions,\n\ttype URLPatternLike,\n} from \"@xmachines/play-url\";\nimport { createNullRecord } from \"@xmachines/core/utils\";\nimport type { PlayRouteEvent } from \"./types.js\";\n\nexport interface RouteMatch {\n\tto: string | null | undefined;\n\tparams?: Record<string, string>;\n}\n\nexport interface BuildPlayRouteEventOptions {\n\tpathname: string;\n\tsearch?: string | undefined;\n\tmatch: (sanitizedPathname: string) => RouteMatch;\n}\n\nexport interface RouterStateIdMap {\n\tgetStateIdByPath(path: string): string | null | undefined;\n\tgetPathByStateId(id: string): string | null | undefined;\n}\n\n/**\n * Matches a clean pathname against a route map, and reads each param of the match.\n *\n * The low-level sync path and the framework sync path share this function.\n * Therefore the semantics of the match in the route map stay identical.\n */\nexport function matchRouteMap(\n\tpathname: string,\n\trouteMap: RouterStateIdMap,\n\textractParams: (pathname: string, stateId: string) => Record<string, string>,\n): RouteMatch {\n\tconst stateId = routeMap.getStateIdByPath(pathname);\n\tif (!stateId) {\n\t\treturn { to: null, params: {} };\n\t}\n\n\treturn {\n\t\tto: stateId,\n\t\tparams: extractParams(pathname, stateId),\n\t};\n}\n\n/**\n * Reads the named path parameters of a URL, with the URLPattern API.\n *\n * The function takes the string of the pattern directly. Use it when you know the\n * pattern already. For a read through the lookup of a state ID, see\n * `RouterBridgeBase.extractParams`.\n *\n * The object of the return holds no undefined value. Such a value comes from an\n * optional segment without a match, for example `/settings` against\n * `/settings/:section?`.\n *\n * The function normalizes the pattern with the rules of the match in `RouteMap`: a\n * name with a hyphen, such as `:cat-id`, becomes `:cat_id` for URLPattern. It then\n * maps each group name back to the original param name. Therefore `/docs/123`\n * against `/docs/:cat-id` gives `{ \"cat-id\": \"123\" }`.\n *\n * The function decodes each percent sequence of a value (`john%20doe` → `john doe`),\n * as a framework router does, for example vue-router. It keeps a malformed sequence\n * raw.\n *\n * @param pathname - The concrete URL pathname, for example `/profile/alice`\n * @param pattern  - The template of the URL pattern, for example `/profile/:username`\n * @returns The record of the parameter values of the read, or `{}` for a static pattern.\n * @throws {InvalidRoutePatternError} When URLPattern cannot compile the pattern.\n *\n * @example\n * ```typescript\n * import { extractRouteParams } from \"@xmachines/play-router\";\n *\n * extractRouteParams(\"/profile/alice\", \"/profile/:username\")\n * // → { username: \"alice\" }\n *\n * extractRouteParams(\"/settings\", \"/settings/:section?\")\n * // → {}  — the optional param is absent, and the object holds it not\n * ```\n */\nexport function extractRouteParams(\n\tpathname: string,\n\tpattern: string,\n\toptions?: CompileOptions,\n): Record<string, string> {\n\t// ONE parse answers both questions of this function: does the pattern need a match,\n\t// and which name does each URLPattern group carry.\n\tconst parsed = parsePattern(pattern, options);\n\tif (!parsed.parameterized) return {};\n\t// Compile the pattern with the SAME normalization as the match in RouteMap.\n\t// Without it, URLPattern reads \":cat-id\" as the group \":cat\" and the literal \"-id\",\n\t// and the read of the params then contradicts the map that matched the path.\n\tconst urlPattern: URLPatternLike = getCompiledPattern(pattern, options);\n\tconst match = urlPattern.exec({ pathname });\n\tif (!match?.pathname.groups) return {};\n\t// Map each normalized group name (\":cat_id\") back to its original param name (\"cat-id\").\n\tconst nameMap = parsed.declaredNames;\n\t// A null prototype for the accumulator, exactly as `cleanFrameworkParams` uses: a plain\n\t// `{}` turns `params[\"__proto__\"] = value` into a write of the PROTOTYPE setter, which\n\t// drops the value in silence. A machine that declares `/:__proto__` then received `{}`\n\t// from this extraction while the parse of Vue Router or SolidJS Router carried the\n\t// value, so the two sources of the same params disagreed.\n\tconst params: Record<string, string> = createNullRecord<string>();\n\tfor (const [key, value] of Object.entries(match.pathname.groups)) {\n\t\tif (value !== undefined) {\n\t\t\tparams[nameMap.get(key) ?? key] = decodeParamValue(value); // nosemgrep: gitlab.eslint.detect-object-injection\n\t\t}\n\t}\n\t// Spread at the boundary: `event.params` reaches a machine of the user, and a plain\n\t// object is what it received before. A spread creates OWN properties, so a param named\n\t// \"__proto__\" stays a key while the value keeps a prototype.\n\treturn { ...params };\n}\n\n/**\n * Decodes each percent sequence of a URLPattern group value. It keeps the raw value\n * when the sequence is malformed, because `decodeURIComponent` then throws a\n * `URIError`.\n */\nfunction decodeParamValue(value: string): string {\n\ttry {\n\t\treturn decodeURIComponent(value);\n\t} catch {\n\t\treturn value;\n\t}\n}\n\n/**\n * Parses a URL search string into the plain object that a `play.route` event\n * needs.\n */\nexport function extractQuery(search: string): Record<string, string> {\n\ttry {\n\t\t// A null prototype for the accumulator, and a spread at the boundary: the same two\n\t\t// steps as `extractRouteParams` above, and for the same reason. A plain `{}` turns\n\t\t// `params[\"__proto__\"] = value` into a write of the PROTOTYPE setter, which drops\n\t\t// the value in silence — so a location of `?__proto__=nav` reached the machine with\n\t\t// an EMPTY query, while the same name in the path reached it as a param. The two\n\t\t// halves of one `play.route` event answered one name differently.\n\t\tconst params: Record<string, string> = createNullRecord<string>();\n\t\tnew URLSearchParams(search).forEach((value, key) => {\n\t\t\tparams[key] = value; // nosemgrep: gitlab.eslint.detect-object-injection\n\t\t});\n\t\treturn { ...params };\n\t} catch {\n\t\treturn {};\n\t}\n}\n\n/**\n * Builds a normalized `play.route` event from the raw input of a router or of a\n * browser.\n *\n * `connectRouter()` of `@xmachines/play-dom-router` and `RouterBridgeBase` both use\n * this helper. Therefore a low-level adapter and a framework adapter clean each\n * pathname, match each route, and read each query in the same way.\n */\nexport function buildPlayRouteEvent(\n\toptions: BuildPlayRouteEventOptions,\n): { pathname: string; event: PlayRouteEvent } | null {\n\tconst pathname = sanitizePathname(options.pathname);\n\tif (pathname === null) return null;\n\n\tconst match = options.match(pathname);\n\tif (!match.to) return null;\n\n\t// The one place of the canonical form of the emitted event: a `play.route` event\n\t// always carries a target with a '#' prefix. A route map can register a bare\n\t// stateId, and it can return one, because RouteMap keeps the registered form.\n\t// Therefore this code formats the target of the event, and no other code does\n\t// it.\n\tconst to = match.to.startsWith(\"#\") ? match.to : `#${match.to}`;\n\treturn {\n\t\tpathname,\n\t\tevent: {\n\t\t\ttype: \"play.route\",\n\t\t\tto,\n\t\t\tparams: match.params ?? {},\n\t\t\tquery: extractQuery(options.search ?? \"\"),\n\t\t},\n\t};\n}\n"],"mappings":";;;;;;;;;AAgCA,SAAgB,cACf,UACA,UACA,eACa;CACb,MAAM,UAAU,SAAS,iBAAiB,QAAQ;CAClD,IAAI,CAAC,SACJ,OAAO;EAAE,IAAI;EAAM,QAAQ,CAAC;CAAE;CAG/B,OAAO;EACN,IAAI;EACJ,QAAQ,cAAc,UAAU,OAAO;CACxC;AACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,SAAgB,mBACf,UACA,SACA,SACyB;CAGzB,MAAM,SAAS,aAAa,SAAS,OAAO;CAC5C,IAAI,CAAC,OAAO,eAAe,OAAO,CAAC;CAKnC,MAAM,QAD6B,mBAAmB,SAAS,OACjD,CAAA,CAAW,KAAK,EAAE,SAAS,CAAC;CAC1C,IAAI,CAAC,OAAO,SAAS,QAAQ,OAAO,CAAC;CAErC,MAAM,UAAU,OAAO;CAMvB,MAAM,SAAiC,iBAAyB;CAChE,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,MAAM,SAAS,MAAM,GAC9D,IAAI,UAAU,KAAA,GACb,OAAO,QAAQ,IAAI,GAAG,KAAK,OAAO,iBAAiB,KAAK;CAM1D,OAAO,EAAE,GAAG,OAAO;AACpB;;;;;;AAOA,SAAS,iBAAiB,OAAuB;CAChD,IAAI;EACH,OAAO,mBAAmB,KAAK;CAChC,QAAQ;EACP,OAAO;CACR;AACD;;;;;AAMA,SAAgB,aAAa,QAAwC;CACpE,IAAI;EAOH,MAAM,SAAiC,iBAAyB;EAChE,IAAI,gBAAgB,MAAM,CAAC,CAAC,SAAS,OAAO,QAAQ;GACnD,OAAO,OAAO;EACf,CAAC;EACD,OAAO,EAAE,GAAG,OAAO;CACpB,QAAQ;EACP,OAAO,CAAC;CACT;AACD;;;;;;;;;AAUA,SAAgB,oBACf,SACqD;CACrD,MAAM,WAAW,iBAAiB,QAAQ,QAAQ;CAClD,IAAI,aAAa,MAAM,OAAO;CAE9B,MAAM,QAAQ,QAAQ,MAAM,QAAQ;CACpC,IAAI,CAAC,MAAM,IAAI,OAAO;CAQtB,OAAO;EACN;EACA,OAAO;GACN,MAAM;GACN,IALS,MAAM,GAAG,WAAW,GAAG,IAAI,MAAM,KAAK,IAAI,MAAM;GAMzD,QAAQ,MAAM,UAAU,CAAC;GACzB,OAAO,aAAa,QAAQ,UAAU,EAAE;EACzC;CACD;AACD"}

package/dist/validate-routes.js

@@ -1,73 +1,65 @@
-import { EmptyRoutePathError, InvalidStateIdError, DuplicateRoutePathError } from "./errors.js";
+import { DuplicateRoutePathError, EmptyRoutePathError, InvalidStateIdError } from "./errors.js";
+//#region packages/play-router/src/validate-routes.ts
 /**
- * Checks the format of a route path
- *
- * The function requires a string that is not empty. It accepts an absolute path
- * ("/foo") and also a relative path ("foo" or "child/nested"). A relative route
- * receives the path prefix of its parent state during the construction of the tree.
- *
- * @param routePath - The route path to check: absolute or relative
- * @param stateId - The identifier of the state, for the error message
- * @throws {EmptyRoutePathError} When the route path is empty
- */
-export const validateRouteFormat = (routePath, stateId) => {
-    if (!routePath) {
-        throw new EmptyRoutePathError(stateId);
-    }
+* Checks the format of a route path
+*
+* The function requires a string that is not empty. It accepts an absolute path
+* ("/foo") and also a relative path ("foo" or "child/nested"). A relative route
+* receives the path prefix of its parent state during the construction of the tree.
+*
+* @param routePath - The route path to check: absolute or relative
+* @param stateId - The identifier of the state, for the error message
+* @throws {EmptyRoutePathError} When the route path is empty
+*/
+var validateRouteFormat = (routePath, stateId) => {
+	if (!routePath) throw new EmptyRoutePathError(stateId);
 };
 /**
- * Checks that the set of the state IDs holds a state
- *
- * The function requires each state ID of a reference in the machine graph. This
- * check at the build time therefore stops a broken route reference.
- *
- * @param stateId - The identifier of the state to check
- * @param stateIds - The set of every known state ID of the machine graph
- * @throws {InvalidStateIdError} When the set does not hold the state ID
- */
-export const validateStateExists = (stateId, stateIds) => {
-    if (!stateIds.has(stateId)) {
-        throw new InvalidStateIdError(stateId);
-    }
+* Checks that the set of the state IDs holds a state
+*
+* The function requires each state ID of a reference in the machine graph. This
+* check at the build time therefore stops a broken route reference.
+*
+* @param stateId - The identifier of the state to check
+* @param stateIds - The set of every known state ID of the machine graph
+* @throws {InvalidStateIdError} When the set does not hold the state ID
+*/
+var validateStateExists = (stateId, stateIds) => {
+	if (!stateIds.has(stateId)) throw new InvalidStateIdError(stateId);
 };
 /**
- * Finds each duplicate route path
- *
- * The function THROWS AN ERROR when more than one state holds the same RESOLVED
- * complete path.
- *
- * The detection works on the resolved complete paths, after `buildRouteTree` put the
- * path of each parent before its relative routes. It does not work on the raw route
- * strings: two relative `"settings"` routes below two different parents resolve to
- * two different complete paths, and they are valid; a relative route and an absolute
- * route that resolve to the same URL are a real collision, and the function refuses
- * them. `buildRouteTree` calls this function when the complete paths are known.
- *
- * The reason: a routing on the URL requires one state for each URL. Two states at
- * the same path make the browser navigation ambiguous, for the BACK button and for a
- * direct URL. Use a different path for each state, or use one state with a
- * conditional render.
- *
- * @param routes - The array of the route entries with their resolved complete paths, for example the `RouteNode` objects
- * @throws {DuplicateRoutePathError} When the function finds two resolved route paths that are equal
- */
-export const detectDuplicateRoutes = (routes) => {
-    const routeMap = new Map();
-    // Build the map from each resolved complete path to its state IDs
-    for (const route of routes) {
-        const stateIds = routeMap.get(route.fullPath) || [];
-        stateIds.push(route.stateId);
-        routeMap.set(route.fullPath, stateIds);
-    }
-    // Find each duplicate, and throw an error
-    const duplicates = [];
-    for (const [routePath, stateIds] of routeMap.entries()) {
-        if (stateIds.length > 1) {
-            duplicates.push(`  ${routePath}: [${stateIds.join(", ")}]`);
-        }
-    }
-    if (duplicates.length > 0) {
-        throw new DuplicateRoutePathError(duplicates);
-    }
+* Finds each duplicate route path
+*
+* The function THROWS AN ERROR when more than one state holds the same RESOLVED
+* complete path.
+*
+* The detection works on the resolved complete paths, after `buildRouteTree` put the
+* path of each parent before its relative routes. It does not work on the raw route
+* strings: two relative `"settings"` routes below two different parents resolve to
+* two different complete paths, and they are valid; a relative route and an absolute
+* route that resolve to the same URL are a real collision, and the function refuses
+* them. `buildRouteTree` calls this function when the complete paths are known.
+*
+* The reason: a routing on the URL requires one state for each URL. Two states at
+* the same path make the browser navigation ambiguous, for the BACK button and for a
+* direct URL. Use a different path for each state, or use one state with a
+* conditional render.
+*
+* @param routes - The array of the route entries with their resolved complete paths, for example the `RouteNode` objects
+* @throws {DuplicateRoutePathError} When the function finds two resolved route paths that are equal
+*/
+var detectDuplicateRoutes = (routes) => {
+	const routeMap = /* @__PURE__ */ new Map();
+	for (const route of routes) {
+		const stateIds = routeMap.get(route.fullPath) || [];
+		stateIds.push(route.stateId);
+		routeMap.set(route.fullPath, stateIds);
+	}
+	const duplicates = [];
+	for (const [routePath, stateIds] of routeMap.entries()) if (stateIds.length > 1) duplicates.push(`  ${routePath}: [${stateIds.join(", ")}]`);
+	if (duplicates.length > 0) throw new DuplicateRoutePathError(duplicates);
 };
+//#endregion
+export { detectDuplicateRoutes, validateRouteFormat, validateStateExists };
+
 //# sourceMappingURL=validate-routes.js.map

package/dist/validate-routes.js.map

@@ -1 +1 @@
-{"version":3,"file":"validate-routes.js","sourceRoot":"","sources":["../src/validate-routes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAehG;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,SAAiB,EAAE,OAAe,EAAQ,EAAE;IAC/E,IAAI,CAAC,SAAS,EAAE,CAAC;QAChB,MAAM,IAAI,mBAAmB,CAAC,OAAO,CAAC,CAAC;IACxC,CAAC;AACF,CAAC,CAAC;AAEF;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,OAAe,EAAE,QAAqB,EAAQ,EAAE;IACnF,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC;QAC5B,MAAM,IAAI,mBAAmB,CAAC,OAAO,CAAC,CAAC;IACxC,CAAC;AACF,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,MAA2B,EAAQ,EAAE;IAC1E,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAoB,CAAC;IAE7C,kEAAkE;IAClE,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC5B,MAAM,QAAQ,GAAG,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;QACpD,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QAC7B,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;IACxC,CAAC;IAED,0CAA0C;IAC1C,MAAM,UAAU,GAAa,EAAE,CAAC;IAChC,KAAK,MAAM,CAAC,SAAS,EAAE,QAAQ,CAAC,IAAI,QAAQ,CAAC,OAAO,EAAE,EAAE,CAAC;QACxD,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACzB,UAAU,CAAC,IAAI,CAAC,KAAK,SAAS,MAAM,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAC7D,CAAC;IACF,CAAC;IAED,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC3B,MAAM,IAAI,uBAAuB,CAAC,UAAU,CAAC,CAAC;IAC/C,CAAC;AACF,CAAC,CAAC"}
+{"version":3,"file":"validate-routes.js","names":[],"sources":["../src/validate-routes.ts"],"sourcesContent":["import { EmptyRoutePathError, InvalidStateIdError, DuplicateRoutePathError } from \"./errors.js\";\n\n/**\n * A route entry with its RESOLVED complete path, which is the path after the tree\n * construction put the path of the parent before each relative route.\n *\n * `RouteNode` satisfies this shape structurally.\n */\nexport interface ResolvedRoutePath {\n\t/** The identifier of the state that owns the route, for example `\"app.dashboard.settings\"`. */\n\tstateId: string;\n\t/** The resolved absolute route path, for example `\"/dashboard/settings\"`. */\n\tfullPath: string;\n}\n\n/**\n * Checks the format of a route path\n *\n * The function requires a string that is not empty. It accepts an absolute path\n * (\"/foo\") and also a relative path (\"foo\" or \"child/nested\"). A relative route\n * receives the path prefix of its parent state during the construction of the tree.\n *\n * @param routePath - The route path to check: absolute or relative\n * @param stateId - The identifier of the state, for the error message\n * @throws {EmptyRoutePathError} When the route path is empty\n */\nexport const validateRouteFormat = (routePath: string, stateId: string): void => {\n\tif (!routePath) {\n\t\tthrow new EmptyRoutePathError(stateId);\n\t}\n};\n\n/**\n * Checks that the set of the state IDs holds a state\n *\n * The function requires each state ID of a reference in the machine graph. This\n * check at the build time therefore stops a broken route reference.\n *\n * @param stateId - The identifier of the state to check\n * @param stateIds - The set of every known state ID of the machine graph\n * @throws {InvalidStateIdError} When the set does not hold the state ID\n */\nexport const validateStateExists = (stateId: string, stateIds: Set<string>): void => {\n\tif (!stateIds.has(stateId)) {\n\t\tthrow new InvalidStateIdError(stateId);\n\t}\n};\n\n/**\n * Finds each duplicate route path\n *\n * The function THROWS AN ERROR when more than one state holds the same RESOLVED\n * complete path.\n *\n * The detection works on the resolved complete paths, after `buildRouteTree` put the\n * path of each parent before its relative routes. It does not work on the raw route\n * strings: two relative `\"settings\"` routes below two different parents resolve to\n * two different complete paths, and they are valid; a relative route and an absolute\n * route that resolve to the same URL are a real collision, and the function refuses\n * them. `buildRouteTree` calls this function when the complete paths are known.\n *\n * The reason: a routing on the URL requires one state for each URL. Two states at\n * the same path make the browser navigation ambiguous, for the BACK button and for a\n * direct URL. Use a different path for each state, or use one state with a\n * conditional render.\n *\n * @param routes - The array of the route entries with their resolved complete paths, for example the `RouteNode` objects\n * @throws {DuplicateRoutePathError} When the function finds two resolved route paths that are equal\n */\nexport const detectDuplicateRoutes = (routes: ResolvedRoutePath[]): void => {\n\tconst routeMap = new Map<string, string[]>();\n\n\t// Build the map from each resolved complete path to its state IDs\n\tfor (const route of routes) {\n\t\tconst stateIds = routeMap.get(route.fullPath) || [];\n\t\tstateIds.push(route.stateId);\n\t\trouteMap.set(route.fullPath, stateIds);\n\t}\n\n\t// Find each duplicate, and throw an error\n\tconst duplicates: string[] = [];\n\tfor (const [routePath, stateIds] of routeMap.entries()) {\n\t\tif (stateIds.length > 1) {\n\t\t\tduplicates.push(`  ${routePath}: [${stateIds.join(\", \")}]`);\n\t\t}\n\t}\n\n\tif (duplicates.length > 0) {\n\t\tthrow new DuplicateRoutePathError(duplicates);\n\t}\n};\n"],"mappings":";;;;;;;;;;;;;AA0BA,IAAa,uBAAuB,WAAmB,YAA0B;CAChF,IAAI,CAAC,WACJ,MAAM,IAAI,oBAAoB,OAAO;AAEvC;;;;;;;;;;;AAYA,IAAa,uBAAuB,SAAiB,aAAgC;CACpF,IAAI,CAAC,SAAS,IAAI,OAAO,GACxB,MAAM,IAAI,oBAAoB,OAAO;AAEvC;;;;;;;;;;;;;;;;;;;;;;AAuBA,IAAa,yBAAyB,WAAsC;CAC3E,MAAM,2BAAW,IAAI,IAAsB;CAG3C,KAAK,MAAM,SAAS,QAAQ;EAC3B,MAAM,WAAW,SAAS,IAAI,MAAM,QAAQ,KAAK,CAAC;EAClD,SAAS,KAAK,MAAM,OAAO;EAC3B,SAAS,IAAI,MAAM,UAAU,QAAQ;CACtC;CAGA,MAAM,aAAuB,CAAC;CAC9B,KAAK,MAAM,CAAC,WAAW,aAAa,SAAS,QAAQ,GACpD,IAAI,SAAS,SAAS,GACrB,WAAW,KAAK,KAAK,UAAU,KAAK,SAAS,KAAK,IAAI,EAAE,EAAE;CAI5D,IAAI,WAAW,SAAS,GACvB,MAAM,IAAI,wBAAwB,UAAU;AAE9C"}

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

@@ -1,40 +1,41 @@
+import { RouteMap } from "../base-route-map.js";
 import { extractMachineRoutes } from "./extract-routes.js";
 import { getRoutableRoutes } from "./query.js";
-import { RouteMap } from "../base-route-map.js";
+//#region packages/play-router/src/xstate/create-route-map.ts
 /**
- * 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 function createRouteMap(machine, options) {
-    // 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,
-        path: node.fullPath,
-    })), options);
+* 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 });
+* ```
+*/
+function createRouteMap(machine, options) {
+	const routeTree = extractMachineRoutes(machine, options);
+	const routes = getRoutableRoutes(routeTree);
+	return new RouteMap(routes.map((node) => ({
+		stateId: node.stateId,
+		path: node.fullPath
+	})), options);
 }
+//#endregion
+export { createRouteMap };
+
 //# sourceMappingURL=create-route-map.js.map

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

@@ -1 +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"}
+{"version":3,"file":"create-route-map.js","names":[],"sources":["../../src/xstate/create-route-map.ts"],"sourcesContent":["import type { AnyStateMachine } from \"xstate\";\nimport { extractMachineRoutes } from \"./extract-routes.js\";\nimport { getRoutableRoutes } from \"./query.js\";\nimport { RouteMap } from \"../base-route-map.js\";\nimport type { RouteMapOptions } from \"../types.js\";\n\n/**\n * Creates a `RouteMap` from an XState state machine.\n *\n * The function reads every state with a route, which means each state with a\n * `meta.route` field. It keeps the routable states alone, and it drops the synthetic\n * root of the tree. `createRouteMapFromTree` of the main entry point drops the same\n * 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\n * stateId, for both directions. A subclass of `RouterBridgeBase` uses the map: it\n * converts each change of the browser URL into a `play.route` actor event, and each\n * actor route into a URL.\n *\n * @param machine - The XState v5 state machine, with a `meta.route` annotation on each state with a route.\n * @param options - The optional configuration. Give `{ pathCache }` to replace the\n *   default LRU cache of the parameterized path lookups with one that you own.\n * @returns A `RouteMap` for each adapter on `RouterBridgeBase`.\n *\n * @example\n * ```typescript\n * import { createRouteMap } from '@xmachines/play-router/xstate';\n * import { connectRouter } from '@xmachines/play-dom-router';\n *\n * const routeMap = createRouteMap(myMachine);\n * const disconnect = connectRouter({ actor, router, routeMap });\n * ```\n */\nexport function createRouteMap(machine: AnyStateMachine, options?: RouteMapOptions): RouteMap {\n\t// The options reach the EXTRACTION too. `extractMachineRoutes` parses the route of\n\t// every node, so a caller that passes a cache for the isolation of a tenant would\n\t// otherwise write each of those patterns into the shared default cache.\n\tconst routeTree = extractMachineRoutes(machine, options);\n\tconst routes = getRoutableRoutes(routeTree);\n\treturn new RouteMap(\n\t\troutes.map((node) => ({\n\t\t\tstateId: node.stateId,\n\t\t\tpath: node.fullPath,\n\t\t})),\n\t\toptions,\n\t);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,SAAgB,eAAe,SAA0B,SAAqC;CAI7F,MAAM,YAAY,qBAAqB,SAAS,OAAO;CACvD,MAAM,SAAS,kBAAkB,SAAS;CAC1C,OAAO,IAAI,SACV,OAAO,KAAK,UAAU;EACrB,SAAS,KAAK;EACd,MAAM,KAAK;CACZ,EAAE,GACF,OACD;AACD"}

package/dist/xstate/extract-routes.js

@@ -1,92 +1,75 @@
-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 { machineToGraph } from "./machine-to-graph.js";
+import { parsePattern } from "@xmachines/play-url";
+//#region packages/play-router/src/xstate/extract-routes.ts
 /**
- * Builds the statePath of a graph node, and it walks the chain of the parentId
- * values.
- *
- * The function makes an array of the stateId segments, from the root to this node,
- * and the array holds no root. This is the format of the parent lookup in
- * buildRouteTree.
- *
- * @param graphNode - The node of the path
- * @param graphNodeMap - The map from a node id to a GraphNode, for a parent lookup in O(1)
- * @returns The array of the stateId segments, for example ["dashboard", "overview"]
- */
-const buildStatePath = (graphNode, graphNodeMap) => {
-    const path = [];
-    let current = graphNode;
-    while (current && current.parentId !== undefined && current.parentId !== null) {
-        path.unshift(current.data.stateId);
-        current = graphNodeMap.get(current.parentId);
-    }
-    return path;
+* Builds the statePath of a graph node, and it walks the chain of the parentId
+* values.
+*
+* The function makes an array of the stateId segments, from the root to this node,
+* and the array holds no root. This is the format of the parent lookup in
+* buildRouteTree.
+*
+* @param graphNode - The node of the path
+* @param graphNodeMap - The map from a node id to a GraphNode, for a parent lookup in O(1)
+* @returns The array of the stateId segments, for example ["dashboard", "overview"]
+*/
+var buildStatePath = (graphNode, graphNodeMap) => {
+	const path = [];
+	let current = graphNode;
+	while (current && current.parentId !== void 0 && current.parentId !== null) {
+		path.unshift(current.data.stateId);
+		current = graphNodeMap.get(current.parentId);
+	}
+	return path;
 };
 /**
- * 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, options) => {
-    const { stateId, route, meta } = graphNode.data;
-    // The node has no route
-    if (!route)
-        return null;
-    // Check the format. The path must start with /
-    validateRouteFormat(route, stateId);
-    // Check that the graph holds the state. This test is redundant, and it guards against a corruption
-    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);
-    // 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"]
-        : route;
-    const result = {
-        stateId,
-        statePath,
-        routePath: route,
-        isAbsolute: route.startsWith("/"),
-        routable: true,
-        metadata,
-    };
-    if (pattern)
-        result.pattern = pattern;
-    return result;
+* Reads the route information of the MachineNodeData object of a graph node.
+* The function returns null when the node has no route.
+*/
+var extractRouteFromNode = (graphNode, stateIds, graphNodeMap, options) => {
+	const { stateId, route, meta } = graphNode.data;
+	if (!route) return null;
+	validateRouteFormat(route, stateId);
+	validateStateExists(stateId, stateIds);
+	const statePath = buildStatePath(graphNode, graphNodeMap);
+	const pattern = parsePattern(route, options).parameterized ? route : void 0;
+	const metadata = meta && typeof meta === "object" && "route" in meta ? meta["route"] : route;
+	const result = {
+		stateId,
+		statePath,
+		routePath: route,
+		isAbsolute: route.startsWith("/"),
+		routable: true,
+		metadata
+	};
+	if (pattern) result.pattern = pattern;
+	return result;
 };
 /**
- * Reads the complete route tree from the graph of a state machine
- *
- * The function converts the XState machine into a Graph of @statelyai/graph, with
- * machineToGraph(). It then walks the graph nodes: it reads the route metadata of
- * each node, it checks each route reference, and it builds a hierarchical RouteTree.
- * The RouteTree of the return value also holds the graph, for a later query that
- * needs the transitions.
- *
- * @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, 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)
-    const stateIds = new Set(graph.nodes.map((n) => n.data.stateId));
-    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, 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
-    // to a complete path. The raw route strings are not comparable, because two
-    // relative "settings" routes below two different parents are two different
-    // routes.
-    const tree = buildRouteTree(routes);
-    return { ...tree, graph };
+* Reads the complete route tree from the graph of a state machine
+*
+* The function converts the XState machine into a Graph of @statelyai/graph, with
+* machineToGraph(). It then walks the graph nodes: it reads the route metadata of
+* each node, it checks each route reference, and it builds a hierarchical RouteTree.
+* The RouteTree of the return value also holds the graph, for a later query that
+* needs the transitions.
+*
+* @param machine - The XState v5 state machine
+* @returns The route tree, with its root, its byStateId map, its byPath map, and its graph
+*/
+var extractMachineRoutes = (machine, options) => {
+	const graph = machineToGraph(machine);
+	const stateIds = new Set(graph.nodes.map((n) => n.data.stateId));
+	const graphNodeMap = new Map(graph.nodes.map((n) => [n.id, n]));
+	const routes = graph.nodes.map((node) => extractRouteFromNode(node, stateIds, graphNodeMap, options)).filter((r) => r !== null);
+	return {
+		...buildRouteTree(routes),
+		graph
+	};
 };
+//#endregion
+export { extractMachineRoutes };
+
 //# sourceMappingURL=extract-routes.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"extract-routes.js","sourceRoot":"","sources":["../../src/xstate/extract-routes.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"extract-routes.js","names":[],"sources":["../../src/xstate/extract-routes.ts"],"sourcesContent":["import { parsePattern } from \"@xmachines/play-url\";\nimport type { ParseOptions } from \"@xmachines/play-url\";\nimport type { AnyStateMachine } from \"xstate\";\nimport type { GraphNode } from \"@statelyai/graph\";\nimport type { RouteTree, RouteInfo, RouteMetadata } from \"../types.js\";\nimport type { MachineNodeData } from \"./machine-types.js\";\nimport { machineToGraph, type MachineGraph } from \"./machine-to-graph.js\";\nimport { validateRouteFormat, validateStateExists } from \"../validate-routes.js\";\nimport { buildRouteTree } from \"../build-tree.js\";\n\n/**\n * Builds the statePath of a graph node, and it walks the chain of the parentId\n * values.\n *\n * The function makes an array of the stateId segments, from the root to this node,\n * and the array holds no root. This is the format of the parent lookup in\n * buildRouteTree.\n *\n * @param graphNode - The node of the path\n * @param graphNodeMap - The map from a node id to a GraphNode, for a parent lookup in O(1)\n * @returns The array of the stateId segments, for example [\"dashboard\", \"overview\"]\n */\nconst buildStatePath = (\n\tgraphNode: GraphNode<MachineNodeData>,\n\tgraphNodeMap: Map<string, GraphNode<MachineNodeData>>,\n): string[] => {\n\tconst path: string[] = [];\n\tlet current: GraphNode<MachineNodeData> | undefined = graphNode;\n\n\twhile (current && current.parentId !== undefined && current.parentId !== null) {\n\t\tpath.unshift(current.data.stateId);\n\t\tcurrent = graphNodeMap.get(current.parentId);\n\t}\n\n\treturn path;\n};\n\n/**\n * Reads the route information of the MachineNodeData object of a graph node.\n * The function returns null when the node has no route.\n */\nconst extractRouteFromNode = (\n\tgraphNode: GraphNode<MachineNodeData>,\n\tstateIds: Set<string>,\n\tgraphNodeMap: Map<string, GraphNode<MachineNodeData>>,\n\toptions?: ParseOptions,\n): RouteInfo | null => {\n\tconst { stateId, route, meta } = graphNode.data;\n\n\t// The node has no route\n\tif (!route) return null;\n\n\t// Check the format. The path must start with /\n\tvalidateRouteFormat(route, stateId);\n\n\t// Check that the graph holds the state. This test is redundant, and it guards against a corruption\n\tvalidateStateExists(stateId, stateIds);\n\n\t// Build the statePath from the chain of the parentId values. This works for an explicit ID and also for a generated one\n\tconst statePath = buildStatePath(graphNode, graphNodeMap);\n\n\t// The parse answers this, and not a search for a \":\". `route.includes(\":\")` was the\n\t// last expression that read the grammar on its own: it reported no pattern for\n\t// `/docs/*`, for `/books{/:id}?` and for an escaped literal, so a consumer that reads\n\t// `node.pattern` learned that a parameterized route is a literal path.\n\tconst pattern = parsePattern(route, options).parameterized ? route : undefined;\n\n\t// Build the original shape of the metadata again, from the data of the graph\n\tconst metadata: RouteMetadata =\n\t\tmeta && typeof meta === \"object\" && \"route\" in meta\n\t\t\t? (meta[\"route\"] as RouteMetadata)\n\t\t\t: route;\n\n\tconst result: RouteInfo = {\n\t\tstateId,\n\t\tstatePath,\n\t\troutePath: route,\n\t\tisAbsolute: route.startsWith(\"/\"),\n\t\troutable: true,\n\t\tmetadata,\n\t};\n\n\tif (pattern) result.pattern = pattern;\n\n\treturn result;\n};\n\n/**\n * Reads the complete route tree from the graph of a state machine\n *\n * The function converts the XState machine into a Graph of @statelyai/graph, with\n * machineToGraph(). It then walks the graph nodes: it reads the route metadata of\n * each node, it checks each route reference, and it builds a hierarchical RouteTree.\n * The RouteTree of the return value also holds the graph, for a later query that\n * needs the transitions.\n *\n * @param machine - The XState v5 state machine\n * @returns The route tree, with its root, its byStateId map, its byPath map, and its graph\n */\nexport const extractMachineRoutes = (\n\tmachine: AnyStateMachine,\n\toptions?: ParseOptions,\n): RouteTree<MachineGraph> => {\n\t// 1. Convert the machine into a graph\n\tconst graph: MachineGraph = machineToGraph(machine);\n\n\t// 2. Build the set of the state IDs, for the check, and the node map, for a parent lookup in O(1)\n\tconst stateIds = new Set(graph.nodes.map((n) => n.data.stateId));\n\tconst graphNodeMap = new Map(graph.nodes.map((n) => [n.id, n]));\n\n\t// 3. Read the routes of the graph nodes\n\tconst routes = graph.nodes\n\t\t.map((node) => extractRouteFromNode(node, stateIds, graphNodeMap, options))\n\t\t.filter((r): r is RouteInfo => r !== null);\n\n\t// 4. Build the hierarchical tree, and attach the graph.\n\t// buildRouteTree finds each duplicate route, AFTER it resolved each relative route\n\t// to a complete path. The raw route strings are not comparable, because two\n\t// relative \"settings\" routes below two different parents are two different\n\t// routes.\n\tconst tree = buildRouteTree(routes);\n\treturn { ...tree, graph };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;AAsBA,IAAM,kBACL,WACA,iBACc;CACd,MAAM,OAAiB,CAAC;CACxB,IAAI,UAAkD;CAEtD,OAAO,WAAW,QAAQ,aAAa,KAAA,KAAa,QAAQ,aAAa,MAAM;EAC9E,KAAK,QAAQ,QAAQ,KAAK,OAAO;EACjC,UAAU,aAAa,IAAI,QAAQ,QAAQ;CAC5C;CAEA,OAAO;AACR;;;;;AAMA,IAAM,wBACL,WACA,UACA,cACA,YACsB;CACtB,MAAM,EAAE,SAAS,OAAO,SAAS,UAAU;CAG3C,IAAI,CAAC,OAAO,OAAO;CAGnB,oBAAoB,OAAO,OAAO;CAGlC,oBAAoB,SAAS,QAAQ;CAGrC,MAAM,YAAY,eAAe,WAAW,YAAY;CAMxD,MAAM,UAAU,aAAa,OAAO,OAAO,CAAC,CAAC,gBAAgB,QAAQ,KAAA;CAGrE,MAAM,WACL,QAAQ,OAAO,SAAS,YAAY,WAAW,OAC3C,KAAK,WACN;CAEJ,MAAM,SAAoB;EACzB;EACA;EACA,WAAW;EACX,YAAY,MAAM,WAAW,GAAG;EAChC,UAAU;EACV;CACD;CAEA,IAAI,SAAS,OAAO,UAAU;CAE9B,OAAO;AACR;;;;;;;;;;;;;AAcA,IAAa,wBACZ,SACA,YAC6B;CAE7B,MAAM,QAAsB,eAAe,OAAO;CAGlD,MAAM,WAAW,IAAI,IAAI,MAAM,MAAM,KAAK,MAAM,EAAE,KAAK,OAAO,CAAC;CAC/D,MAAM,eAAe,IAAI,IAAI,MAAM,MAAM,KAAK,MAAM,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC;CAG9D,MAAM,SAAS,MAAM,MACnB,KAAK,SAAS,qBAAqB,MAAM,UAAU,cAAc,OAAO,CAAC,CAAC,CAC1E,QAAQ,MAAsB,MAAM,IAAI;CAQ1C,OAAO;EAAE,GADI,eAAe,MAChB;EAAM;CAAM;AACzB"}

package/dist/xstate/index.js

@@ -1,33 +1,5 @@
-/**
- * `@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 { getNavigableRoutes, getRoutableRoutes, routeExists, getTransitionReachableRoutes, isRouteReachable, getRouteMappings, } from "./query.js";
-//# sourceMappingURL=index.js.map
+import { machineToGraph } from "./machine-to-graph.js";
+import { extractMachineRoutes } from "./extract-routes.js";
+import { getNavigableRoutes, getRoutableRoutes, getRouteMappings, getTransitionReachableRoutes, isRouteReachable, routeExists } from "./query.js";
+import { createRouteMap } from "./create-route-map.js";
+export { createRouteMap, extractMachineRoutes, getNavigableRoutes, getRoutableRoutes, getRouteMappings, getTransitionReachableRoutes, isRouteReachable, machineToGraph, routeExists };