@xmachines/play-xstate 6.1.0 → 7.0.0

package/dist/view/derive-current-view.js

@@ -1,235 +1,257 @@
-import { composePlayState, composeViews, toAtomState, } from "@xmachines/play-view";
+import { activeChildKeys, activeChildValue, branchOrder, flatStateMeta, warnStateIds } from "../state-meta.js";
 import { createWarnOnce } from "@xmachines/core/utils";
-import { activeChildKeys, activeChildValue, activeStateMeta, branchOrder, } from "../state-meta.js";
+import { composePlayState, composeViews, toAtomState } from "@xmachines/play-view";
+//#region packages/play-xstate/src/view/derive-current-view.ts
 /**
- * The migration warning of the `contextProps` field, which 1.x removed. The code
- * writes it one time for each spec. A meta.view object from a person passes around
- * `typedSpec`, and a spec with the field therefore compiles without an error. But
- * the meaning of the field inverted: it was an allowlist, or an empty filter that
- * projected nothing, and the whole context is the value now. The key is the static
- * meta.view object. Therefore the warning appears one time, and not for each
- * snapshot.
- */
-const warnOnce = createWarnOnce();
-const warnRemovedContextProps = (viewMeta) => {
-    warnOnce(viewMeta, "[play-xstate] meta.view.contextProps has been removed: the whole machine context " +
-        "is always projected under /context. Delete the field — it no longer filters anything.");
+* The migration warning of the `contextProps` field, which 1.x removed. The code
+* writes it one time for each spec. A meta.view object from a person passes around
+* `typedSpec`, and a spec with the field therefore compiles without an error. But
+* the meaning of the field inverted: it was an allowlist, or an empty filter that
+* projected nothing, and the whole context is the value now. The key is the static
+* meta.view object. Therefore the warning appears one time, and not for each
+* snapshot.
+*/
+var warnOnce = createWarnOnce();
+var warnRemovedContextProps = (viewMeta) => {
+	warnOnce(viewMeta, "[play-xstate] meta.view.contextProps has been removed: the whole machine context is always projected under /context. Delete the field — it no longer filters anything.");
 };
 /** Reads the `view` of one meta entry, when the entry holds a whole spec. */
-const viewOfEntry = (stateMeta) => {
-    const maybeView = stateMeta && typeof stateMeta === "object"
-        ? stateMeta.view
-        : undefined;
-    return maybeView &&
-        typeof maybeView === "object" &&
-        "root" in maybeView &&
-        "elements" in maybeView
-        ? maybeView
-        : null;
+var viewOfEntry = (stateMeta) => {
+	const maybeView = stateMeta && typeof stateMeta === "object" ? stateMeta.view : void 0;
+	return maybeView && typeof maybeView === "object" && "root" in maybeView && "elements" in maybeView ? maybeView : null;
 };
-const resolveViewMeta = (meta) => {
-    // Take the LAST entry that holds a view, and not the first: snapshot.getMeta() puts
-    // the keys of the ancestors first, so the last match is the meta.view of the deepest
-    // active state. An ancestor hides it not.
-    //
-    // A walk from the end, and not a findLast or a mapped copy: this runs for each
-    // snapshot. The walk stops at the first match, and `viewOfEntry` runs one time for
-    // each entry that it visits — a `findLast` would run it a second time on the entry
-    // that its own predicate had already resolved, and a `map()` would visit every entry
-    // and allocate one object for each match before the search began.
-    //
-    // `toReversed()`, which copies, and not `reverse()`, which mutates: one spelling for
-    // one operation, beside the `toSorted()` that `unicorn/no-array-sort` asks for.
-    //
-    // The copy costs about 10 ns for the handful of entries that a state path holds, and
-    // `Object.entries` above it costs twenty times that. Measured, after a review called
-    // this line a cost of a hot path: it is not one, at any rate of snapshots that an
-    // actor produces.
-    for (const [key, stateMeta] of Object.entries(meta).toReversed()) {
-        const view = viewOfEntry(stateMeta);
-        if (view) {
-            return { key, view };
-        }
-    }
-    return null;
+/**
+* Resolves the view of one active state node and its active descendants.
+*
+* A node whose view declares `outlets` composes: the tree holds the resolved view of
+* each active child that an outlet shows. Any other node takes the deepest view below
+* it. A parallel node tries its regions in {@link branchOrder}: the region of the routes
+* first, so the view belongs to the region of the URL when that region resolves to a
+* view, and to the first region that resolves to one otherwise.
+*/
+var resolveViewTree = (node, value) => {
+	const view = viewOfEntry(node.meta);
+	if (view && "contextProps" in view) warnRemovedContextProps(view);
+	if (view?.outlets) {
+		const { outlets } = view;
+		const children = [];
+		for (const key of activeChildKeys(value)) {
+			if (!outlets[Object.hasOwn(outlets, key) ? key : "*"]) continue;
+			const child = node.states?.[key];
+			if (!child) continue;
+			const tree = resolveViewTree(child, activeChildValue(value, key));
+			if (tree) children.push({
+				key,
+				tree
+			});
+		}
+		return {
+			id: node.id,
+			view,
+			children
+		};
+	}
+	for (const key of branchOrder(node, value)) {
+		const child = node.states?.[key];
+		if (!child) continue;
+		const tree = resolveViewTree(child, activeChildValue(value, key));
+		if (tree) return tree;
+	}
+	return view ? {
+		id: node.id,
+		view,
+		children: []
+	} : null;
+};
+/**
+* The view of a snapshot that exposes no machine tree to walk, from its flat `getMeta()`
+* record. The keys of the ancestors come first, so the LAST entry that holds a view is
+* the deepest one. The route derivation reads the same record for such a snapshot, so
+* the route and the view agree there too.
+*
+* The record names no state key, so the fallback composes nothing: it gives the deepest
+* view alone, and it drops the `outlets` of that view, which no spec carries.
+*/
+var flatView = (snapshot) => {
+	const meta = flatStateMeta(snapshot);
+	if (!meta) return null;
+	let deepest = null;
+	for (const [id, stateMeta] of Object.entries(meta)) {
+		const found = viewOfEntry(stateMeta);
+		if (found) deepest = {
+			id,
+			view: found
+		};
+	}
+	if (!deepest) return null;
+	if ("contextProps" in deepest.view) warnRemovedContextProps(deepest.view);
+	const { outlets: _outlets, ...view } = deepest.view;
+	return {
+		id: deepest.id,
+		view
+	};
 };
 /**
- * Resolves the view of one active state node and its active descendants.
- *
- * A node whose view declares `outlets` composes: the tree holds the resolved view of
- * each active child. Any other node keeps the rule of a view without outlets: the
- * deepest view below it wins, and a parallel node follows the region of the URL when
- * that region resolves to a view, and its first region that resolves to one otherwise.
- */
-const resolveViewTree = (node, value) => {
-    const view = viewOfEntry(node.meta);
-    if (view && "contextProps" in view) {
-        warnRemovedContextProps(view);
-    }
-    // A view with outlets places its children in the order of the machine. Any other
-    // node tries the routed region first, so its view belongs to the region of the URL.
-    const keys = view?.outlets ? activeChildKeys(value) : branchOrder(node, value);
-    const children = [];
-    for (const key of keys) {
-        const child = node.states?.[key]; // nosemgrep: gitlab.eslint.detect-object-injection
-        if (!child)
-            continue;
-        const resolved = resolveViewTree(child, activeChildValue(value, key));
-        if (resolved)
-            children.push({ key, resolved });
-        // Without outlets, only the first child that resolves counts.
-        if (resolved && !view?.outlets)
-            break;
-    }
-    if (view?.outlets) {
-        return {
-            tree: {
-                id: node.id,
-                view,
-                children: children.map(({ key, resolved }) => ({ key, tree: resolved.tree })),
-            },
-            composes: true,
-        };
-    }
-    const deeper = children[0]?.resolved;
-    if (deeper)
-        return deeper;
-    return view ? { tree: { id: node.id, view, children: [] }, composes: false } : null;
+* Collects each view that a layout can compose, keyed on the id of its state node.
+*
+* The key is the STATE, and not the view object: two states that use one spec constant
+* are two pages of the layout, and they share its store as two distinct objects do.
+*/
+var collectViews = (node, into) => {
+	const view = viewOfEntry(node.meta);
+	if (view) into.set(node.id, view);
+	for (const [key, child] of Object.entries(node.states ?? {})) {
+		if (view?.outlets) {
+			const outletKey = Object.hasOwn(view.outlets, key) ? key : "*";
+			if (!view.outlets[outletKey]) continue;
+		}
+		collectViews(child, into);
+	}
 };
-// Whether any state node of a machine declares `outlets`, for each root node. A
-// machine without outlets skips the walk of the view tree on every snapshot.
-const outletsByMachine = new WeakMap();
-const declaresOutlets = (node) => Boolean(viewOfEntry(node.meta)?.outlets) ||
-    Object.values(node.states ?? {}).some(declaresOutlets);
-const machineDeclaresOutlets = (root) => {
-    let declares = outletsByMachine.get(root);
-    if (declares === undefined) {
-        declares = declaresOutlets(root);
-        outletsByMachine.set(root, declares);
-    }
-    return declares;
+var warnSharedKeysOnce = createWarnOnce();
+/** Warns about the shared keys of each outermost layout at or below `node`. */
+var warnLayoutsBelow = (node) => {
+	const view = viewOfEntry(node.meta);
+	if (!view?.outlets) {
+		for (const child of Object.values(node.states ?? {})) warnLayoutsBelow(child);
+		return;
+	}
+	const views = /* @__PURE__ */ new Map();
+	collectViews(node, views);
+	const owners = /* @__PURE__ */ new Map();
+	for (const [id, composed] of views) {
+		let keys;
+		try {
+			keys = Object.keys(toAtomState(composed.state));
+		} catch {
+			continue;
+		}
+		for (const key of keys) owners.set(key, [...owners.get(key) ?? [], id]);
+	}
+	const shared = [...owners].filter(([, ids]) => ids.length > 1);
+	if (shared.length === 0) return;
+	warnSharedKeysOnce(view, `[play-xstate] The views that the layout "${node.id}" composes share one store, and two or more of them declare the same state key: ` + shared.map(([key, ids]) => `"${key}" (${ids.join(", ")})`).join("; ") + `. They share one value. Give each view its own keys.`);
 };
 /**
- * Derives the view of a machine that declares `outlets` somewhere. The walk of the view
- * tree alone decides that view: a composed view, the plain view that the walk resolved,
- * or `null` when no active state holds a view.
- *
- * The function returns `undefined` for a machine that declares no `outlets`. The caller
- * then derives the view as before, which keeps every such machine on the exact rule that
- * it had, the flat fallback of a parallel machine included.
- */
-const deriveTreeView = (snapshot) => {
-    const root = snapshot?.machine?.root;
-    if (!root || !machineDeclaresOutlets(root))
-        return undefined;
-    const resolved = resolveViewTree(root, snapshot.value);
-    if (!resolved)
-        return null;
-    // A tree that does not compose is a view without outlets.
-    if (!resolved.composes)
-        return { viewKey: resolved.tree.id, view: resolved.tree.view };
-    const composed = composeViews(resolved.tree);
-    return {
-        viewKey: resolved.tree.id,
-        view: {
-            root: composed.root,
-            elements: composed.elements,
-            ...(composed.state !== undefined && { state: composed.state }),
-            viewParts: composed.viewParts,
-        },
-    };
+* Warns about each authored state key that two views of one layout declare.
+*
+* The views that a layout composes share the store of the layout, because the `viewKey`
+* is the id of the layout. Two pages that each declare `query` therefore share one value,
+* and the second page finds the input of the first. The check runs one time for each
+* machine, and it reads the state nodes only, so it also finds two pages that are never
+* on the screen together.
+*/
+var checkedMachines = /* @__PURE__ */ new WeakSet();
+var warnSharedStateKeys = (root) => {
+	if (checkedMachines.has(root)) return;
+	checkedMachines.add(root);
+	warnLayoutsBelow(root);
+};
+/** The token that closes the children of one view in the walk of a tree. */
+var CLOSE = Symbol("close");
+var stepTo = (step, token) => {
+	let next = step.next.get(token);
+	if (!next) {
+		next = { next: /* @__PURE__ */ new Map() };
+		step.next.set(token, next);
+	}
+	return next;
+};
+/**
+* Walks the trie along a {@link ViewTree}: each view object, the id of its state, the key
+* of each child, and a close token after the children. The tokens are the objects and the
+* strings themselves, so two different trees never reach one step, and a walk builds no
+* key and no array.
+*/
+var walkTrie = (step, tree) => {
+	let at = stepTo(stepTo(step, tree.view), tree.id);
+	for (const child of tree.children) at = walkTrie(stepTo(at, child.key), child.tree);
+	return stepTo(at, CLOSE);
+};
+var compositions = /* @__PURE__ */ new WeakMap();
+var composeOnce = (root, tree) => {
+	let start = compositions.get(root);
+	if (!start) {
+		start = { next: /* @__PURE__ */ new Map() };
+		compositions.set(root, start);
+	}
+	const step = walkTrie(start, tree);
+	step.composed ??= composeViews(tree);
+	return step.composed;
 };
 /**
- * Derives the current view of the actor from the state metadata.
- *
- * The function always returns a **fresh** `PlaySpec` object. The `Object.is`
- * equality test of the atom therefore stops no real change of the view.
- * The `currentView` atom of `withView` decides if the actor emits that fresh object:
- * it compares the object with the last spec of an emission, it reuses the reference
- * of the composed `state` field when the value of the projection did not change, and
- * it returns the previous spec when the view on the screen is the same — which the
- * `Object.is` compare of the atom reads as no change, so it notifies no subscriber. A
- * provider below the actor therefore mounts the UI again not on every event.
- *
- * ### The context projection
- *
- * The function projects the context of the machine into the `state` field of the
- * derived spec, under the read-only `/context` subtree:
- * `state: { ...meta.view.state, context: slice }`. The spec of the emission is
- * therefore **consistent with itself**, and its `state` field describes the contents
- * of the store correctly. `repeat.statePath: "/context/tasks"`,
- * `visible: { $state: "/context/…" }`, and a `{ $state: "/context/…" }` prop all
- * resolve through the ordinary state grammar. A tool such as `validateSpec` also
- * passes on a derived view, with no special case. Validate the derived view, and not
- * the raw `meta.view`.
- *
- * The store always holds the complete context. The function changes the authored
- * `meta.view` object never.
- *
- * ### The viewKey
- *
- * The derived spec carries a `viewKey` field. Its value is the key of the meta
- * record, which is the id of the state node, of the entry that this derivation
- * selected. A provider uses it as the key of its store lifecycle: a new key seeds
- * the store again, and the same key refreshes `/context` in place. The value comes
- * from the selected entry, and not from "the id of the active state", because for a
- * parallel machine the branch of the walk and the flat `getMeta()` fallback can
- * select a view of a different region than the leaf of the branch.
- *
- * @param snapshot - The current snapshot of the XState machine.
- * @returns The derived `PlaySpec`, or `null` when the current state has no view metadata.
- */
-export const deriveCurrentView = (snapshot) => {
-    const slice = snapshot?.context !== null && typeof snapshot?.context === "object"
-        ? snapshot.context
-        : undefined;
-    // A parent view with `outlets` shares the screen with the views of its substates.
-    const treeView = deriveTreeView(snapshot);
-    if (treeView !== undefined) {
-        if (treeView === null)
-            return null;
-        const authoredState = treeView.view.state !== undefined ? toAtomState(treeView.view.state) : undefined;
-        const state = composePlayState(authoredState, slice);
-        return {
-            ...treeView.view,
-            viewKey: treeView.viewKey,
-            ...(state !== undefined && { state }),
-        };
-    }
-    // Follow the SAME single active branch as the route derivation. Therefore the view
-    // on the screen of a parallel machine belongs to the region of the URL, when that
-    // region declares a view.
-    const meta = activeStateMeta(snapshot);
-    if (!meta) {
-        return null;
-    }
-    // A parallel machine can hold its routes and its views in DIFFERENT regions: one
-    // region owns the navigation, and another region owns the shell. When the branch of
-    // the walk declares no view, scan the flat record of every active region, where the
-    // deepest entry wins, before the conclusion that no view is present.
-    let resolved = resolveViewMeta(meta);
-    if (!resolved) {
-        const flatMeta = snapshot.getMeta();
-        if (flatMeta && typeof flatMeta === "object") {
-            resolved = resolveViewMeta(flatMeta);
-        }
-    }
-    if (!resolved) {
-        return null;
-    }
-    const { key: viewKey, view: viewMeta } = resolved;
-    if ("contextProps" in viewMeta) {
-        warnRemovedContextProps(viewMeta);
-    }
-    // Project the complete context under /context. composePlayState skips the
-    // projection, the authored state wins, and the code writes a warning in development,
-    // when spec.state declares a top-level "context" key already.
-    const authoredState = viewMeta.state !== undefined ? toAtomState(viewMeta.state) : undefined;
-    const state = composePlayState(authoredState, slice);
-    return {
-        ...viewMeta,
-        viewKey,
-        ...(state !== undefined && { state }),
-    };
+* Derives the current view of the actor from the state metadata.
+*
+* The function always returns a **fresh** `PlaySpec` object. The `Object.is`
+* equality test of the atom therefore stops no real change of the view.
+* The `currentView` atom of `withView` decides if the actor emits that fresh object:
+* it compares the object with the last spec of an emission, it reuses the reference
+* of the composed `state` field when the value of the projection did not change, and
+* it returns the previous spec when the view on the screen is the same — which the
+* `Object.is` compare of the atom reads as no change, so it notifies no subscriber. A
+* provider below the actor therefore mounts the UI again not on every event.
+*
+* ### The context projection
+*
+* The function projects the context of the machine into the `state` field of the
+* derived spec, under the read-only `/context` subtree:
+* `state: { ...meta.view.state, context: slice }`. The spec of the emission is
+* therefore **consistent with itself**, and its `state` field describes the contents
+* of the store correctly. `repeat.statePath: "/context/tasks"`,
+* `visible: { $state: "/context/…" }`, and a `{ $state: "/context/…" }` prop all
+* resolve through the ordinary state grammar. A tool such as `validateSpec` also
+* passes on a derived view, with no special case. Validate the derived view, and not
+* the raw `meta.view`.
+*
+* The store always holds the complete context. The function changes the authored
+* `meta.view` object never.
+*
+* ### The viewKey
+*
+* The derived spec carries a `viewKey` field. Its value is the id of the state node
+* whose view the walk selected: the outermost state that composes with `outlets`, or
+* the state of the deepest view. A provider uses it as the key of its store lifecycle:
+* a new key seeds the store again, and the same key refreshes `/context` in place. The
+* value comes from the selected view, and not from "the id of the active state",
+* because for a parallel machine the walk can select a view of a different region than
+* the leaf of the routed branch.
+*
+* ### One rule
+*
+* One walk of the active state tree derives every view, and a machine with no
+* `outlets` is its simple case: the deepest view wins. Declare `outlets` on a state to
+* show its view beside the views of its children. A snapshot that exposes no machine
+* tree falls back to its flat `getMeta()` record, as the route derivation does.
+*
+* @param snapshot - The current snapshot of the XState machine.
+* @returns The derived `PlaySpec`, or `null` when the current state has no view metadata.
+*/
+var deriveCurrentView = (snapshot) => {
+	const root = snapshot?.machine?.root;
+	let id;
+	let view;
+	if (root) {
+		warnSharedStateKeys(root);
+		warnStateIds(root);
+		const tree = resolveViewTree(root, snapshot.value);
+		if (!tree) return null;
+		id = tree.id;
+		view = tree.view.outlets ? composeOnce(root, tree) : tree.view;
+	} else {
+		const flat = flatView(snapshot);
+		if (!flat) return null;
+		({id, view} = flat);
+	}
+	const slice = snapshot.context !== null && typeof snapshot.context === "object" ? snapshot.context : void 0;
+	const authoredState = view.state !== void 0 ? toAtomState(view.state) : void 0;
+	const state = composePlayState(authoredState, slice);
+	return {
+		...view,
+		viewKey: id,
+		...state !== void 0 && { state }
+	};
 };
+//#endregion
+export { deriveCurrentView };
+
 //# sourceMappingURL=derive-current-view.js.map

package/dist/view/derive-current-view.js.map

@@ -1 +1 @@
-{"version":3,"file":"derive-current-view.js","sourceRoot":"","sources":["../../src/view/derive-current-view.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"derive-current-view.js","names":[],"sources":["../../src/view/derive-current-view.ts"],"sourcesContent":["/**\n * The view derivation — the meta.view half of the player pipeline.\n *\n * This file is beside src/routing/, so that player-actor.ts holds the actor\n * itself only: the atoms, the hooks, and the lifecycle. The walk shares\n * `branchOrder` with the route derivation, so a parallel node tries the region of its\n * URL first. When that region resolves to no view, the view comes from the next region\n * that resolves to one.\n */\nimport type { AnyMachineSnapshot } from \"xstate\";\nimport {\n\tcomposePlayState,\n\tcomposeViews,\n\ttoAtomState,\n\ttype ComposedView,\n\ttype PlaySpec,\n\ttype ViewMeta,\n\ttype ViewTree,\n\ttype ViewTreeChild,\n} from \"@xmachines/play-view\";\nimport { createWarnOnce } from \"@xmachines/core/utils\";\n\nimport {\n\tactiveChildKeys,\n\tactiveChildValue,\n\tbranchOrder,\n\tflatStateMeta,\n\twarnStateIds,\n\ttype BranchNode,\n} from \"../state-meta.js\";\n\n/**\n * The migration warning of the `contextProps` field, which 1.x removed. The code\n * writes it one time for each spec. A meta.view object from a person passes around\n * `typedSpec`, and a spec with the field therefore compiles without an error. But\n * the meaning of the field inverted: it was an allowlist, or an empty filter that\n * projected nothing, and the whole context is the value now. The key is the static\n * meta.view object. Therefore the warning appears one time, and not for each\n * snapshot.\n */\nconst warnOnce = createWarnOnce();\nconst warnRemovedContextProps = (viewMeta: object): void => {\n\twarnOnce(\n\t\tviewMeta,\n\t\t\"[play-xstate] meta.view.contextProps has been removed: the whole machine context \" +\n\t\t\t\"is always projected under /context. Delete the field — it no longer filters anything.\",\n\t);\n};\n\n/** Reads the `view` of one meta entry, when the entry holds a whole spec. */\nconst viewOfEntry = (stateMeta: unknown): ViewMeta | null => {\n\tconst maybeView =\n\t\tstateMeta && typeof stateMeta === \"object\"\n\t\t\t? (stateMeta as { view?: unknown }).view\n\t\t\t: undefined;\n\n\treturn maybeView &&\n\t\ttypeof maybeView === \"object\" &&\n\t\t\"root\" in (maybeView as object) &&\n\t\t\"elements\" in (maybeView as object)\n\t\t? (maybeView as ViewMeta)\n\t\t: null;\n};\n\n/**\n * Resolves the view of one active state node and its active descendants.\n *\n * A node whose view declares `outlets` composes: the tree holds the resolved view of\n * each active child that an outlet shows. Any other node takes the deepest view below\n * it. A parallel node tries its regions in {@link branchOrder}: the region of the routes\n * first, so the view belongs to the region of the URL when that region resolves to a\n * view, and to the first region that resolves to one otherwise.\n */\nconst resolveViewTree = (node: BranchNode, value: unknown): ViewTree | null => {\n\tconst view = viewOfEntry(node.meta);\n\tif (view && \"contextProps\" in view) {\n\t\twarnRemovedContextProps(view);\n\t}\n\n\tif (view?.outlets) {\n\t\tconst { outlets } = view;\n\t\tconst children: ViewTreeChild[] = [];\n\t\t// A view with outlets places its children in the order of the machine.\n\t\tfor (const key of activeChildKeys(value)) {\n\t\t\t// A child that no outlet shows stays out of the tree, so a change inside it\n\t\t\t// changes the composed view not.\n\t\t\tconst outletKey = Object.hasOwn(outlets, key) ? key : \"*\";\n\t\t\tif (!outlets[outletKey]) continue; // nosemgrep: gitlab.eslint.detect-object-injection\n\t\t\tconst child = node.states?.[key]; // nosemgrep: gitlab.eslint.detect-object-injection\n\t\t\tif (!child) continue;\n\t\t\tconst tree = resolveViewTree(child, activeChildValue(value, key));\n\t\t\tif (tree) children.push({ key, tree });\n\t\t}\n\t\treturn { id: node.id, view, children };\n\t}\n\n\tfor (const key of branchOrder(node, value)) {\n\t\tconst child = node.states?.[key]; // nosemgrep: gitlab.eslint.detect-object-injection\n\t\tif (!child) continue;\n\t\tconst tree = resolveViewTree(child, activeChildValue(value, key));\n\t\tif (tree) return tree;\n\t}\n\treturn view ? { id: node.id, view, children: [] } : null;\n};\n\n/**\n * The view of a snapshot that exposes no machine tree to walk, from its flat `getMeta()`\n * record. The keys of the ancestors come first, so the LAST entry that holds a view is\n * the deepest one. The route derivation reads the same record for such a snapshot, so\n * the route and the view agree there too.\n *\n * The record names no state key, so the fallback composes nothing: it gives the deepest\n * view alone, and it drops the `outlets` of that view, which no spec carries.\n */\nconst flatView = (snapshot: AnyMachineSnapshot): { id: string; view: ViewMeta } | null => {\n\tconst meta = flatStateMeta(snapshot);\n\tif (!meta) return null;\n\tlet deepest: { id: string; view: ViewMeta } | null = null;\n\tfor (const [id, stateMeta] of Object.entries(meta)) {\n\t\tconst found = viewOfEntry(stateMeta);\n\t\tif (found) deepest = { id, view: found };\n\t}\n\tif (!deepest) return null;\n\tif (\"contextProps\" in deepest.view) warnRemovedContextProps(deepest.view);\n\tconst { outlets: _outlets, ...view } = deepest.view;\n\treturn { id: deepest.id, view };\n};\n\n/**\n * Collects each view that a layout can compose, keyed on the id of its state node.\n *\n * The key is the STATE, and not the view object: two states that use one spec constant\n * are two pages of the layout, and they share its store as two distinct objects do.\n */\nconst collectViews = (node: BranchNode, into: Map<string, ViewMeta>): void => {\n\tconst view = viewOfEntry(node.meta);\n\tif (view) into.set(node.id, view);\n\tfor (const [key, child] of Object.entries(node.states ?? {})) {\n\t\tif (view?.outlets) {\n\t\t\tconst outletKey = Object.hasOwn(view.outlets, key) ? key : \"*\";\n\t\t\tif (!view.outlets[outletKey]) continue; // nosemgrep: gitlab.eslint.detect-object-injection\n\t\t}\n\t\tcollectViews(child, into);\n\t}\n};\n\n// The warning of the shared keys keeps its own memory of the views. With the memory of\n// `warnRemovedContextProps`, a layout that carries both faults showed one warning alone.\nconst warnSharedKeysOnce = createWarnOnce();\n\n/** Warns about the shared keys of each outermost layout at or below `node`. */\nconst warnLayoutsBelow = (node: BranchNode): void => {\n\tconst view = viewOfEntry(node.meta);\n\tif (!view?.outlets) {\n\t\tfor (const child of Object.values(node.states ?? {})) warnLayoutsBelow(child);\n\t\treturn;\n\t}\n\tconst views = new Map<string, ViewMeta>();\n\tcollectViews(node, views);\n\tconst owners = new Map<string, string[]>();\n\tfor (const [id, composed] of views) {\n\t\t// The check reads views that are not on the screen, and a warning must not break\n\t\t// the derivation. A `state` accessor can throw — the renderers contain that as a\n\t\t// failure of the view, when the view shows — so such a view is left out here.\n\t\tlet keys: string[];\n\t\ttry {\n\t\t\tkeys = Object.keys(toAtomState(composed.state));\n\t\t} catch {\n\t\t\tcontinue;\n\t\t}\n\t\tfor (const key of keys) owners.set(key, [...(owners.get(key) ?? []), id]);\n\t}\n\tconst shared = [...owners].filter(([, ids]) => ids.length > 1);\n\tif (shared.length === 0) return;\n\twarnSharedKeysOnce(\n\t\tview,\n\t\t`[play-xstate] The views that the layout \"${node.id}\" composes share one store, and ` +\n\t\t\t`two or more of them declare the same state key: ` +\n\t\t\tshared.map(([key, ids]) => `\"${key}\" (${ids.join(\", \")})`).join(\"; \") +\n\t\t\t`. They share one value. Give each view its own keys.`,\n\t);\n};\n\n/**\n * Warns about each authored state key that two views of one layout declare.\n *\n * The views that a layout composes share the store of the layout, because the `viewKey`\n * is the id of the layout. Two pages that each declare `query` therefore share one value,\n * and the second page finds the input of the first. The check runs one time for each\n * machine, and it reads the state nodes only, so it also finds two pages that are never\n * on the screen together.\n */\nconst checkedMachines = new WeakSet<BranchNode>();\nconst warnSharedStateKeys = (root: BranchNode): void => {\n\tif (checkedMachines.has(root)) return;\n\tcheckedMachines.add(root);\n\twarnLayoutsBelow(root);\n};\n\n/** One step of the trie of kept compositions. */\ninterface CompositionStep {\n\treadonly next: Map<unknown, CompositionStep>;\n\tcomposed?: ComposedView;\n}\n\n/** The token that closes the children of one view in the walk of a tree. */\nconst CLOSE = Symbol(\"close\");\n\nconst stepTo = (step: CompositionStep, token: unknown): CompositionStep => {\n\tlet next = step.next.get(token);\n\tif (!next) {\n\t\tnext = { next: new Map() };\n\t\tstep.next.set(token, next);\n\t}\n\treturn next;\n};\n\n/**\n * Walks the trie along a {@link ViewTree}: each view object, the id of its state, the key\n * of each child, and a close token after the children. The tokens are the objects and the\n * strings themselves, so two different trees never reach one step, and a walk builds no\n * key and no array.\n */\nconst walkTrie = (step: CompositionStep, tree: ViewTree): CompositionStep => {\n\tlet at = stepTo(stepTo(step, tree.view), tree.id);\n\tfor (const child of tree.children) at = walkTrie(stepTo(at, child.key), child.tree);\n\treturn stepTo(at, CLOSE);\n};\n\n// One composition for each distinct tree of views of each machine. A machine has a finite\n// set of views and of such trees, and the cache goes with the machine.\n//\n// The cache is what keeps `elements` and `viewParts` the SAME objects from one snapshot\n// to the next: the emit gate of the actor compares them by reference, and a new object on\n// every context assign would render the whole screen again.\nconst compositions = new WeakMap<BranchNode, CompositionStep>();\n\nconst composeOnce = (root: BranchNode, tree: ViewTree): ComposedView => {\n\tlet start = compositions.get(root);\n\tif (!start) {\n\t\tstart = { next: new Map() };\n\t\tcompositions.set(root, start);\n\t}\n\tconst step = walkTrie(start, tree);\n\tstep.composed ??= composeViews(tree);\n\treturn step.composed;\n};\n\n/**\n * Derives the current view of the actor from the state metadata.\n *\n * The function always returns a **fresh** `PlaySpec` object. The `Object.is`\n * equality test of the atom therefore stops no real change of the view.\n * The `currentView` atom of `withView` decides if the actor emits that fresh object:\n * it compares the object with the last spec of an emission, it reuses the reference\n * of the composed `state` field when the value of the projection did not change, and\n * it returns the previous spec when the view on the screen is the same — which the\n * `Object.is` compare of the atom reads as no change, so it notifies no subscriber. A\n * provider below the actor therefore mounts the UI again not on every event.\n *\n * ### The context projection\n *\n * The function projects the context of the machine into the `state` field of the\n * derived spec, under the read-only `/context` subtree:\n * `state: { ...meta.view.state, context: slice }`. The spec of the emission is\n * therefore **consistent with itself**, and its `state` field describes the contents\n * of the store correctly. `repeat.statePath: \"/context/tasks\"`,\n * `visible: { $state: \"/context/…\" }`, and a `{ $state: \"/context/…\" }` prop all\n * resolve through the ordinary state grammar. A tool such as `validateSpec` also\n * passes on a derived view, with no special case. Validate the derived view, and not\n * the raw `meta.view`.\n *\n * The store always holds the complete context. The function changes the authored\n * `meta.view` object never.\n *\n * ### The viewKey\n *\n * The derived spec carries a `viewKey` field. Its value is the id of the state node\n * whose view the walk selected: the outermost state that composes with `outlets`, or\n * the state of the deepest view. A provider uses it as the key of its store lifecycle:\n * a new key seeds the store again, and the same key refreshes `/context` in place. The\n * value comes from the selected view, and not from \"the id of the active state\",\n * because for a parallel machine the walk can select a view of a different region than\n * the leaf of the routed branch.\n *\n * ### One rule\n *\n * One walk of the active state tree derives every view, and a machine with no\n * `outlets` is its simple case: the deepest view wins. Declare `outlets` on a state to\n * show its view beside the views of its children. A snapshot that exposes no machine\n * tree falls back to its flat `getMeta()` record, as the route derivation does.\n *\n * @param snapshot - The current snapshot of the XState machine.\n * @returns The derived `PlaySpec`, or `null` when the current state has no view metadata.\n */\nexport const deriveCurrentView = (snapshot: AnyMachineSnapshot): PlaySpec | null => {\n\tconst root = snapshot?.machine?.root as BranchNode | undefined;\n\tlet id: string;\n\tlet view: Omit<PlaySpec, \"viewKey\">;\n\tif (root) {\n\t\t// Two checks of the machine, each one time for each machine: the state keys that the\n\t\t// views of a layout share, and the ids of the states.\n\t\twarnSharedStateKeys(root);\n\t\twarnStateIds(root);\n\t\tconst tree = resolveViewTree(root, snapshot.value);\n\t\tif (!tree) return null;\n\t\tid = tree.id;\n\t\t// A tree without outlets is the view of one state, as the author wrote it.\n\t\tview = tree.view.outlets ? composeOnce(root, tree) : tree.view;\n\t} else {\n\t\tconst flat = flatView(snapshot);\n\t\tif (!flat) return null;\n\t\t({ id, view } = flat);\n\t}\n\n\t// Project the complete context under /context. composePlayState skips the\n\t// projection, the authored state wins, and the code writes a warning in development,\n\t// when spec.state declares a top-level \"context\" key already.\n\tconst slice =\n\t\tsnapshot.context !== null && typeof snapshot.context === \"object\"\n\t\t\t? (snapshot.context as Record<string, unknown>)\n\t\t\t: undefined;\n\tconst authoredState = view.state !== undefined ? toAtomState(view.state) : undefined;\n\tconst state = composePlayState(authoredState, slice);\n\n\treturn {\n\t\t...view,\n\t\tviewKey: id,\n\t\t...(state !== undefined && { state }),\n\t};\n};\n"],"mappings":"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"}