@xmachines/play-router 2.2.0 → 4.0.0

package/dist/xstate/index.d.ts

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

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

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

package/dist/xstate/index.js

@@ -0,0 +1,33 @@
+/**
+ * `@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

package/dist/xstate/index.js.map

@@ -0,0 +1 @@
+{"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/{machine-to-graph.d.ts → xstate/machine-to-graph.d.ts}

@@ -1,6 +1,6 @@
 import type { AnyStateMachine } from "xstate";
 import { type Graph } from "@statelyai/graph";
-import type { MachineNodeData, MachineEdgeData } from "./types.js";
+import type { MachineNodeData, MachineEdgeData } from "./machine-types.js";
 /**
  * The typed Graph of @statelyai/graph that represents a state machine.
  * It gives you the queries of the hierarchy, the algorithms of a walk, and the tests

package/dist/xstate/machine-to-graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"machine-to-graph.d.ts","sourceRoot":"","sources":["../../src/xstate/machine-to-graph.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,QAAQ,CAAC;AAE9C,OAAO,EAAe,KAAK,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC3D,OAAO,KAAK,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAG3E;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,YAAY,GAAG,KAAK,CAAC,eAAe,EAAE,eAAe,CAAC,CAAC;AAsDnE,eAAO,MAAM,cAAc,GAAI,SAAS,eAAe,KAAG,YAwEzD,CAAC"}

package/dist/{machine-to-graph.js → xstate/machine-to-graph.js}

@@ -1,6 +1,6 @@
 import { toDirectedGraph } from "xstate/graph";
 import { createGraph } from "@statelyai/graph";
-import { UnknownStateTypeError } from "./errors.js";
+import { UnknownStateTypeError } from "../errors.js";
 /**
  * Converts an XState v5 state machine into a typed Graph of @statelyai/graph.
  *
@@ -20,7 +20,7 @@ import { UnknownStateTypeError } from "./errors.js";
  * ```typescript
  * import { createMachine } from "xstate";
  * import { getChildren, getSuccessors } from "@statelyai/graph";
- * import { machineToGraph } from "@xmachines/play-router";
+ * import { machineToGraph } from "@xmachines/play-router/xstate";
  *
  * const machine = createMachine({
  *   id: "app",

package/dist/xstate/machine-to-graph.js.map

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

package/dist/xstate/machine-types.d.ts

@@ -0,0 +1,42 @@
+/**
+ * The data that a node and an edge of an XState machine graph carry.
+ *
+ * `machineToGraph` writes them, and the query functions of this package read them. They
+ * live here and not on the main entry point, because a route tree is a map from a path
+ * to a state and it names no machine.
+ */
+/**
+ * The data on each node of the graph that represents the machine.
+ * It holds the state metadata that the route extraction and the queries need.
+ */
+export interface MachineNodeData {
+    /** The XState state ID, for example "test.dashboard.overview" */
+    stateId: string;
+    /** The state type of XState */
+    type: "atomic" | "compound" | "parallel" | "final" | "history";
+    /** The original meta object of the state */
+    meta?: Record<string, unknown>;
+    /** The route path of meta.route, in its string form */
+    route?: string;
+}
+/**
+ * The data on each edge of the graph that represents the machine.
+ * It holds the event of the transition and the information of its guard.
+ */
+export interface MachineEdgeData {
+    /** The event type that starts this transition */
+    eventType: string;
+    /**
+     * The guard as a string, when a guard is present
+     *
+     * XState 5 holds the guard of a transition as a value that `String()` describes, and
+     * `machineToGraph` writes that string here.
+     *
+     * The field carried a "removed in the next major" notice before, and it keeps no such
+     * notice now. XState 6 populates it never, so it leaves with the migration to XState 6
+     * and not before: a removal while XState 5 fills it deletes a field that works, and it
+     * gives a consumer nothing in its place.
+     */
+    guardType?: string;
+}
+//# sourceMappingURL=machine-types.d.ts.map

package/dist/xstate/machine-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"machine-types.d.ts","sourceRoot":"","sources":["../../src/xstate/machine-types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC/B,iEAAiE;IACjE,OAAO,EAAE,MAAM,CAAC;IAChB,+BAA+B;IAC/B,IAAI,EAAE,QAAQ,GAAG,UAAU,GAAG,UAAU,GAAG,OAAO,GAAG,SAAS,CAAC;IAC/D,4CAA4C;IAC5C,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,uDAAuD;IACvD,KAAK,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC/B,iDAAiD;IACjD,SAAS,EAAE,MAAM,CAAC;IAClB;;;;;;;;;;OAUG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACnB"}

package/dist/xstate/machine-types.js

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

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

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

package/dist/{query.d.ts → xstate/query.d.ts}

@@ -1,7 +1,9 @@
+import { type BasePathOptions } from "@xmachines/play-url";
 import type { Graph } from "@statelyai/graph";
-import type { RouteTree, RouteNode, MachineNodeData, MachineEdgeData } from "./types.js";
-import type { RouteMapping } from "./base-route-map.js";
-import { type BasePathOptions } from "./base-path.js";
+import type { RouteTree, RouteNode } from "../types.js";
+import type { MachineNodeData, MachineEdgeData } from "./machine-types.js";
+import type { MachineGraph } from "./machine-to-graph.js";
+import type { RouteMapping } from "../base-route-map.js";
 /**
  * Returns every route of a navigation from the given state
  *
@@ -19,7 +21,7 @@ import { type BasePathOptions } from "./base-path.js";
  * // [{ id: 'overview', path: '/overview', ... }, { id: 'settings', ... }]
  * ```
  */
-export declare const getNavigableRoutes: (tree: RouteTree, stateId: string) => RouteNode[];
+export declare const getNavigableRoutes: (tree: RouteTree<MachineGraph>, stateId: string) => RouteNode[];
 /**
  * Returns every route of the tree that has a route, in one flat array
  *

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

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../src/xstate/query.ts"],"names":[],"mappings":"AAAA,OAAO,EAIN,KAAK,eAAe,EACpB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,KAAK,EAAa,MAAM,kBAAkB,CAAC;AAGzD,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxD,OAAO,KAAK,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAC3E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AA0BzD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,kBAAkB,GAAI,MAAM,SAAS,CAAC,YAAY,CAAC,EAAE,SAAS,MAAM,KAAG,SAAS,EA0B5F,CAAC;AAkBF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,iBAAiB,GAAI,MAAM,SAAS,KAAG,SAAS,EAW5D,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW,GAAI,MAAM,SAAS,EAAE,MAAM,MAAM,KAAG,OAE3D,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,4BAA4B,GACxC,OAAO,KAAK,CAAC,eAAe,EAAE,eAAe,CAAC,EAC9C,SAAS,MAAM,KACb,MAAM,EAER,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,gBAAgB,GAC5B,OAAO,KAAK,CAAC,eAAe,EAAE,eAAe,CAAC,EAC9C,aAAa,MAAM,EACnB,WAAW,MAAM,KACf,OAKF,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,eAAO,MAAM,gBAAgB,GAAI,MAAM,SAAS,EAAE,UAAU,eAAe,KAAG,YAAY,EAazF,CAAC"}

package/dist/{query.js → xstate/query.js}

@@ -1,5 +1,6 @@
+import { joinBasePath, normalizeBasePath, resolveBasePath, } from "@xmachines/play-url";
 import { getSuccessors, hasNode, hasPath } from "@statelyai/graph";
-import { joinBasePath, normalizeBasePath, resolveBasePath, } from "./base-path.js";
+import { ROOT_NODE_ID } from "../build-tree.js";
 /**
  * Returns the successor nodes of a state that have a route: the states of a direct
  * transition edge that hold a `meta.route` field.
@@ -93,7 +94,7 @@ 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__") {
+        if (node.routable && node.id !== ROOT_NODE_ID) {
             routes.push(node);
         }
     }

package/dist/xstate/query.js.map

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@xmachines/play-router",
-  "version": "2.2.0",
-  "description": "Route tree extraction from XState v5 state machines. Part of @xmachines/play Universal Player Architecture.",
+  "version": "4.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",
     "state-machine",
@@ -30,6 +30,10 @@
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     },
+    "./xstate": {
+      "types": "./dist/xstate/index.d.ts",
+      "default": "./dist/xstate/index.js"
+    },
     "./errors": {
       "types": "./dist/errors.d.ts",
       "default": "./dist/errors.js"
@@ -43,40 +47,42 @@
     "build": "vite build && tsc --build",
     "clean": "rm -rf dist *.tsbuildinfo coverage .vitest-attachments test/browser/__screenshots__ node_modules/.svelte2tsx-* node_modules/.vite*",
     "lint": "oxlint .",
+    "lint:security": "node ../../scripts/semgrep-scan.mjs",
     "format": "oxfmt .",
     "test": "vitest",
     "test:coverage": "vitest run --coverage"
   },
   "dependencies": {
-    "@statelyai/graph": "^2.1.0",
-    "@xmachines/play": "2.2.0",
-    "@xmachines/play-actor": "2.2.0",
-    "@xmachines/play-signals": "2.2.0",
+    "@statelyai/graph": "^2.4.0",
+    "@xmachines/play-url": "4.0.0",
     "quick-lru": "^7.3.0"
   },
   "devDependencies": {
-    "@testing-library/jest-dom": "^6.9.1",
-    "@types/node": "^26.2.0",
-    "@vitest/browser-playwright": "^4.1.11",
-    "oxfmt": "^0.64.0",
-    "oxlint": "^1.79.0",
+    "@testing-library/jest-dom": "^7.0.1",
+    "@types/node": "^26.6.2",
+    "@vitest/browser-playwright": "^5.0.1",
+    "@xmachines/play": "4.0.0",
+    "@xmachines/play-signals": "4.0.0",
+    "@xmachines/play-view": "4.0.0",
+    "oxfmt": "^0.68.0",
+    "oxlint": "^1.83.0",
     "typescript": "^5.9.3 || ^6.0.3",
-    "urlpattern-polyfill": "^10.1.0",
-    "vite": "^8.0.10",
-    "vitest": "^4.1.11",
-    "xstate": "^5.31.0"
+    "vite": "^8.3.0",
+    "vitest": "^5.0.1",
+    "xstate": "^5.33.0"
   },
   "peerDependencies": {
-    "urlpattern-polyfill": "^10.1.0",
-    "xstate": "^5.31.0"
+    "@xmachines/play": "4.0.0",
+    "@xmachines/play-signals": "4.0.0",
+    "xstate": "^5.33.0"
   },
   "peerDependenciesMeta": {
-    "urlpattern-polyfill": {
+    "xstate": {
       "optional": true
     }
   },
   "engines": {
-    "node": ">=22.0.0"
+    "node": ">=24.0.0"
   },
-  "_devDependencies_note": "xstate appears in both peerDependencies and devDependencies intentionally. devDependencies provides workspace resolution for local builds and tests. peerDependencies declares the consumer version constraint. Both are pinned to ^5.30.0 to prevent drift. urlpattern-polyfill is an optional peer dependency — consumers on Node < 24 or older browsers install it themselves. devDependencies entry ensures workspace test resolution."
+  "_devDependencies_note": "xstate appears in both peerDependencies and devDependencies intentionally. devDependencies provides workspace resolution for local builds and tests. peerDependencies declares the consumer version constraint. Both hold the same range, to prevent drift."
 }

package/dist/base-path.d.ts

@@ -1,209 +0,0 @@
-/**
- * The base-path support — it mounts the routes of a machine under a URL prefix.
- *
- * A host application often owns a part of its own URL space, and it wants a machine
- * to own the rest of that space, inside the SAME router. A URL such as
- * `/:machineId/play/dashboard` has two halves: `/:machineId/play` belongs to the
- * host, which resolves `:machineId` in a loader, and `/dashboard` belongs to the
- * `meta.route` tree of the machine.
- *
- * This module is the boundary between those two halves:
- * - {@link resolveBasePath} makes the concrete prefix that the browser URL carries,
- *   from a base-path pattern and its params.
- * - {@link stripBasePath} removes that prefix from an inbound location of the router,
- *   and it reports a location OUTSIDE the prefix as foreign, so that the bridge stays
- *   out of it.
- * - {@link joinBasePath} adds the prefix again to an outbound path of the machine.
- *
- * The prefix lives on the BRIDGE, and not on the `RouteMap`. A route map is static,
- * it is shared, and it holds an LRU cache inside, while a mount point is dynamic. One
- * route map therefore serves every `machineId` without a rebuild.
- *
- * @internal The package exports these primitives for an adapter and for a host, but
- * a consumer normally uses the `basePath` option of a bridge instead.
- */
-/**
- * The base-path options that every router bridge, `connectRouter` function, and
- * `PlayRouterProvider` component accepts.
- *
- * @example
- * ```typescript
- * // A host that mounts a machine under a route it resolved in a loader
- * connectRouter({
- *   actor,
- *   router,
- *   routeMap,
- *   basePath: "/:machineId/play",
- *   basePathParams: { machineId },
- * });
- * ```
- */
-export interface BasePathOptions {
-    /**
-     * The URL prefix that the routes of the machine hang off, for example `"/admin"`
-     * or `"/:machineId/play"`.
-     *
-     * A `:param` segment is a declarative convenience, so that a host keeps ONE string
-     * that mirrors its own route config. Every `:param` must have a value in
-     * {@link BasePathOptions.basePathParams}, because the bridge writes a real URL. An
-     * optional segment (`:param?`) and a wildcard (`*`) are therefore refused: neither
-     * of them resolves to one concrete prefix.
-     *
-     * An absent value, `""`, and `"/"` all mean "no prefix", which is the behaviour of
-     * every release before this option existed.
-     */
-    readonly basePath?: string | undefined;
-    /**
-     * The values of the `:param` segments of {@link BasePathOptions.basePath}.
-     *
-     * These values belong to the HOST, which wrote the prefix and resolved them, so
-     * they travel in NO `play.route` event: the machine is authoritative over its own
-     * params, and `event.params` holds what the pattern of the machine declares, and
-     * nothing else. A param of the host that shares a name with one of the machine can
-     * therefore shadow it never.
-     *
-     * A host reads them back from `bridge.basePathParams`, where they cannot go stale.
-     * A machine that needs the identity of its host takes it through the `input` of the
-     * actor, where that identity decides WHICH machine runs.
-     */
-    readonly basePathParams?: Record<string, string | number> | undefined;
-}
-/**
- * A base path that is ready for a use in both directions.
- */
-export interface ResolvedBasePath {
-    /**
-     * The normalized prefix: it starts with `/`, it carries no trailing `/`, and it
-     * holds no duplicate slash. The empty string means "no prefix".
-     */
-    readonly path: string;
-    /**
-     * The values of each `:param` of the prefix, for the `params` of a `play.route`
-     * event. The object is empty for a prefix without a param, and for a pattern that
-     * nothing resolved.
-     */
-    readonly params: Record<string, string>;
-}
-/**
- * The base path of a bridge that has no `basePath` option.
- *
- * The object is FROZEN, and both levels of it: {@link resolveBasePath} returns this
- * exact instance for every bridge with no mount, and
- * `RouterBridgeBase.basePathParams` hands its `params` to the caller.
- * `Readonly<Record<string, string>>` is gone at run time, so without the freeze one
- * write in consumer code would leak that key into every other unmounted bridge in
- * the process.
- */
-export declare const NO_BASE_PATH: ResolvedBasePath;
-/**
- * Normalizes a base path, and it substitutes no `:param` segment of that path.
- *
- * Use this function when you want the form of the pattern, for example to declare
- * the routes of a machine in a route config of a host that substitutes each param
- * itself. {@link resolveBasePath} gives the form that a bridge needs.
- *
- * @param basePath - The prefix, as a pattern or as a concrete path. An absent value,
- *   `""`, and `"/"` all give `""`.
- * @returns The normalized prefix. It starts with `/`, and it carries no trailing `/`.
- * @throws {InvalidBasePathError} For a wildcard segment, for an optional `:param?`
- *   segment, for a `$param` segment, for a query string or a hash fragment, for a URL
- *   scheme, for a dot segment (`.`, `..`, and their percent-encoded forms), and for any
- *   segment that a browser rewrites — one that holds whitespace, a backslash, or a
- *   character that a URL percent-encodes.
- *
- * @example
- * ```typescript
- * normalizeBasePath("/:machineId/play/");  // "/:machineId/play"
- * normalizeBasePath("admin");              // "/admin"
- * normalizeBasePath("/");                  // ""
- * ```
- */
-export declare function normalizeBasePath(basePath?: string | undefined): string;
-/**
- * Resolves a base path and its params to the concrete prefix that a browser URL
- * carries.
- *
- * A bridge calls this function one time, and again on each `setBasePath()` call. The
- * result is always concrete. {@link stripBasePath} therefore compares a literal
- * prefix, and no URLPattern match runs on the hot path of a navigation.
- *
- * @param basePath - The prefix, as a pattern or as a concrete path.
- * @param params - The values of the `:param` segments of `basePath`.
- * @returns The concrete prefix, and the values of each param for a `play.route` event.
- * @throws {InvalidBasePathError} For a wildcard segment, for an optional `:param?`
- *   segment, for a `$param` segment, for a query string or a hash fragment, for a URL
- *   scheme, for a dot segment (`.`, `..`, and their percent-encoded forms), and for any
- *   segment that a browser rewrites — one that holds whitespace, a backslash, or a
- *   character that a URL percent-encodes.
- * @throws {MissingBasePathParamError} When a `:param` of the prefix has no value.
- *
- * @example
- * ```typescript
- * resolveBasePath("/:machineId/play", { machineId: "abc123" });
- * // → { path: "/abc123/play", params: { machineId: "abc123" } }
- *
- * resolveBasePath("/admin");
- * // → { path: "/admin", params: {} }
- * ```
- */
-export declare function resolveBasePath(basePath?: string | undefined, params?: Record<string, string | number> | undefined): ResolvedBasePath;
-/**
- * Removes the base path from an inbound location of the router.
- *
- * The return value separates the two cases that make a shared router work:
- * - A string is the MACHINE half of the location, for example `"/dashboard"` of
- *   `"/abc123/play/dashboard"`. The bridge matches it against the route map.
- * - `null` means that the location is FOREIGN: it lies outside the mount, so it
- *   belongs to the host. The bridge sends no `play.route` event, AND it runs no
- *   corrective navigation. A correction here would drag the user off a page of the
- *   host.
- *
- * The match is exact, and it respects each segment boundary. `"/abc/playground"` is
- * therefore foreign to the mount `"/abc/play"`.
- *
- * @param pathname - A sanitized pathname of the router, with no query and no duplicate slash.
- * @param basePath - The concrete prefix of {@link resolveBasePath}. `""` removes nothing.
- * @returns The machine half of the path, or `null` when the location is foreign.
- *
- * @example
- * ```typescript
- * stripBasePath("/abc123/play/dashboard", "/abc123/play");  // "/dashboard"
- * stripBasePath("/abc123/play", "/abc123/play");            // "/"
- * stripBasePath("/settings", "/abc123/play");               // null — the host owns it
- * ```
- */
-export declare function stripBasePath(pathname: string, basePath: string): string | null;
-/**
- * Adds the base path to an outbound path of the machine.
- *
- * The function joins the PATHNAME only. A query string and a hash fragment of the
- * path of the machine stay at the end, because the prefix belongs in front of the
- * path.
- *
- * @param basePath - The concrete prefix of {@link resolveBasePath}. `""` adds nothing.
- * @param path - The path of the machine, for example `"/dashboard"` or `"/dates?trip=one-way"`.
- * @returns The location for the router of the host.
- *
- * @example
- * ```typescript
- * joinBasePath("/abc123/play", "/dashboard");         // "/abc123/play/dashboard"
- * joinBasePath("/abc123/play", "/");                  // "/abc123/play"
- * joinBasePath("/abc123/play", "/x?tab=a");           // "/abc123/play/x?tab=a"
- * joinBasePath("", "/dashboard");                     // "/dashboard"
- * ```
- */
-export declare function joinBasePath(basePath: string, path: string): string;
-/**
- * Gives the index of the first query mark or fragment mark of a path, or `-1`.
- *
- * The names say `At`, because both values are an INDEX. A name such as `hash` reads
- * as a digest to a reader and to a scanner both: `gitlab.eslint.detect-possible-timing-attacks`
- * fires on a `===` test against an identifier of that name, and it cannot see that
- * the operands here are two numbers.
- *
- * @internal `RouterBridgeBase` splits a location on the same boundary, to read the
- *   pathname half of an actor route. One function, so the two sides cannot disagree
- *   about where a pathname ends.
- */
-export declare function firstMarkIndex(path: string): number;
-//# sourceMappingURL=base-path.d.ts.map

package/dist/base-path.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"base-path.d.ts","sourceRoot":"","sources":["../src/base-path.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAIH;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,eAAe;IAC/B;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACvC;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,GAAG,SAAS,CAAC;CACtE;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAChC;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACxC;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,YAAY,EAAE,gBAGzB,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAqBvE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,eAAe,CAC9B,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,EAC7B,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,GAAG,SAAS,GAClD,gBAAgB,CAkElB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAK/E;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAgBnE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAMnD"}