@xmachines/play-router 2.1.0 → 2.2.0

package/dist/router-bridge-base.d.ts

@@ -43,8 +43,8 @@
  * @see [Play RFC](../../docs/rfc/play.md) - invariant INV-04
  */
 import { Signal } from "@xmachines/play-signals";
-import type { RoutableActor } from "./types.js";
-import type { RouterBridge } from "./types.js";
+import type { MountableRouterBridge, RoutableActor } from "./types.js";
+import { type BasePathOptions } from "./base-path.js";
 /**
  * The narrow interface of the TC39 Signal watcher. `RouterBridgeBase` uses it to
  * observe each change of `actor.currentRoute`.
@@ -63,14 +63,7 @@ export interface RouteWatcherHandle {
     /** Stops the observation and frees the watcher. */
     unwatch(): void;
 }
-/**
- * The abstract base class of every router adapter bridge of `@xmachines`.
- *
- * The class implements the RouterBridge protocol, and it holds every part of the
- * bridge logic that the adapters share. A subclass implements the 3 abstract methods
- * that are different in each framework, and it implements nothing more.
- */
-export declare abstract class RouterBridgeBase implements RouterBridge {
+export declare abstract class RouterBridgeBase implements MountableRouterBridge {
     protected readonly actor: RoutableActor;
     protected readonly routeMap: {
         getStateIdByPath(path: string): string | null | undefined;
@@ -78,7 +71,35 @@ export declare abstract class RouterBridgeBase implements RouterBridge {
     };
     protected isConnected: boolean;
     protected hasConnectedOnce: boolean;
+    /**
+     * The machine-side location that the router holds, as far as this bridge knows. It
+     * carries the query and the fragment, and it carries NO `basePath`.
+     *
+     * Only code that saw a location, or that wrote one, writes this field:
+     * `performInitialSync` when it finds the two sides in step, `takeReturnUnderMount`
+     * for the same test under a mount, `pushResolvedRoute` after it resolves a route to
+     * a concrete path, and `syncActorFromRouter` for the location that the router
+     * reports. `null` means that this bridge placed no location yet, so it knows nothing
+     * about the address bar, and every test against this field must then answer "no".
+     *
+     * The field held the route of the actor as well, from the seed of the constructor
+     * and from a route that resolves to no URL. Those two values describe no location
+     * that a router ever showed, and each reader of this field asks about a location, so
+     * each of them read them wrongly. {@link lastActorRoute} holds them now.
+     */
     protected lastSyncedPath: string | null;
+    /**
+     * The raw value of `actor.currentRoute` that this bridge accounted for already.
+     *
+     * The field answers ONE question: "did the bridge see this value of the signal
+     * before?". It is therefore a string, and not a location — a route that resolves to
+     * no URL, such as an unknown stateId or a parameterized pattern, still stops a
+     * second attempt at the same value.
+     *
+     * The constructor and `connect()` seed it, so that the first fire of the watcher of
+     * the signal pushes nothing for a route that moved nowhere.
+     */
+    protected lastActorRoute: string | null;
     /**
      * The flag guards `syncActorFromRouter` against a re-entrant call from a guard
      * redirect of the actor itself. Such a call has this sequence: the bridge sends to
@@ -87,11 +108,73 @@ export declare abstract class RouterBridgeBase implements RouterBridge {
      *
      * The flag is NOT the echo suppression of the direction from the actor to the
      * router. `lastSyncedPath` does that work alone: the bridge writes it before the
-     * `navigateRouter()` call. Therefore each router callback of the same path stops at
-     * the `sanitized === lastSyncedPath` test in `syncActorFromRouter`.
+     * `navigateRouter()` call. Therefore each router callback of the same location stops
+     * at the {@link isEchoOfLastSync} test in `syncActorFromRouter`.
      */
     protected isProcessingNavigation: boolean;
+    /**
+     * Who owns the address bar, and what this bridge owes it.
+     *
+     * - `"under-mount"` — the location lies under the mount, so this bridge owns the
+     *   address bar and it writes the location for every route of its actor.
+     * - `"outside"` — the location lies outside the mount, so the HOST owns it. The
+     *   bridge sends no event and it corrects no URL, which is what lets the routes of
+     *   the host and the routes of the machine share one router.
+     * - `"outside-push-owed"` — outside, AND the route of the actor changed while the
+     *   host owned the address bar. The push waits here instead of going to the router,
+     *   and {@link RouterBridgeBase.takeReturnUnderMount} spends it when the location
+     *   comes back. The machine therefore keeps its place while the user reads a page of
+     *   the host.
+     *
+     * ONE value, and not a latch plus a memory. The memory only ever means something
+     * while the latch is up, so two fields could hold a fourth combination that says
+     * "the bridge owns the address bar AND a push waits for a return" — a state with no
+     * meaning, which a return would spend at a location the router already holds. Two
+     * writes also cannot happen together: every site that lowered the latch wrote the
+     * memory on the NEXT line, and the value between the two lines was that fourth
+     * combination. `takeReturnUnderMount` reads the value it replaces instead.
+     *
+     * `syncActorFromRouter` is the one place that sees a location, so it is the one
+     * place that decides between `"under-mount"` and `"outside"`.
+     * `performInitialSync` decides it for the location that the page loaded with.
+     *
+     * A bridge with no mount never leaves its mount: `stripBasePath` returns the path
+     * unchanged for an empty prefix, and never `null`. The value therefore stays
+     * `"under-mount"` for every bridge that takes no `basePath`.
+     */
+    private mountState;
+    /**
+     * True once the first synchronization ran against a location INSIDE the mount.
+     *
+     * `performInitialSync` separates a deep link from a restore, and it can make that
+     * decision only for a location that lies under the mount. A bridge that connects
+     * while the host owns the address bar therefore reaches no decision at all: it
+     * raises the latch and returns. The flag says that the decision is still owed, and
+     * `syncActorFromRouter` pays it at the first location that IS under the mount —
+     * through {@link RouterBridgeBase.takeReturnUnderMount} for a RETURN, which needs the
+     * decision itself, and directly for every other location under the mount.
+     *
+     * A bridge with no mount never leaves its mount, so `performInitialSync` writes this
+     * flag on the first `connect()` and nothing reads it again.
+     */
+    private hasSynchronizedUnderMount;
     protected routeWatcher: RouteWatcherHandle | null;
+    /**
+     * The mount point of the machine inside the host router: the resolved prefix, and
+     * the values of each `:param` of that prefix.
+     *
+     * The prefix lives here, and NOT in the route map, for two reasons. 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. And
+     * the bridge is the boundary between a location of the host router and a path of
+     * the machine already, which is exactly what the prefix separates.
+     *
+     * `lastSyncedPath` stays MACHINE-side, and it carries no prefix. The code adds the
+     * prefix at the one `navigateRouter()` call in `pushResolvedRoute`, and it removes
+     * the prefix at the one inbound entry point `syncActorFromRouter`. Every test of
+     * the echo suppression therefore keeps comparing like with like.
+     */
+    private mount;
     /**
      * @param actor    - A `RoutableActor`, with `currentRoute`, `initialRoute`, and `send`.
      * @param routeMap - The route map of both directions, for the resolution between a
@@ -104,7 +187,113 @@ export declare abstract class RouterBridgeBase implements RouterBridge {
     constructor(actor: RoutableActor, routeMap: {
         getStateIdByPath(path: string): string | null | undefined;
         getPathByStateId(id: string): string | null | undefined;
-    });
+    }, options?: BasePathOptions);
+    /**
+     * The resolved URL prefix that the machine of this bridge is mounted under, or `""`
+     * when the machine owns the complete router.
+     */
+    get basePath(): string;
+    /**
+     * The resolved values of the `:param` segments of the mount, or `{}` for a prefix
+     * without a param.
+     *
+     * These params belong to the HOST: the host wrote the prefix and resolved the
+     * values, and they describe the route of the host and not the route of the machine.
+     * They therefore 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.
+     *
+     * They live here instead, because a value that reached the actor on a navigation
+     * ALONE would go stale: `setBasePath()` can move the mount while the machine stays
+     * on the same route, no event goes out, and `event.params` would then contradict
+     * `basePath`. A read of this accessor cannot go stale.
+     *
+     * A machine that needs the identity of its host — a `machineId`, a tenant — takes
+     * it through the `input` of the actor, where it belongs: that identity decides
+     * WHICH machine runs, and it is not a param of a route inside the machine.
+     *
+     * @example
+     * ```typescript
+     * bridge.basePath;        // "/abc123/play"
+     * bridge.basePathParams;  // { machineId: "abc123" }
+     * ```
+     */
+    get basePathParams(): Readonly<Record<string, string>>;
+    /**
+     * Moves the machine to a different mount point, while it stays connected.
+     *
+     * This is the "load and unload" half of a shared router. It moves WHERE an actor is
+     * mounted, and never WHICH actor is mounted: the actor, the route map, and its LRU
+     * cache all stay, and nothing goes away.
+     *
+     * An actor never changes identity. A prefix that IDENTIFIES the actor — a
+     * `machineId` that names the document it runs — therefore never moves through this
+     * method: a new identity is a new actor, and a new actor takes a new bridge, because
+     * `connect()` permits one bridge for each actor. The segments that move here are the
+     * ones that LOCATE: a region, a locale, a tenant, a workspace slug.
+     *
+     * The call then brings the location in step with the NEW prefix. A location inside
+     * the new mount runs the same first-synchronization decision as `connect()`: it
+     * drives the actor, and a restore keeps the route of the actor. A location OUTSIDE
+     * the new mount is the old mount in practice, so the bridge writes the new one
+     * itself, and it keeps the route of the actor while it does so — nothing else moves
+     * the address bar. A call that resolves to the current prefix changes no location,
+     * and it therefore reconciles nothing.
+     *
+     * @param basePath - The new prefix, as a pattern or as a concrete path. An absent
+     *   value, `""`, and `"/"` all remove the prefix, and they give the machine the
+     *   complete router again.
+     * @param basePathParams - The values of the `:param` segments of `basePath`.
+     * @throws {InvalidBasePathError} For a prefix that resolves to one concrete path never.
+     * @throws {MissingBasePathParamError} When a `:param` of the prefix has no value.
+     *
+     * @example
+     * ```typescript
+     * // The host moved this actor to another place in its URL space. `machineId` names
+     * // WHICH document the actor runs, and it does not change: a new identity is a new
+     * // actor, and therefore a new bridge, because one actor takes one bridge.
+     * bridge.setBasePath("/:region/:machineId/play", { region: "us", machineId });
+     * ```
+     */
+    setBasePath(basePath?: BasePathOptions["basePath"], basePathParams?: BasePathOptions["basePathParams"]): void;
+    /**
+     * Brings the location of the router in step with a mount that just moved.
+     *
+     * **The location lies under the new mount:** run the same first-synchronization
+     * decision as `connect()`, so a location inside the mount drives the actor and a
+     * restore keeps the route of the actor.
+     *
+     * **The location lies outside it:** the bridge writes the new mount ITSELF, and it
+     * keeps the route of the actor while it does so. A host that re-points a mount
+     * changes no location by itself, and nothing else moves the address bar. Without
+     * this push the machine sits at a mount that no location is under: it hears no
+     * `play.route`, `lastSyncedPath` is clear already, and the stale prefix stays in the
+     * URL until the route of the actor happens to change — which then jumps the URL with
+     * no reason that the history of the user explains.
+     *
+     * `pushResolvedRoute` writes `lastSyncedPath` before it navigates, so the callback
+     * of the router for this push stops at the echo suppression, and it sends no event.
+     */
+    private reconcileLocationWithMount;
+    /**
+     * Pushes a route to the router, and it holds {@link isProcessingNavigation} across
+     * the write.
+     *
+     * Every corrective push of the bridge needs that flag: `navigateRouter` makes the
+     * router call `syncActorFromRouter` again inside it, and a router that NORMALIZES the
+     * location it receives — a `validateSearch` that injects a default, a trailing slash
+     * that a history adds — reports a value that the echo test misses. The bridge would
+     * then answer its own write with a `play.route` event, and on a press of BACK that
+     * answer is a history entry that FORWARD cannot return to.
+     *
+     * The one push that does NOT come through here is `syncRouterFromActor`: that push
+     * follows the actor, and the echo suppression of `lastSyncedPath` is what stops it.
+     *
+     * @param route    - The raw value of the actor route.
+     * @param resolved - The concrete path of that route, when the caller resolved it
+     *   already. `undefined` resolves it in `pushResolvedRoute`.
+     */
+    private pushHoldingNavigation;
     /**
      * Connects the router bridge to the Actor.
      *
@@ -113,7 +302,7 @@ export declare abstract class RouterBridgeBase implements RouterBridge {
      * in its own way.
      *
      * The order of these steps is part of the contract of the bridge:
-     * - The constructor seeds `lastSyncedPath` from `actor.currentRoute`
+     * - The constructor seeds `lastActorRoute` from `actor.currentRoute`, and it records no location
      * - The method installs the actor watcher before the router subscriptions of the adapter
      * - The first synchronization then separates a deep link from a restore, with `actor.initialRoute`
      *
@@ -122,6 +311,33 @@ export declare abstract class RouterBridgeBase implements RouterBridge {
      * `connect()`.
      */
     connect(): void;
+    /**
+     * Brings the actor and the router in step one time, and decides which side wins.
+     *
+     * The method is separate from `connect()`, so that `connect()` can roll the whole
+     * first synchronization back when it throws. See the `try` block there.
+     *
+     * The first synchronization: the direction from the router to the actor has the
+     * priority over the other direction.
+     *
+     * The page can load on a URL that is not the initial state of the actor. For
+     * example, the user types "/about", or the user follows a deep link. The router
+     * holds the correct path then, and the actor is still at its initial state ("/").
+     * The code must therefore drive the actor to the URL, and it must not write the
+     * default of the actor to the URL.
+     *
+     * router.subscribe() fires on a *later* navigation event only. It does NOT fire for
+     * the location that the page loaded. A subclass that can read the current location
+     * of its router synchronously overrides getInitialRouterPath().
+     *
+     * @param initialRouterPath - The location of the router. Every caller reads it and
+     *   passes it, and this parameter carries NO default: a default fires for an
+     *   explicit `undefined` too, so `reconcileLocationWithMount` asked the adapter a
+     *   SECOND time for exactly the value that says "the adapter does the first
+     *   synchronization itself" — and a read belongs to the adapter, which can walk the
+     *   state of a router and answer differently on the second call.
+     */
+    private performInitialSync;
     /**
      * Disconnects the router bridge from the Actor.
      *
@@ -150,6 +366,68 @@ export declare abstract class RouterBridgeBase implements RouterBridge {
      * redirect.
      */
     protected syncRouterFromActor(route: string | null | unknown): void;
+    /**
+     * Records that the location lies outside the mount, so the HOST owns the address bar.
+     *
+     * A bridge that is outside ALREADY keeps the value it holds: `"outside-push-owed"`
+     * says that a push waits for the address bar to come back, and a second location of
+     * the host is no reason to forget it.
+     */
+    private markOutside;
+    /**
+     * Takes the return of the address bar under the mount.
+     *
+     * The actor wins that return when it moved while the host owned the location AND the
+     * address bar came back to the location it still held: the method pushes the route of
+     * the actor, and the caller sends no `play.route` event. A return to any other route
+     * of the mount belongs to the host, so the memory goes and the caller drives the
+     * actor from the location instead.
+     *
+     * The method also pays the first synchronization that the mount still owes. A bridge
+     * that connected while the host owned the address bar reached no decision between a
+     * deep link and a restore: `performInitialSync` can decide only for a location under
+     * the mount, and it found none. This is the first such location, so the decision runs
+     * here, with the same rule.
+     *
+     * The method holds `isProcessingNavigation` across each push, because
+     * `navigateRouter` makes the router call `syncActorFromRouter` again.
+     *
+     * @returns `true` when the method handled the location, so the caller returns.
+     */
+    private takeReturnUnderMount;
+    /**
+     * Writes the route of the actor to a router that just came under the mount.
+     *
+     * The method holds `isProcessingNavigation` across the push, because
+     * `navigateRouter` makes the router call `syncActorFromRouter` again inside it.
+     *
+     * A re-entrant call pushes nothing inside another push, and the memory of a
+     * suppressed push DOES survive that case: the outer push is still in flight, and a
+     * clear here would throw the remembered route away with nothing left to replay it.
+     *
+     * @param route - The raw value of the actor route.
+     * @returns `true` when the method wrote the location, so that the caller returns and
+     *   sends no event. `false` when the route resolves to no concrete path, so that the
+     *   caller drives the actor from the location instead.
+     */
+    private pushUnderMount;
+    /**
+     * Tests a route of the actor against the last synchronized location.
+     *
+     * The exact string test covers a stateId, for example `"#home"`, which
+     * `pushResolvedRoute` writes to the field when it cannot resolve a path. The query
+     * test covers a location that carries a query: the order of the keys of a query is
+     * not significant, so `?b=2&a=1` and `?a=1&b=2` are the same location, and the
+     * bridge must push neither of them back.
+     *
+     * The FRAGMENT counts in this direction, and the inbound test ignores it. The two
+     * are different questions. `navigateRouter` writes the whole value that the actor
+     * gave — `buildRouteUrl` appends `context.hash` — so `"/docs"` and `"/docs#intro"`
+     * are two locations to write, and a test that read them as one left the fragment out
+     * of the address bar for ever. `isEchoOfLastSync` compares against what the ROUTER
+     * reports, and `sanitizePathname` has removed the fragment from that already.
+     */
+    private testEchoOfLastPush;
     /**
      * Resolves an actor route to its concrete URL path, and pushes that path to the
      * router.
@@ -165,6 +443,11 @@ export declare abstract class RouterBridgeBase implements RouterBridge {
      * literal `*` into the browser URL. The method still writes the raw route to
      * lastSyncedPath. Therefore the dedup guard fires correctly on the next identical
      * value of the signal.
+     *
+     * @param route    - The raw value of the actor route.
+     * @param resolved - The concrete path of that route. The default resolves it here. A
+     *   caller that resolved it already passes it, so that `resolveNavigationPath` runs
+     *   one time: the method is `protected`, and a subclass can override it.
      */
     private pushResolvedRoute;
     /**
@@ -214,10 +497,43 @@ export declare abstract class RouterBridgeBase implements RouterBridge {
      * through `lookupPathByStateId`. Therefore a route map of your own that holds one
      * form only still resolves the path.
      *
+     * The result is MACHINE-side: it carries no `basePath`, because it is also the
+     * value that `lastSyncedPath` stores and that the code compares against an actor
+     * route. The code adds the prefix one time, at the `navigateRouter()` call in
+     * `pushResolvedRoute`.
+     *
      * @param route - The raw value of the actor route: a stateId, a stateId with a `#`, or a concrete path
-     * @returns The concrete URL path, or `null` when the bridge must skip the navigation
+     * @returns The concrete machine-side URL path, or `null` when the bridge must skip the navigation
      */
     protected resolveNavigationPath(route: string): string | null;
+    /**
+     * Tells you whether the actor already stands at a location of the router.
+     *
+     * The `currentRoute` of the actor can be a stateId, for example `"#app.home"`, while a
+     * location of the router is a URL path, for example `"/home"`. Therefore the method
+     * resolves the path to a stateId before it compares. Without this step, a false "the
+     * two are different" starts a synchronization that nothing needs — and, in
+     * `takeReturnUnderMount`, it reads a location that the HOST chose as a restore of the
+     * actor and writes over it.
+     *
+     * The actor is at the location in three cases: the stateId of the match IS the actor
+     * route, the path of the match IS the actor route, or the actor route is a stateId
+     * that resolves to the same registered path as the stateId of the match. Each lookup
+     * goes through {@link lookupPathByStateId}, which tries the form `"#stateId"` and also
+     * the bare form `"stateId"`. Therefore a route map with `"#about"` recognizes an actor
+     * route of `"about"`, and the opposite also works, and this is correct for a
+     * structural map of your own that holds one form. An actor route with a concrete path,
+     * which starts with `"/"`, goes to a direct comparison with the path of the router
+     * only.
+     *
+     * Each lookup runs ONE time. `getPathByStateId` belongs to the route map: a map of a
+     * consumer can answer differently on a second call, and `RouteMap` pays a cache lookup
+     * for each of them.
+     *
+     * @param machinePath - The machine half of the location of the router.
+     * @param actorRoute  - The raw value of the actor route.
+     */
+    private isActorAtLocation;
     /**
      * Returns the path of the route map for a value of an actor route, and it tries both
      * forms of a stateId.
@@ -241,6 +557,28 @@ export declare abstract class RouterBridgeBase implements RouterBridge {
      * @returns The query parameters of the read, or an empty object
      */
     protected extractQuery(search: string): Record<string, string>;
+    /**
+     * True when a location of the router is the location that this bridge pushed.
+     *
+     * `lastSyncedPath` holds the value of `actor.currentRoute`, and that value carries
+     * the query string of `context.query`, for example `"/dates?trip=one-way"`. A router
+     * callback reports the pathname and the search SEPARATELY, and `sanitizePathname`
+     * removes the query. A comparison of the pathname alone therefore misses for every
+     * route with a query, and the push of this bridge comes back as a `play.route` event
+     * of its own navigation. That echo is not only wasted work: it writes to the signal
+     * graph from inside the watcher callback of the actor route, and the watcher then
+     * arms itself again on a computed that is dirty already, which ends the direction
+     * from the actor to the router for the rest of the session.
+     *
+     * The query is compared as a MAP, and not as a string: a framework can re-serialize
+     * a search string in another order, and `URLSearchParams` also accepts the form with
+     * a leading `?` and the form without one.
+     *
+     * @param sanitized - The clean pathname of the router callback, with no query.
+     * @param search - The search string of the router callback, when it has one.
+     * @returns True when the location is the echo of the last push of this bridge.
+     */
+    private isEchoOfLastSync;
     /**
      * The method must start the navigation of the framework router, for example with a
      * router.navigate(path) call.

package/dist/router-bridge-base.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"router-bridge-base.d.ts","sourceRoot":"","sources":["../src/router-bridge-base.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"router-bridge-base.d.ts","sourceRoot":"","sources":["../src/router-bridge-base.ts"],"names":[],"mappings":"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"}