npm - @xmachines/docs - Versions diffs - 3.0.0 → 5.0.0 - Mend

@xmachines/docs 3.0.0 → 5.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (567) hide show

package/api/@xmachines/play-dom-router/functions/createRouteMap.md DELETED Viewed

@@ -1,40 +0,0 @@
-[API](../../../README.md) / [@xmachines/play-dom-router](../README.md) / createRouteMap
-# Function: createRouteMap()
-```ts
-function createRouteMap(machine, options?): RouteMap;
-```
-Defined in: [play-router/src/create-route-map.ts:47](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/create-route-map.ts#L47)
-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 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.
-## Parameters
-| Parameter  | Type                                                                      | Description                                                                                                                     |
-| ---------- | ------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
-| `machine`  | [`AnyStateMachine`](https://www.jsdocs.io/package/xstate#AnyStateMachine) | The XState v5 state machine, with a `meta.route` annotation on each state with a route.                                         |
-| `options?` | [`RouteMapOptions`](../interfaces/RouteMapOptions.md)                     | The optional configuration. Give `{ cacheSize }` to change the default size of the LRU cache of the parameterized path lookups. |
-## Returns
-[`RouteMap`](../interfaces/RouteMap.md)
-A `RouteMap` for each adapter on `RouterBridgeBase`.
-## Example
-```typescript
-import { createRouteMap } from "@xmachines/play-router";
-import { connectRouter } from "@xmachines/play-dom-router";
-const routeMap = createRouteMap(myMachine);
-const disconnect = connectRouter({ actor, router, routeMap });
-```

package/api/@xmachines/play-dom-router/interfaces/DisposableBrowserHistory.md DELETED Viewed

@@ -1,262 +0,0 @@
-[API](../../../README.md) / [@xmachines/play-dom-router](../README.md) / DisposableBrowserHistory
-# Interface: DisposableBrowserHistory
-Defined in: [play-dom-router/src/create-browser-history.ts:87](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-dom-router/src/create-browser-history.ts#L87)
-The history that [createBrowserHistory](../functions/createBrowserHistory.md) builds.
-It IS a [BrowserHistory](BrowserHistory.md), and it says one thing more: `subscribe` hands back a
-[Cleanup](../type-aliases/Cleanup.md), so a caller may release it with `using` and write no teardown.
-```ts
-const history = createBrowserHistory({ window });
-{
-	using stop = history.subscribe((location) => render(location));
-	// stop() runs at the end of the scope, and after an exception too
-}
-```
-The history itself is a `Disposable` too, and [BrowserHistory.destroy](BrowserHistory.md#destroy) is what it
-releases. `destroy()` unpatches `history.pushState` and `history.replaceState` of the
-window, so a scope that drops the history without it leaves the global patched:
-```ts
-{
-	using history = createBrowserHistory({ window });
-	history.push("/first");
-	// destroy() runs at the end of the scope, and after an exception too
-}
-```
-A narrowed return and not a narrowed interface: the return type of a method may narrow
-in an extension, so this costs an implementer of `BrowserHistory` nothing. The dispose
-key is added here, and not on `BrowserHistory`, for the same reason.
-## Extends
-- [`BrowserHistory`](BrowserHistory.md)
-## Properties
-| Property                                  | Modifier   | Type      | Description                               | Inherited from                                                                          | Defined in                                                                                                                                                              |
-| ----------------------------------------- | ---------- | --------- | ----------------------------------------- | --------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| <a id="property-location"></a> `location` | `readonly` | `object`  | Returns the state of the current location | [`BrowserHistory`](BrowserHistory.md).[`location`](BrowserHistory.md#property-location) | [play-dom-router/src/create-browser-history.ts:7](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-dom-router/src/create-browser-history.ts#L7)   |
-| `location.hash`                           | `public`   | `string`  | -                                         | -                                                                                       | [play-dom-router/src/create-browser-history.ts:10](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-dom-router/src/create-browser-history.ts#L10) |
-| `location.pathname`                       | `public`   | `string`  | -                                         | -                                                                                       | [play-dom-router/src/create-browser-history.ts:8](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-dom-router/src/create-browser-history.ts#L8)   |
-| `location.search`                         | `public`   | `string`  | -                                         | -                                                                                       | [play-dom-router/src/create-browser-history.ts:9](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-dom-router/src/create-browser-history.ts#L9)   |
-| `location.state`                          | `public`   | `unknown` | -                                         | -                                                                                       | [play-dom-router/src/create-browser-history.ts:11](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-dom-router/src/create-browser-history.ts#L11) |
-## Methods
-### \[dispose\]()
-```ts
-dispose: void;
-```
-Defined in: [play-dom-router/src/create-browser-history.ts:91](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-dom-router/src/create-browser-history.ts#L91)
-Releases the history with [BrowserHistory.destroy](BrowserHistory.md#destroy). It is idempotent.
-#### Returns
-`void`
----
-### back()
-```ts
-back(): void;
-```
-Defined in: [play-dom-router/src/create-browser-history.ts:28](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-dom-router/src/create-browser-history.ts#L28)
-#### Returns
-`void`
-#### Inherited from
-[`BrowserHistory`](BrowserHistory.md).[`back`](BrowserHistory.md#back)
----
-### createHref()
-```ts
-createHref(path): string;
-```
-Defined in: [play-dom-router/src/create-browser-history.ts:46](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-dom-router/src/create-browser-history.ts#L46)
-Creates an href from a path
-#### Parameters
-| Parameter | Type     |
-| --------- | -------- |
-| `path`    | `string` |
-#### Returns
-`string`
-#### Inherited from
-[`BrowserHistory`](BrowserHistory.md).[`createHref`](BrowserHistory.md#createhref)
----
-### destroy()
-```ts
-destroy(): void;
-```
-Defined in: [play-dom-router/src/create-browser-history.ts:54](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-dom-router/src/create-browser-history.ts#L54)
-Cleans up.
-A second call is safe. When more than one wrapper shares the same
-`window.history`, the last wrapper restores the original methods.
-#### Returns
-`void`
-#### Inherited from
-[`BrowserHistory`](BrowserHistory.md).[`destroy`](BrowserHistory.md#destroy)
----
-### forward()
-```ts
-forward(): void;
-```
-Defined in: [play-dom-router/src/create-browser-history.ts:29](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-dom-router/src/create-browser-history.ts#L29)
-#### Returns
-`void`
-#### Inherited from
-[`BrowserHistory`](BrowserHistory.md).[`forward`](BrowserHistory.md#forward)
----
-### go()
-```ts
-go(delta): void;
-```
-Defined in: [play-dom-router/src/create-browser-history.ts:27](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-dom-router/src/create-browser-history.ts#L27)
-Moves back or forward in the history
-#### Parameters
-| Parameter | Type     |
-| --------- | -------- |
-| `delta`   | `number` |
-#### Returns
-`void`
-#### Inherited from
-[`BrowserHistory`](BrowserHistory.md).[`go`](BrowserHistory.md#go)
----
-### push()
-```ts
-push(path, state?): void;
-```
-Defined in: [play-dom-router/src/create-browser-history.ts:17](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-dom-router/src/create-browser-history.ts#L17)
-Pushes a new URL to the history
-#### Parameters
-| Parameter | Type      |
-| --------- | --------- |
-| `path`    | `string`  |
-| `state?`  | `unknown` |
-#### Returns
-`void`
-#### Inherited from
-[`BrowserHistory`](BrowserHistory.md).[`push`](BrowserHistory.md#push)
----
-### replace()
-```ts
-replace(path, state?): void;
-```
-Defined in: [play-dom-router/src/create-browser-history.ts:22](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-dom-router/src/create-browser-history.ts#L22)
-Replaces the current URL in the history
-#### Parameters
-| Parameter | Type      |
-| --------- | --------- |
-| `path`    | `string`  |
-| `state?`  | `unknown` |
-#### Returns
-`void`
-#### Inherited from
-[`BrowserHistory`](BrowserHistory.md).[`replace`](BrowserHistory.md#replace)
----
-### subscribe()
-```ts
-subscribe(...args): Cleanup;
-```
-Defined in: [play-dom-router/src/create-browser-history.ts:88](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-dom-router/src/create-browser-history.ts#L88)
-Subscribes to the history changes.
-It returns a function that cancels the subscription.
-The return is a plain function here, because a consumer IMPLEMENTS this interface
-to inject its own history for a test or for SSR. A `Cleanup` return would refuse
-every implementation that hands a plain function back.
-DisposableBrowserHistory narrows it for the value that
-[createBrowserHistory](../functions/createBrowserHistory.md) builds, which nothing implements.
-#### Parameters
-| Parameter | Type                       |
-| --------- | -------------------------- |
-| ...`args` | \[(`location`) => `void`\] |
-#### Returns
-[`Cleanup`](../type-aliases/Cleanup.md)
-#### Overrides
-[`BrowserHistory`](BrowserHistory.md).[`subscribe`](BrowserHistory.md#subscribe)

package/api/@xmachines/play-dom-router/interfaces/DisposableVanillaRouter.md DELETED Viewed

@@ -1,80 +0,0 @@
-[API](../../../README.md) / [@xmachines/play-dom-router](../README.md) / DisposableVanillaRouter
-# Interface: DisposableVanillaRouter\<History\>
-Defined in: [play-dom-router/src/create-router.ts:59](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-dom-router/src/create-router.ts#L59)
-The router that [createRouter](../functions/createRouter.md) returns: a [VanillaRouter](VanillaRouter.md) that a `using`
-scope can hold.
-The router OWNS the history, and the history patches `window.history.pushState`. It was
-the one release of this package that a scope could not hold: the history, a
-subscription of it, and the connection of the router each carry the protocol, and the
-router itself carried none, so a scope that forgot `destroy()` left the global patched.
-The release covers the HISTORY alone, exactly as `destroy()` always did. `connectRouter`
-hands back its own `RouterConnection`, and a scope that ends releases no connection for
-the caller: release the connection first, then the router.
-```ts
-using router = createRouter({ routeTree, history });
-```
-The key sits on THIS type and not on [VanillaRouter](VanillaRouter.md), exactly as
-`DisposableBrowserHistory` sits beside `BrowserHistory`: a caller that builds a router
-of its own — a test double, or a router of another history — keeps a type that asks for
-no dispose key.
-A caller that keeps `destroy()` keeps it: the two release the same work, and the
-release is idempotent because `BrowserHistory.destroy` is.
-## Extends
-- [`VanillaRouter`](VanillaRouter.md)\<`History`\>
-## Type Parameters
-| Type Parameter                                            | Default type                          |
-| --------------------------------------------------------- | ------------------------------------- |
-| `History` _extends_ [`BrowserHistory`](BrowserHistory.md) | [`BrowserHistory`](BrowserHistory.md) |
-## Properties
-| Property                                    | Modifier   | Type                                                     | Description                                     | Inherited from                                                                         | Defined in                                                                                                                                            |
-| ------------------------------------------- | ---------- | -------------------------------------------------------- | ----------------------------------------------- | -------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
-| <a id="property-history"></a> `history`     | `readonly` | `History`                                                | The history instance                            | [`VanillaRouter`](VanillaRouter.md).[`history`](VanillaRouter.md#property-history)     | [play-dom-router/src/create-router.ts:21](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-dom-router/src/create-router.ts#L21) |
-| <a id="property-routetree"></a> `routeTree` | `readonly` | [`RouteTree`](../../play-router/interfaces/RouteTree.md) | The route tree, as a reference to the structure | [`VanillaRouter`](VanillaRouter.md).[`routeTree`](VanillaRouter.md#property-routetree) | [play-dom-router/src/create-router.ts:26](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-dom-router/src/create-router.ts#L26) |
-## Methods
-### \[dispose\]()
-```ts
-dispose: void;
-```
-Defined in: [play-dom-router/src/create-router.ts:62](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-dom-router/src/create-router.ts#L62)
-#### Returns
-`void`
----
-### destroy()
-```ts
-destroy(): void;
-```
-Defined in: [play-dom-router/src/create-router.ts:31](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-dom-router/src/create-router.ts#L31)
-Cleans up
-#### Returns
-`void`
-#### Inherited from
-[`VanillaRouter`](VanillaRouter.md).[`destroy`](VanillaRouter.md#destroy)

package/api/@xmachines/play-react/functions/useSignalEffect.md DELETED Viewed

@@ -1,77 +0,0 @@
-[API](../../../README.md) / [@xmachines/play-react](../README.md) / useSignalEffect
-# Function: useSignalEffect()
-```ts
-function useSignalEffect(callback, deps?): void;
-```
-Defined in: [packages/play-react/src/useSignalEffect.ts:81](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-react/src/useSignalEffect.ts#L81)
-The React hook that subscribes to the signal changes and runs an effect callback
-The hook puts the callback in a Signal.Computed, which tracks each signal that
-the callback reads. It then gives the watcher lifecycle to `watchSignal` from
-`@xmachines/play-signals`. That function does the microtask batching, the new arm
-of the watcher, and the disposal. It is the one canonical implementation, and
-every framework renderer uses it.
-Architecture:
-- The hook puts the callback in a Signal.Computed for the dependency tracking
-- watchSignal owns the Signal.subtle.Watcher lifecycle (Phase 29, memory safety)
-- The microtask batching groups rapid signal updates
-- The callback triggers each new render with its own setState (see the remarks)
-- The hook cleans up on unmount, so that nothing stays in memory
-Invariant: Signal-Only Reactivity. The hook watches each signal that the callback reads.
-Invariant: Passive Infrastructure. React observes the signals, and it does not control them.
-## Parameters
-| Parameter  | Type                           | Default value | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
-| ---------- | ------------------------------ | ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `callback` | () => `void` \| (() => `void`) | `undefined`   | The effect function that reads the signals. It can return a cleanup function.                                                                                                                                                                                                                                                                                                                                                                                                         |
-| `deps`     | `DependencyList`               | `[]`          | The optional dependency list, as in useEffect. On a change of one dependency, the hook removes the watcher and the Computed, then makes them again and tracks the signals from the start. The default is `[]`, which subscribes one time for each mount. Give this list when the identity of the object whose signals you read can change during the life of the component, for example an `actor` prop. Without the list, the watcher tracks the signals of the OLD object for ever. |
-## Returns
-`void`
-## Example
-```typescript
-const MyComponent = ({ actor }) => {
-  const [view, setView] = useState(null);
-  // Subscribe to the actor.currentView signal, and subscribe again on a new actor
-  useSignalEffect(() => {
-    const currentView = actor.currentView.get();
-    setView(currentView);
-  }, [actor]);
-  return <div>{view?.root}</div>;
-};
-```
-## Remarks
-**CRITICAL:** read each signal unconditionally, with no `if` statement. A
-conditional read breaks the dependency tracking.
-**Performance:** the microtask batching (queueMicrotask, inside watchSignal)
-stops a flood of React renders when several signals update in rapid sequence.
-**Re-rendering:** the hook itself does NOT force a React render on a signal
-change. The callback triggers each new render, because it calls setState with the
-new signal value, as in the example above. The setState bailout of React can
-therefore skip a render when the derived value is the same. An unconditional
-force-update here caused one wasted render for each notification before, also
-when the setState of the callback made the bailout. If you must render again on
-every notification, and you read the signals during the render, copy the signal
-value into the React state inside the callback.
-**Implementation note:** the hook puts the callback in a Signal.Computed, because
-Signal.subtle.Watcher cannot track an arbitrary function call. The Computed does
-the dependency tracking. watchSignal evaluates the Computed, which runs the
-callback, on each change of a tracked signal.

package/api/@xmachines/play-react/type-aliases/PlayRendererProps.md DELETED Viewed

@@ -1,13 +0,0 @@
-[API](../../../README.md) / [@xmachines/play-react](../README.md) / PlayRendererProps
-# ~~Type Alias: PlayRendererProps~~
-```ts
-type PlayRendererProps = ActorProviderProps;
-```
-Defined in: [packages/play-react/src/index.ts:71](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-react/src/index.ts#L71)
-## Deprecated
-Use [ActorProviderProps](../interfaces/ActorProviderProps.md). Will be removed in the next major.

package/api/@xmachines/play-react-router/functions/createRouteMap.md DELETED Viewed

@@ -1,40 +0,0 @@
-[API](../../../README.md) / [@xmachines/play-react-router](../README.md) / createRouteMap
-# Function: createRouteMap()
-```ts
-function createRouteMap(machine, options?): RouteMap;
-```
-Defined in: [play-router/src/create-route-map.ts:47](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/create-route-map.ts#L47)
-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 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.
-## Parameters
-| Parameter  | Type                                                                      | Description                                                                                                                     |
-| ---------- | ------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
-| `machine`  | [`AnyStateMachine`](https://www.jsdocs.io/package/xstate#AnyStateMachine) | The XState v5 state machine, with a `meta.route` annotation on each state with a route.                                         |
-| `options?` | [`RouteMapOptions`](../interfaces/RouteMapOptions.md)                     | The optional configuration. Give `{ cacheSize }` to change the default size of the LRU cache of the parameterized path lookups. |
-## Returns
-[`RouteMap`](../classes/RouteMap.md)
-A `RouteMap` for each adapter on `RouterBridgeBase`.
-## Example
-```typescript
-import { createRouteMap } from "@xmachines/play-router";
-import { connectRouter } from "@xmachines/play-dom-router";
-const routeMap = createRouteMap(myMachine);
-const disconnect = connectRouter({ actor, router, routeMap });
-```

package/api/@xmachines/play-react-router/interfaces/PlayActor.md DELETED Viewed

@@ -1,70 +0,0 @@
-[API](../../../README.md) / [@xmachines/play-react-router](../README.md) / PlayActor
-# Interface: PlayActor
-Defined in: [play-router/src/types.ts:313](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/types.ts#L313)
-The complete actor shape of the `PlayRouterProvider` component of each framework
-adapter: `play-solid-router`, `play-vue-router`, `play-react-router`, and each
-adapter on the shared framework router bridge bases.
-The shape extends `RoutableActor` with `currentView`, because the provider renders
-the current view spec and also keeps the routes in step. It therefore needs both
-capabilities.
-- Use `RoutableActor` when you need the routing alone, for example in a
-  `RouterBridgeBase` subclass, or in `connectRouter`.
-- Use `PlayActor` when the component also renders the current view spec, for
-  example for the renderer callback parameter of `PlayRouterProvider`, and in
-  `PlayRenderer`.
-Every `AbstractActor` subclass that implements both `Routable` and `Viewable`
-satisfies this interface structurally.
-## Example
-```typescript
-import type { PlayActor } from "@xmachines/play-router";
-function MyRouterProvider({ actor }: { actor: PlayActor }) {
-	// it reads actor.currentRoute for the routing, and actor.currentView for the render
-}
-```
-## Extends
-- [`RoutableActor`](../../play-dom-router/interfaces/RoutableActor.md)
-## Properties
-| Property                                          | Modifier   | Type                                                                                                                                | Description                                                                                                                                                                                                                              | Inherited from                                                                                                                                                 | Defined in                                                                                                                      |
-| ------------------------------------------------- | ---------- | ----------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
-| <a id="property-currentroute"></a> `currentRoute` | `readonly` | [`Computed`](../../play-signals/namespaces/Signal/classes/Computed.md)\<`string` \| `null`\>                                        | The TC39 Signal of the current URL path of the actor, or of its state ID.                                                                                                                                                                | [`RoutableActor`](../../play-dom-router/interfaces/RoutableActor.md).[`currentRoute`](../../play-dom-router/interfaces/RoutableActor.md#property-currentroute) | [play-router/src/types.ts:275](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/types.ts#L275) |
-| <a id="property-currentview"></a> `currentView`   | `readonly` | [`State`](../../play-signals/namespaces/Signal/classes/State.md)\<[`PlaySpec`](../../play-actor/interfaces/PlaySpec.md) \| `null`\> | The TC39 Signal of the current view spec of the actor, or `null` when no view is active.                                                                                                                                                 | -                                                                                                                                                              | [play-router/src/types.ts:315](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/types.ts#L315) |
-| <a id="property-initialroute"></a> `initialRoute` | `readonly` | `string` \| `null`                                                                                                                  | The route of the initial state of the machine. The constructor fixes it. A router bridge compares it with the browser URL. It therefore separates a deep link, where the router wins, from a restore of a session, where the actor wins. | [`RoutableActor`](../../play-dom-router/interfaces/RoutableActor.md).[`initialRoute`](../../play-dom-router/interfaces/RoutableActor.md#property-initialroute) | [play-router/src/types.ts:281](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/types.ts#L281) |
-## Methods
-### send()
-```ts
-send(event): void;
-```
-Defined in: [play-router/src/types.ts:283](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/types.ts#L283)
-Sends a route navigation event to the actor.
-#### Parameters
-| Parameter | Type                                  |
-| --------- | ------------------------------------- |
-| `event`   | [`PlayRouteEvent`](PlayRouteEvent.md) |
-#### Returns
-`void`
-#### Inherited from
-[`RoutableActor`](../../play-dom-router/interfaces/RoutableActor.md).[`send`](../../play-dom-router/interfaces/RoutableActor.md#send)

package/api/@xmachines/play-router/functions/extractMachineRoutes.md DELETED Viewed

@@ -1,29 +0,0 @@
-[API](../../../README.md) / [@xmachines/play-router](../README.md) / extractMachineRoutes
-# Function: extractMachineRoutes()
-```ts
-function extractMachineRoutes(machine): RouteTree;
-```
-Defined in: [play-router/src/extract-routes.ts:92](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/extract-routes.ts#L92)
-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.
-## Parameters
-| Parameter | Type                                                                      | Description                 |
-| --------- | ------------------------------------------------------------------------- | --------------------------- |
-| `machine` | [`AnyStateMachine`](https://www.jsdocs.io/package/xstate#AnyStateMachine) | The XState v5 state machine |
-## Returns
-[`RouteTree`](../interfaces/RouteTree.md)
-The route tree, with its root, its byStateId map, its byPath map, and its graph

package/api/@xmachines/play-router/functions/findRouteByPath.md DELETED Viewed

@@ -1,41 +0,0 @@
-[API](../../../README.md) / [@xmachines/play-router](../README.md) / findRouteByPath
-# Function: findRouteByPath()
-```ts
-function findRouteByPath(tree, path): RouteNode | undefined;
-```
-Defined in: [play-router/src/find-route.ts:86](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v3.0.0/packages/play-router/src/find-route.ts#L86)
-Finds a route node by its URL path
-The function looks the route node up by the URL path. It gives you the state ID of
-a browser URL, for the `play.route` event of a navigation.
-When more than one state holds the same path, for example the root and a second
-state both at "/", the function prefers a node with a route, which means a node
-with a `meta.route` field, over a node without one.
-The function also matches a pattern of a dynamic route, for example
-'/settings/:section?'.
-## Parameters
-| Parameter | Type                                      | Description                                                   |
-| --------- | ----------------------------------------- | ------------------------------------------------------------- |
-| `tree`    | [`RouteTree`](../interfaces/RouteTree.md) | The route tree, from extractMachineRoutes                     |
-| `path`    | `string`                                  | The URL path, for example '/dashboard' or '/settings/profile' |
-## Returns
-[`RouteNode`](../interfaces/RouteNode.md) \| `undefined`
-The route node, or undefined when the function finds none
-## Example
-```typescript
-const tree = extractMachineRoutes(machine);
-const node = findRouteByPath(tree, "/dashboard");
-```