@fluidframework/tree 2.118.1 → 3.0.1

package/dist/simple-tree/api/treeChangeEvents.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"treeChangeEvents.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/api/treeChangeEvents.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,WAAW,gBAAgB;IAChC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2CG;IACH,WAAW,CAAC,QAAQ,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAEtC;;;;;;;;;;;;;;;;;OAiBG;IACH,WAAW,IAAI,IAAI,CAAC;CACpB"}
+{"version":3,"file":"treeChangeEvents.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/api/treeChangeEvents.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,WAAW,gBAAgB;IAChC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+CG;IACH,WAAW,CAAC,QAAQ,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAEtC;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,WAAW,CAAC,QAAQ,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;CACtC"}

package/dist/simple-tree/api/treeChangeEvents.js.map

@@ -1 +1 @@
-{"version":3,"file":"treeChangeEvents.js","sourceRoot":"","sources":["../../../src/simple-tree/api/treeChangeEvents.ts"],"names":[],"mappings":";AAAA;;;GAGG","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/**\n * A collection of events that can be emitted by a {@link TreeNode}.\n *\n * @remarks\n * Access these events via the {@link (Tree:variable)}'s {@link TreeNodeApi.on} method.\n *\n * @privateRemarks\n * TODO: add a way to subscribe to a specific field (for nodeChanged and treeChanged).\n * Probably have object node and map node specific APIs for this.\n *\n * TODO: ensure that subscription API for fields aligns with API for subscribing to the root.\n *\n * TODO: add more wider area (avoid needing tons of nodeChanged registration) events for use-cases other than treeChanged.\n * Some ideas:\n *\n * - treeChanged, but with some subtrees/fields/paths excluded\n * - helper to batch several nodeChanged calls to a treeChanged scope\n * - parent change (ex: registration on the parent field for a specific index: maybe allow it for a range. Ex: node event takes optional field and optional index range?)\n * - new content inserted into subtree. Either provide event for this and/or enough info to treeChanged to find and search the new sub-trees.\n * Add separate (non event related) API to efficiently scan tree for given set of types (using low level cursor and schema based filtering)\n * to allow efficiently searching for new content (and initial content) of a given type.\n *\n * @sealed @public\n */\nexport interface TreeChangeEvents {\n\t/**\n\t * Emitted by a node if any changes affected the node.\n\t *\n\t * This event is emitted after all the changes in a batch have been applied to the whole tree.\n\t * This means that a handler for this event will be able to read the updated state of the tree.\n\t *\n\t * - Object nodes define a change as being when the value of one of its properties changes (i.e., the property's value is set, including when set to `undefined`).\n\t *\n\t * - Array nodes define a change as when an element is added, removed, moved, or replaced.\n\t *\n\t * - Map nodes define a change as when an entry is added, updated, or removed.\n\t *\n\t * @param unstable - Future versions of this API (such as the one in beta on TreeBeta) may use this argument to provide additional data to the event.\n\t * users of this event should ensure that they do not provide a listener callback which has an optional parameter in this position, since unexpected data might get provided to it.\n\t * This parameter exists to capture this fact in the type system.\n\t * Using an inline lambda expression as the listener callback is a good pattern to avoid cases like this were arguments are added from breaking due to optional arguments.\n\t *\n\t * @remarks\n\t * This event is not emitted when:\n\t *\n\t * - Properties of a child node change. Notably, updates to an array node or a map node (like adding or removing\n\t * elements/entries) will emit this event on the array/map node itself, but not on the node that contains the\n\t * array/map node as one of its properties.\n\t *\n\t * - The node is moved to a different location in the tree or removed from the tree.\n\t * In this case the event is emitted on the _parent_ node, not the node itself.\n\t *\n\t * For remote edits, this event is not guaranteed to occur in the same order or quantity that it did in\n\t * the client that made the original edit.\n\t *\n\t * When the event is emitted, the tree is guaranteed to be in-schema.\n\t *\n\t * @privateRemarks\n\t * This event occurs whenever the apparent contents of the node instance change, regardless of what caused the change.\n\t * For example, it will fire when the local client reassigns a child, when part of a remote edit is applied to the\n\t * node, or when the node has to be updated due to resolution of a merge conflict\n\t * (for example a previously applied local change might be undone, then reapplied differently or not at all).\n\t *\n\t * Event ordering: when multiple nodes are directly changed in a single batch,\n\t * events fire in the order nodes were first edited. At each node, `nodeChanged` fires before `treeChanged`.\n\t * When only a leaf node changes, this naturally produces bottom-up ordering\n\t * (leaf events first, then ancestor `treeChanged` propagating up).\n\t * See `treeChangeEventOrdering.spec.ts` for comprehensive ordering tests.\n\t */\n\tnodeChanged(unstable?: unknown): void;\n\n\t/**\n\t * Emitted by a node if something changed anywhere in the subtree rooted at it.\n\t *\n\t * This event is emitted after all the changes in a batch have been applied to the whole tree.\n\t * This means that a handler for this event will be able to read the updated state of the tree.\n\t *\n\t * @remarks\n\t * This event is not emitted when the node itself is moved to a different location in the tree or removed from the tree.\n\t * In that case it is emitted on the _parent_ node, not the node itself.\n\t *\n\t * The node itself is part of the subtree, so this event will be emitted even if the only changes are to the properties\n\t * of the node itself.\n\t *\n\t * For remote edits, this event is not guaranteed to occur in the same order or quantity that it did in\n\t * the client that made the original edit.\n\t *\n\t * When it is emitted, the tree is guaranteed to be in-schema.\n\t */\n\ttreeChanged(): void;\n}\n"]}
+{"version":3,"file":"treeChangeEvents.js","sourceRoot":"","sources":["../../../src/simple-tree/api/treeChangeEvents.ts"],"names":[],"mappings":";AAAA;;;GAGG","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/**\n * A collection of events that can be emitted by a {@link TreeNode}.\n *\n * @remarks\n * Access these events via the {@link (Tree:variable)}'s {@link TreeNodeApi.on} method.\n *\n * @privateRemarks\n * TODO: add a way to subscribe to a specific field (for nodeChanged and treeChanged).\n * Probably have object node and map node specific APIs for this.\n *\n * TODO: ensure that subscription API for fields aligns with API for subscribing to the root.\n *\n * TODO: add more wider area (avoid needing tons of nodeChanged registration) events for use-cases other than treeChanged.\n * Some ideas:\n *\n * - treeChanged, but with some subtrees/fields/paths excluded\n * - helper to batch several nodeChanged calls to a treeChanged scope\n * - parent change (ex: registration on the parent field for a specific index: maybe allow it for a range. Ex: node event takes optional field and optional index range?)\n * - new content inserted into subtree. Either provide event for this and/or enough info to treeChanged to find and search the new sub-trees.\n * Add separate (non event related) API to efficiently scan tree for given set of types (using low level cursor and schema based filtering)\n * to allow efficiently searching for new content (and initial content) of a given type.\n *\n * @sealed @public\n */\nexport interface TreeChangeEvents {\n\t/**\n\t * Emitted by a node if any changes affected the node.\n\t *\n\t * This event is emitted after all the changes in a batch have been applied to the whole tree.\n\t * This means that a handler for this event will be able to read the updated state of the tree.\n\t *\n\t * - Object nodes define a change as being when the value of one of its properties changes (i.e., the property's value is set, including when set to `undefined`).\n\t *\n\t * - Array nodes define a change as when an element is added, removed, moved, or replaced.\n\t *\n\t * - Map nodes define a change as when an entry is added, updated, or removed.\n\t *\n\t * @param unstable - Future versions of this API (such as the one in beta on {@link TreeChangeEventsBeta.nodeChanged})\n\t * may use this argument to provide additional data to the event.\n\t * Users of this event should ensure that they do not provide a listener callback which has an optional parameter\n\t * in this position, since unexpected data might get provided to it.\n\t * This parameter exists to capture this fact in the type system.\n\t *\n\t * Using an inline lambda expression as the listener callback is a good pattern to avoid cases like this where\n\t * arguments are added from breaking due to optional arguments.\n\t *\n\t * @remarks\n\t * This event is not emitted when:\n\t *\n\t * - Properties of a child node change. Notably, updates to an array node or a map node (like adding or removing\n\t * elements/entries) will emit this event on the array/map node itself, but not on the node that contains the\n\t * array/map node as one of its properties.\n\t *\n\t * - The node is moved to a different location in the tree or removed from the tree.\n\t * In this case the event is emitted on the _parent_ node, not the node itself.\n\t *\n\t * For remote edits, this event is not guaranteed to occur in the same order or quantity that it did in\n\t * the client that made the original edit.\n\t *\n\t * When the event is emitted, the tree is guaranteed to be in-schema.\n\t *\n\t * @privateRemarks\n\t * This event occurs whenever the apparent contents of the node instance change, regardless of what caused the change.\n\t * For example, it will fire when the local client reassigns a child, when part of a remote edit is applied to the\n\t * node, or when the node has to be updated due to resolution of a merge conflict\n\t * (for example a previously applied local change might be undone, then reapplied differently or not at all).\n\t *\n\t * Event ordering: when multiple nodes are directly changed in a single batch,\n\t * events fire in the order nodes were first edited. At each node, `nodeChanged` fires before `treeChanged`.\n\t * When only a leaf node changes, this naturally produces bottom-up ordering\n\t * (leaf events first, then ancestor `treeChanged` propagating up).\n\t * See `treeChangeEventOrdering.spec.ts` for comprehensive ordering tests.\n\t */\n\tnodeChanged(unstable?: unknown): void;\n\n\t/**\n\t * Emitted by a node if something changed anywhere in the subtree rooted at it.\n\t *\n\t * This event is emitted after all the changes in a batch have been applied to the whole tree.\n\t * This means that a handler for this event will be able to read the updated state of the tree.\n\t *\n\t * @remarks\n\t * This event is not emitted when the node itself is moved to a different location in the tree or removed from the tree.\n\t * In that case it is emitted on the _parent_ node, not the node itself.\n\t *\n\t * The node itself is part of the subtree, so this event will be emitted even if the only changes are to the properties\n\t * of the node itself.\n\t *\n\t * For remote edits, this event is not guaranteed to occur in the same order or quantity that it did in\n\t * the client that made the original edit.\n\t *\n\t * When it is emitted, the tree is guaranteed to be in-schema.\n\t *\n\t * @param unstable - Future versions of this API may use this argument to provide additional data to the event.\n\t * Users of this event should ensure that they do not provide a listener callback which has an optional parameter\n\t * in this position, since unexpected data might get provided to it.\n\t * This parameter exists to capture this fact in the type system.\n\t *\n\t * Using an inline lambda expression as the listener callback is a good pattern to avoid cases like this where\n\t * arguments are added from breaking due to optional arguments.\n\t */\n\ttreeChanged(unstable?: unknown): void;\n}\n"]}

package/dist/simple-tree/api/treeChangeEventsBeta.d.ts

@@ -0,0 +1,209 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import type { NodeKind, TreeNode, WithType } from "../core/index.js";
+import type { TreeChangeEvents } from "./treeChangeEvents.js";
+/**
+ * A `"retain"` op in an {@link ArrayNodeDeltaOp} sequence.
+ * Represents elements that were neither inserted into nor removed from the array.
+ * @sealed @beta
+ */
+export interface ArrayNodeRetainOp {
+    readonly type: "retain";
+    readonly count: number;
+}
+/**
+ * A `"retain"` op in an {@link ArrayNodeTreeChangedDeltaOp} sequence, used in
+ * {@link NodeChangedDataTreeDelta} payloads delivered to
+ * {@link TreeChangeEventsBeta.treeChanged} on array nodes.
+ *
+ * Extends {@link ArrayNodeRetainOp} with a {@link ArrayNodeTreeChangedRetainOp.subtreeChanged}
+ * flag that indicates whether any descendant of the retained element changed.
+ * @sealed @beta
+ */
+export interface ArrayNodeTreeChangedRetainOp extends ArrayNodeRetainOp {
+    /**
+     * Whether any descendant of this retained element changed.
+     * `true` if the element's subtree changed; `false` if nothing changed within it.
+     * @remarks
+     * Subscribe to `nodeChanged` or `treeChanged` on the element node itself for details.
+     */
+    readonly subtreeChanged: boolean;
+}
+/**
+ * A single operation in an array-node delta delivered by {@link TreeChangeEventsBeta.treeChanged}.
+ * Extends {@link ArrayNodeDeltaOp}: retain ops carry a {@link ArrayNodeTreeChangedRetainOp.subtreeChanged}
+ * flag indicating whether any descendant of the retained element changed.
+ * @beta
+ */
+export type ArrayNodeTreeChangedDeltaOp = ArrayNodeTreeChangedRetainOp | ArrayNodeInsertOp | ArrayNodeRemoveOp;
+/**
+ * An `"insert"` op in an {@link ArrayNodeDeltaOp} sequence.
+ * Represents elements added to the array.
+ * Read the new element values from the current tree at the positions described by this op.
+ * @sealed @beta
+ */
+export interface ArrayNodeInsertOp {
+    readonly type: "insert";
+    readonly count: number;
+}
+/**
+ * A `"remove"` op in an {@link ArrayNodeDeltaOp} sequence.
+ * Represents elements removed from the array.
+ * @sealed @beta
+ */
+export interface ArrayNodeRemoveOp {
+    readonly type: "remove";
+    readonly count: number;
+}
+/**
+ * A single operation in an array node change delta. Used to efficiently sync an external
+ * representation of an array (e.g. a text editor or virtual list) with tree changes without
+ * needing to snapshot the old state or diff the entire array. Each op describes a contiguous run
+ * of positions in the array before the change. For inserts, read the new element values from the
+ * current tree at those positions.
+ *
+ * @remarks
+ * There is no dedicated `"move"` op. Moves are represented as `"remove"` + `"insert"`.
+ * When an element is moved within the same array it appears
+ * as a `"remove"` at the source position followed by an `"insert"` at the destination position.
+ * When an element is moved across two different arrays, the source array's delta contains a
+ * `"remove"` and the destination array's delta contains an `"insert"` — they cannot be
+ * correlated without additional bookkeeping on the caller's side.
+ *
+ * The operations cover the complete array: trailing elements that were not changed are included
+ * in a final `"retain"` op. Applying every operation therefore consumes the entire pre-edit array
+ * and produces the entire post-edit array.
+ *
+ * @sealed @beta
+ */
+export type ArrayNodeDeltaOp = ArrayNodeRetainOp | ArrayNodeInsertOp | ArrayNodeRemoveOp;
+/**
+ * Data included for {@link TreeChangeEventsBeta.nodeChanged}.
+ * @sealed @beta
+ */
+export interface NodeChangedData<TNode extends TreeNode = TreeNode> {
+    /**
+     * When the changed node is an object, map, or record node, this lists all the properties which changed.
+     * @remarks
+     * This only includes changes to the node itself (which would trigger {@link TreeChangeEvents.nodeChanged}).
+     *
+     * Not present when the {@link NodeKind} does not support this feature (currently just array nodes).
+     *
+     * When defined, the set should never be empty, since `nodeChanged` will only be triggered when there is a change, and for the supported node types, the only things that can change are properties.
+     */
+    readonly changedProperties?: ReadonlySet<TNode extends WithType<string, NodeKind.Object, infer TInfo> ? string & keyof TInfo : string>;
+    /**
+     * When the changed node is an array node, the sequential operations describing what changed.
+     * @remarks
+     * Not present for non-array nodes. When present, the value may be `undefined` when the
+     * document was updated in a way that required multiple internal change passes in a single
+     * operation (for example, a data change combined with a schema upgrade).
+     */
+    readonly delta?: readonly ArrayNodeDeltaOp[] | undefined;
+}
+/**
+ * Data included for {@link TreeChangeEventsBeta.nodeChanged} when the node is an object, map, or record node.
+ * @sealed @beta
+ */
+export interface NodeChangedDataProperties<TNode extends TreeNode = TreeNode> extends NodeChangedData<TNode> {
+    /**
+     * Lists all the properties which changed on the node.
+     */
+    readonly changedProperties: ReadonlySet<TNode extends WithType<string, NodeKind.Object, infer TInfo> ? string & keyof TInfo : string>;
+}
+/**
+ * Data carried by the {@link TreeChangeEventsBeta.nodeChanged} event for array nodes.
+ * @sealed @beta
+ */
+export interface NodeChangedDataDelta extends NodeChangedData {
+    /**
+     * The sequential operations describing what changed in the array node.
+     * @remarks
+     * The value may be `undefined` when the document was updated in a way that required multiple
+     * internal change passes in a single operation (for example, a data change combined with a
+     * schema upgrade).
+     *
+     * See {@link ArrayNodeDeltaOp} for op semantics.
+     */
+    readonly delta: readonly ArrayNodeDeltaOp[] | undefined;
+}
+/**
+ * Data carried by the {@link TreeChangeEventsBeta.treeChanged} event for array nodes.
+ * @remarks
+ * Extends {@link NodeChangedDataDelta}: the retain ops in the delta additionally carry a
+ * {@link ArrayNodeTreeChangedRetainOp.subtreeChanged} flag indicating whether any descendant
+ * of the retained element changed.
+ * @sealed @beta
+ */
+export interface NodeChangedDataTreeDelta {
+    /**
+     * The sequential operations describing what changed in the array node,
+     * including subtree-change information on retain ops.
+     * @remarks
+     * The value may be `undefined` when the document was updated in a way that required multiple
+     * internal change passes in a single operation (for example, a data change combined with a
+     * schema upgrade).
+     *
+     * See {@link ArrayNodeTreeChangedDeltaOp} for op semantics.
+     */
+    readonly delta: readonly ArrayNodeTreeChangedDeltaOp[] | undefined;
+}
+/**
+ * Extensions to {@link TreeChangeEvents} which are not yet stable.
+ *
+ * @sealed @beta
+ */
+export interface TreeChangeEventsBeta<TNode extends TreeNode = TreeNode> extends Omit<TreeChangeEvents, "nodeChanged" | "treeChanged"> {
+    /**
+     * Emitted by a node after a batch of changes has been applied to the tree, if any of the changes affected the node.
+     *
+     * - Object nodes define a change as being when the value of one of its properties changes (i.e., the property's value is set, including when set to `undefined`).
+     *
+     * - Array nodes define a change as when an element is added, removed, moved or replaced.
+     *
+     * - Map nodes define a change as when an entry is added, updated, or removed.
+     *
+     * @remarks
+     * This event is not emitted when:
+     *
+     * - Properties of a child node change. Notably, updates to an array node or a map node (like adding or removing
+     * elements/entries) will emit this event on the array/map node itself, but not on the node that contains the
+     * array/map node as one of its properties.
+     *
+     * - The node is moved to a different location in the tree or removed from the tree.
+     * In this case the event is emitted on the _parent_ node, not the node itself.
+     *
+     * For remote edits, this event is not guaranteed to occur in the same order or quantity that it did in
+     * the client that made the original edit.
+     *
+     * When the event is emitted, the tree is guaranteed to be in-schema.
+     *
+     * @privateRemarks
+     * This event occurs whenever the apparent contents of the node instance change, regardless of what caused the change.
+     * For example, it will fire when the local client reassigns a child, when part of a remote edit is applied to the
+     * node, or when the node has to be updated due to resolution of a merge conflict
+     * (for example a previously applied local change might be undone, then reapplied differently or not at all).
+     *
+     * TODO: define and document event ordering (ex: bottom up, with nodeChanged before treeChange on each level).
+     *
+     * This defines a property which is a function instead of using the method syntax to avoid function bi-variance issues with the input data to the callback.
+     */
+    nodeChanged: (data: TNode extends WithType<string, NodeKind.Array> ? NodeChangedDataDelta : TNode extends WithType<string, NodeKind.Map | NodeKind.Object | NodeKind.Record> ? NodeChangedDataProperties<TNode> : NodeChangedData<TNode>) => void;
+    /**
+     * Emitted when something in the subtree rooted at this node changes.
+     *
+     * @remarks
+     * For array nodes, the event data carries a {@link NodeChangedDataTreeDelta.delta | delta}
+     * payload describing both shallow and deep changes. Retain operations use
+     * {@link ArrayNodeTreeChangedRetainOp.subtreeChanged} to indicate whether an element's
+     * descendants changed.
+     *
+     * For non-array nodes, this has the same signature as {@link TreeChangeEvents.treeChanged}.
+     * @privateRemarks
+     * This defines a property which is a function instead of using the method syntax to avoid function bi-variance issues with the input data to the callback.
+     */
+    treeChanged: TNode extends WithType<string, NodeKind.Array> ? (data: NodeChangedDataTreeDelta) => void : TreeChangeEvents["treeChanged"];
+}
+//# sourceMappingURL=treeChangeEventsBeta.d.ts.map

package/dist/simple-tree/api/treeChangeEventsBeta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"treeChangeEventsBeta.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/api/treeChangeEventsBeta.ts"],"names":[],"mappings":"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"}

package/dist/simple-tree/api/{treeAlpha.js → treeChangeEventsBeta.js}

@@ -4,4 +4,4 @@
  * Licensed under the MIT License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=treeAlpha.js.map
+//# sourceMappingURL=treeChangeEventsBeta.js.map

package/dist/simple-tree/api/treeChangeEventsBeta.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"treeChangeEventsBeta.js","sourceRoot":"","sources":["../../../src/simple-tree/api/treeChangeEventsBeta.ts"],"names":[],"mappings":";AAAA;;;GAGG","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport type { NodeKind, TreeNode, WithType } from \"../core/index.js\";\n\nimport type { TreeChangeEvents } from \"./treeChangeEvents.js\";\n\n/**\n * A `\"retain\"` op in an {@link ArrayNodeDeltaOp} sequence.\n * Represents elements that were neither inserted into nor removed from the array.\n * @sealed @beta\n */\nexport interface ArrayNodeRetainOp {\n\treadonly type: \"retain\";\n\treadonly count: number;\n}\n\n/**\n * A `\"retain\"` op in an {@link ArrayNodeTreeChangedDeltaOp} sequence, used in\n * {@link NodeChangedDataTreeDelta} payloads delivered to\n * {@link TreeChangeEventsBeta.treeChanged} on array nodes.\n *\n * Extends {@link ArrayNodeRetainOp} with a {@link ArrayNodeTreeChangedRetainOp.subtreeChanged}\n * flag that indicates whether any descendant of the retained element changed.\n * @sealed @beta\n */\nexport interface ArrayNodeTreeChangedRetainOp extends ArrayNodeRetainOp {\n\t/**\n\t * Whether any descendant of this retained element changed.\n\t * `true` if the element's subtree changed; `false` if nothing changed within it.\n\t * @remarks\n\t * Subscribe to `nodeChanged` or `treeChanged` on the element node itself for details.\n\t */\n\treadonly subtreeChanged: boolean;\n}\n\n/**\n * A single operation in an array-node delta delivered by {@link TreeChangeEventsBeta.treeChanged}.\n * Extends {@link ArrayNodeDeltaOp}: retain ops carry a {@link ArrayNodeTreeChangedRetainOp.subtreeChanged}\n * flag indicating whether any descendant of the retained element changed.\n * @beta\n */\nexport type ArrayNodeTreeChangedDeltaOp =\n\t| ArrayNodeTreeChangedRetainOp\n\t| ArrayNodeInsertOp\n\t| ArrayNodeRemoveOp;\n\n/**\n * An `\"insert\"` op in an {@link ArrayNodeDeltaOp} sequence.\n * Represents elements added to the array.\n * Read the new element values from the current tree at the positions described by this op.\n * @sealed @beta\n */\nexport interface ArrayNodeInsertOp {\n\treadonly type: \"insert\";\n\treadonly count: number;\n}\n\n/**\n * A `\"remove\"` op in an {@link ArrayNodeDeltaOp} sequence.\n * Represents elements removed from the array.\n * @sealed @beta\n */\nexport interface ArrayNodeRemoveOp {\n\treadonly type: \"remove\";\n\treadonly count: number;\n}\n\n/**\n * A single operation in an array node change delta. Used to efficiently sync an external\n * representation of an array (e.g. a text editor or virtual list) with tree changes without\n * needing to snapshot the old state or diff the entire array. Each op describes a contiguous run\n * of positions in the array before the change. For inserts, read the new element values from the\n * current tree at those positions.\n *\n * @remarks\n * There is no dedicated `\"move\"` op. Moves are represented as `\"remove\"` + `\"insert\"`.\n * When an element is moved within the same array it appears\n * as a `\"remove\"` at the source position followed by an `\"insert\"` at the destination position.\n * When an element is moved across two different arrays, the source array's delta contains a\n * `\"remove\"` and the destination array's delta contains an `\"insert\"` — they cannot be\n * correlated without additional bookkeeping on the caller's side.\n *\n * The operations cover the complete array: trailing elements that were not changed are included\n * in a final `\"retain\"` op. Applying every operation therefore consumes the entire pre-edit array\n * and produces the entire post-edit array.\n *\n * @sealed @beta\n */\nexport type ArrayNodeDeltaOp = ArrayNodeRetainOp | ArrayNodeInsertOp | ArrayNodeRemoveOp;\n\n/**\n * Data included for {@link TreeChangeEventsBeta.nodeChanged}.\n * @sealed @beta\n */\nexport interface NodeChangedData<TNode extends TreeNode = TreeNode> {\n\t/**\n\t * When the changed node is an object, map, or record node, this lists all the properties which changed.\n\t * @remarks\n\t * This only includes changes to the node itself (which would trigger {@link TreeChangeEvents.nodeChanged}).\n\t *\n\t * Not present when the {@link NodeKind} does not support this feature (currently just array nodes).\n\t *\n\t * When defined, the set should never be empty, since `nodeChanged` will only be triggered when there is a change, and for the supported node types, the only things that can change are properties.\n\t */\n\treadonly changedProperties?: ReadonlySet<\n\t\t// For Object nodes, strongly type with the property names from the schema:\n\t\tTNode extends WithType<string, NodeKind.Object, infer TInfo>\n\t\t\t? string & keyof TInfo\n\t\t\t: string\n\t>;\n\n\t/**\n\t * When the changed node is an array node, the sequential operations describing what changed.\n\t * @remarks\n\t * Not present for non-array nodes. When present, the value may be `undefined` when the\n\t * document was updated in a way that required multiple internal change passes in a single\n\t * operation (for example, a data change combined with a schema upgrade).\n\t */\n\treadonly delta?: readonly ArrayNodeDeltaOp[] | undefined;\n}\n\n/**\n * Data included for {@link TreeChangeEventsBeta.nodeChanged} when the node is an object, map, or record node.\n * @sealed @beta\n */\nexport interface NodeChangedDataProperties<TNode extends TreeNode = TreeNode>\n\textends NodeChangedData<TNode> {\n\t/**\n\t * Lists all the properties which changed on the node.\n\t */\n\treadonly changedProperties: ReadonlySet<\n\t\tTNode extends WithType<string, NodeKind.Object, infer TInfo>\n\t\t\t? string & keyof TInfo\n\t\t\t: string\n\t>;\n}\n\n/**\n * Data carried by the {@link TreeChangeEventsBeta.nodeChanged} event for array nodes.\n * @sealed @beta\n */\nexport interface NodeChangedDataDelta extends NodeChangedData {\n\t/**\n\t * The sequential operations describing what changed in the array node.\n\t * @remarks\n\t * The value may be `undefined` when the document was updated in a way that required multiple\n\t * internal change passes in a single operation (for example, a data change combined with a\n\t * schema upgrade).\n\t *\n\t * See {@link ArrayNodeDeltaOp} for op semantics.\n\t */\n\treadonly delta: readonly ArrayNodeDeltaOp[] | undefined;\n}\n\n/**\n * Data carried by the {@link TreeChangeEventsBeta.treeChanged} event for array nodes.\n * @remarks\n * Extends {@link NodeChangedDataDelta}: the retain ops in the delta additionally carry a\n * {@link ArrayNodeTreeChangedRetainOp.subtreeChanged} flag indicating whether any descendant\n * of the retained element changed.\n * @sealed @beta\n */\nexport interface NodeChangedDataTreeDelta {\n\t/**\n\t * The sequential operations describing what changed in the array node,\n\t * including subtree-change information on retain ops.\n\t * @remarks\n\t * The value may be `undefined` when the document was updated in a way that required multiple\n\t * internal change passes in a single operation (for example, a data change combined with a\n\t * schema upgrade).\n\t *\n\t * See {@link ArrayNodeTreeChangedDeltaOp} for op semantics.\n\t */\n\treadonly delta: readonly ArrayNodeTreeChangedDeltaOp[] | undefined;\n}\n\n/**\n * Extensions to {@link TreeChangeEvents} which are not yet stable.\n *\n * @sealed @beta\n */\nexport interface TreeChangeEventsBeta<TNode extends TreeNode = TreeNode>\n\textends Omit<TreeChangeEvents, \"nodeChanged\" | \"treeChanged\"> {\n\t/**\n\t * Emitted by a node after a batch of changes has been applied to the tree, if any of the changes affected the node.\n\t *\n\t * - Object nodes define a change as being when the value of one of its properties changes (i.e., the property's value is set, including when set to `undefined`).\n\t *\n\t * - Array nodes define a change as when an element is added, removed, moved or replaced.\n\t *\n\t * - Map nodes define a change as when an entry is added, updated, or removed.\n\t *\n\t * @remarks\n\t * This event is not emitted when:\n\t *\n\t * - Properties of a child node change. Notably, updates to an array node or a map node (like adding or removing\n\t * elements/entries) will emit this event on the array/map node itself, but not on the node that contains the\n\t * array/map node as one of its properties.\n\t *\n\t * - The node is moved to a different location in the tree or removed from the tree.\n\t * In this case the event is emitted on the _parent_ node, not the node itself.\n\t *\n\t * For remote edits, this event is not guaranteed to occur in the same order or quantity that it did in\n\t * the client that made the original edit.\n\t *\n\t * When the event is emitted, the tree is guaranteed to be in-schema.\n\t *\n\t * @privateRemarks\n\t * This event occurs whenever the apparent contents of the node instance change, regardless of what caused the change.\n\t * For example, it will fire when the local client reassigns a child, when part of a remote edit is applied to the\n\t * node, or when the node has to be updated due to resolution of a merge conflict\n\t * (for example a previously applied local change might be undone, then reapplied differently or not at all).\n\t *\n\t * TODO: define and document event ordering (ex: bottom up, with nodeChanged before treeChange on each level).\n\t *\n\t * This defines a property which is a function instead of using the method syntax to avoid function bi-variance issues with the input data to the callback.\n\t */\n\tnodeChanged: (\n\t\tdata: TNode extends WithType<string, NodeKind.Array>\n\t\t\t? NodeChangedDataDelta\n\t\t\t: TNode extends WithType<string, NodeKind.Map | NodeKind.Object | NodeKind.Record>\n\t\t\t\t? NodeChangedDataProperties<TNode>\n\t\t\t\t: NodeChangedData<TNode>,\n\t) => void;\n\n\t/**\n\t * Emitted when something in the subtree rooted at this node changes.\n\t *\n\t * @remarks\n\t * For array nodes, the event data carries a {@link NodeChangedDataTreeDelta.delta | delta}\n\t * payload describing both shallow and deep changes. Retain operations use\n\t * {@link ArrayNodeTreeChangedRetainOp.subtreeChanged} to indicate whether an element's\n\t * descendants changed.\n\t *\n\t * For non-array nodes, this has the same signature as {@link TreeChangeEvents.treeChanged}.\n\t * @privateRemarks\n\t * This defines a property which is a function instead of using the method syntax to avoid function bi-variance issues with the input data to the callback.\n\t */\n\ttreeChanged: TNode extends WithType<string, NodeKind.Array>\n\t\t? (data: NodeChangedDataTreeDelta) => void\n\t\t: TreeChangeEvents[\"treeChanged\"];\n}\n"]}

package/dist/simple-tree/api/treeNodeApi.d.ts

@@ -6,81 +6,7 @@ import { type DeltaMark } from "../../core/index.js";
 import { type TreeStatus } from "../../feature-libraries/index.js";
 import { type TreeNodeSchema, type TreeNode, type TreeLeafValue, type ImplicitAllowedTypes, type TreeNodeFromImplicitAllowedTypes } from "../core/index.js";
 import type { TreeChangeEvents } from "./treeChangeEvents.js";
-/**
- * A `"retain"` op in an {@link ArrayNodeDeltaOp} sequence.
- * Represents elements that were neither inserted into nor removed from the array.
- * @sealed @alpha
- */
-export interface ArrayNodeRetainOp {
-    readonly type: "retain";
-    readonly count: number;
-}
-/**
- * A `"retain"` op in an {@link ArrayNodeTreeChangedDeltaOp} sequence, used in
- * {@link NodeChangedDataTreeDelta} payloads delivered to
- * {@link TreeChangeEventsAlpha.treeChanged} on array nodes.
- *
- * Extends {@link ArrayNodeRetainOp} with a {@link ArrayNodeTreeChangedRetainOp.subtreeChanged}
- * flag that indicates whether any descendant of the retained element changed.
- * @sealed @alpha
- */
-export interface ArrayNodeTreeChangedRetainOp extends ArrayNodeRetainOp {
-    /**
-     * Whether any descendant of this retained element changed.
-     * `true` if the element's subtree changed; `false` if nothing changed within it.
-     * @remarks
-     * Subscribe to `nodeChanged` or `treeChanged` on the element node itself for details.
-     */
-    readonly subtreeChanged: boolean;
-}
-/**
- * A single operation in an array-node delta delivered by {@link TreeChangeEventsAlpha.treeChanged}.
- * Extends {@link ArrayNodeDeltaOp}: retain ops carry a {@link ArrayNodeTreeChangedRetainOp.subtreeChanged}
- * flag indicating whether any descendant of the retained element changed.
- * @alpha
- */
-export type ArrayNodeTreeChangedDeltaOp = ArrayNodeTreeChangedRetainOp | ArrayNodeInsertOp | ArrayNodeRemoveOp;
-/**
- * An `"insert"` op in an {@link ArrayNodeDeltaOp} sequence.
- * Represents elements added to the array.
- * Read the new element values from the current tree at the positions described by this op.
- * @sealed @alpha
- */
-export interface ArrayNodeInsertOp {
-    readonly type: "insert";
-    readonly count: number;
-}
-/**
- * A `"remove"` op in an {@link ArrayNodeDeltaOp} sequence.
- * Represents elements removed from the array.
- * @sealed @alpha
- */
-export interface ArrayNodeRemoveOp {
-    readonly type: "remove";
-    readonly count: number;
-}
-/**
- * A single operation in an array node change delta. Used to efficiently sync an external
- * representation of an array (e.g. a text editor or virtual list) with tree changes without
- * needing to snapshot the old state or diff the entire array. Each op describes a contiguous run
- * of positions in the array before the change. For inserts, read the new element values from the
- * current tree at those positions.
- *
- * @remarks
- * There is no dedicated `"move"` op. Moves are represented as `"remove"` + `"insert"`.
- * When an element is moved within the same array it appears
- * as a `"remove"` at the source position followed by an `"insert"` at the destination position.
- * When an element is moved across two different arrays, the source array's delta contains a
- * `"remove"` and the destination array's delta contains an `"insert"` — they cannot be
- * correlated without additional bookkeeping on the caller's side.
- *
- * The operations cover the complete array: trailing elements that were not changed are included
- * in a final `"retain"` op. Applying every operation therefore consumes the entire pre-edit array
- * and produces the entire post-edit array.
- *
- * @sealed @alpha
- */
-export type ArrayNodeDeltaOp = ArrayNodeRetainOp | ArrayNodeInsertOp | ArrayNodeRemoveOp;
+import type { ArrayNodeInsertOp, ArrayNodeRemoveOp, ArrayNodeRetainOp } from "./treeChangeEventsBeta.js";
 /**
  * Provides various functions for analyzing {@link TreeNode}s.
  *

package/dist/simple-tree/api/treeNodeApi.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"treeNodeApi.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/api/treeNodeApi.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"treeNodeApi.d.ts","sourceRoot":"","sources":["../../../src/simple-tree/api/treeNodeApi.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOH,OAAO,EAA0B,KAAK,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAC7E,OAAO,EAAE,KAAK,UAAU,EAA2B,MAAM,kCAAkC,CAAC;AAE5F,OAAO,EAGN,KAAK,cAAc,EAEnB,KAAK,QAAQ,EAKb,KAAK,aAAa,EAClB,KAAK,oBAAoB,EACzB,KAAK,gCAAgC,EAGrC,MAAM,kBAAkB,CAAC;AAY1B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,KAAK,EACX,iBAAiB,EACjB,iBAAiB,EACjB,iBAAiB,EACjB,MAAM,2BAA2B,CAAC;AAEnC;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,WAAW;IAC3B;;OAEG;IACH,MAAM,CAAC,IAAI,EAAE,QAAQ,GAAG,aAAa,GAAG,cAAc,CAAC;IAEvD;;;;;;;;OAQG;IACH,EAAE,CAAC,OAAO,SAAS,oBAAoB,EACtC,KAAK,EAAE,OAAO,EACd,MAAM,EAAE,OAAO,GACb,KAAK,IAAI,gCAAgC,CAAC,OAAO,CAAC,CAAC;IAEtD;;;;;;;OAOG;IACH,MAAM,CAAC,IAAI,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAC;IAE7C;;;;;;;;OAQG;IACH,GAAG,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,MAAM,CAAC;IAErC;;;;;;;;;;OAUG;IACH,EAAE,CAAC,CAAC,SAAS,MAAM,gBAAgB,EAClC,IAAI,EAAE,QAAQ,EACd,SAAS,EAAE,CAAC,EACZ,QAAQ,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAC3B,MAAM,IAAI,CAAC;IAEd;;OAEG;IACH,MAAM,CAAC,IAAI,EAAE,QAAQ,GAAG,UAAU,CAAC;IAEnC;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;CACrD;AAED;;GAEG;AACH,eAAO,MAAM,WAAW,EAAE,WA6IzB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,8BAA8B,CAAC,OAAO,SAAS,iBAAiB,EAC/E,KAAK,EAAE,SAAS,SAAS,EAAE,EAC3B,cAAc,EAAE,MAAM,EACtB,aAAa,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,cAAc,EAAE,OAAO,KAAK,OAAO,GAChE,CAAC,OAAO,GAAG,iBAAiB,GAAG,iBAAiB,CAAC,EAAE,CAyBrD;AAYD;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,SAAS,GAAG,cAAc,CA2BvE;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,qBAAqB,CACpC,IAAI,EAAE,QAAQ,EACd,WAAW,EAAE,kBAAkB,GAC7B,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;AAC/B,wBAAgB,qBAAqB,CACpC,IAAI,EAAE,QAAQ,EACd,WAAW,EAAE,YAAY,GACvB,MAAM,GAAG,SAAS,CAAC;AACtB,wBAAgB,qBAAqB,CACpC,IAAI,EAAE,QAAQ,EACd,WAAW,EAAE,cAAc,GACzB,MAAM,GAAG,SAAS,CAAC;AA8DtB;;GAEG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,MAAM,CAgB5D;AAED;;GAEG;AACH,wBAAgB,2BAA2B,CAC1C,MAAM,EAAE,cAAc,EACtB,SAAS,EAAE,MAAM,GAAG,MAAM,GACxB,MAAM,GAAG,MAAM,CAyBjB"}

package/dist/simple-tree/api/treeNodeApi.js

@@ -4,7 +4,12 @@
  * Licensed under the MIT License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPropertyKeyFromStoredKey = exports.getStoredKey = exports.getIdentifierFromNode = exports.tryGetSchema = exports.deltaMarksToArrayOpsWithRetain = exports.treeNodeApi = void 0;
+exports.treeNodeApi = void 0;
+exports.deltaMarksToArrayOpsWithRetain = deltaMarksToArrayOpsWithRetain;
+exports.tryGetSchema = tryGetSchema;
+exports.getIdentifierFromNode = getIdentifierFromNode;
+exports.getStoredKey = getStoredKey;
+exports.getPropertyKeyFromStoredKey = getPropertyKeyFromStoredKey;
 const internal_1 = require("@fluidframework/core-utils/internal");
 const internal_2 = require("@fluidframework/runtime-utils/internal");
 const internal_3 = require("@fluidframework/telemetry-utils/internal");
@@ -61,7 +66,7 @@ exports.treeNodeApi = {
                         const marks = fieldMarks.get(index_js_1.EmptyKey);
                         // nodeChanged fires only for shallow changes (insert, remove, move).
                         // Deep changes (e.g. a property of an element changed) are
-                        // surfaced via TreeChangeEventsAlpha.treeChanged with a delta payload instead.
+                        // surfaced via TreeChangeEventsBeta.treeChanged with a delta payload instead.
                         // When marks are undefined (marks could not be composed across multiple
                         // internal passes), we conservatively fire nodeChanged rather than silently
                         // dropping the event, even though the underlying change may have been
@@ -185,7 +190,6 @@ function deltaMarksToArrayOpsWithRetain(marks, postEditLength, buildRetainOp) {
     }
     return ops;
 }
-exports.deltaMarksToArrayOpsWithRetain = deltaMarksToArrayOpsWithRetain;
 /**
  * Returns the length of the `EmptyKey` field under the provided node kernel.
  * @remarks
@@ -227,7 +231,6 @@ function tryGetSchema(value) {
         }
     }
 }
-exports.tryGetSchema = tryGetSchema;
 function getIdentifierFromNode(node, compression) {
     const schema = node[index_js_4.typeSchemaSymbol];
     if (!(0, index_js_5.isObjectNodeSchema)(schema)) {
@@ -280,7 +283,6 @@ function getIdentifierFromNode(node, compression) {
         }
     }
 }
-exports.getIdentifierFromNode = getIdentifierFromNode;
 /**
  * Gets the stored key with which the provided node is associated in the parent.
  */
@@ -297,7 +299,6 @@ function getStoredKey(node) {
     (0, internal_1.assert)(parentField.index === 0, 0xa29 /* When using field key as key, index should be 0 */);
     return parentField.parent.key;
 }
-exports.getStoredKey = getStoredKey;
 /**
  * Given a node schema, gets the property key corresponding with the provided {@link FieldProps.key | stored key}.
  */
@@ -323,5 +324,4 @@ function getPropertyKeyFromStoredKey(schema, storedKey) {
     }
     return storedKey;
 }
-exports.getPropertyKeyFromStoredKey = getPropertyKeyFromStoredKey;
 //# sourceMappingURL=treeNodeApi.js.map

package/dist/simple-tree/api/treeNodeApi.js.map

@@ -1 +1 @@
-{"version":3,"file":"treeNodeApi.js","sourceRoot":"","sources":["../../../src/simple-tree/api/treeNodeApi.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport type { Off } from \"@fluidframework/core-interfaces\";\nimport { assert, oob, fail, unreachableCase } from \"@fluidframework/core-utils/internal\";\nimport { isFluidHandle } from \"@fluidframework/runtime-utils/internal\";\nimport { UsageError } from \"@fluidframework/telemetry-utils/internal\";\n\nimport { EmptyKey, rootFieldKey, type DeltaMark } from \"../../core/index.js\";\nimport { type TreeStatus, isTreeValue, FieldKinds } from \"../../feature-libraries/index.js\";\nimport { extractFromOpaque } from \"../../util/index.js\";\nimport {\n\tgetKernel,\n\tisTreeNode,\n\ttype TreeNodeSchema,\n\tNodeKind,\n\ttype TreeNode,\n\ttryGetTreeNodeSchema,\n\tgetOrCreateNodeFromInnerNode,\n\ttypeSchemaSymbol,\n\tgetInnerNode,\n\ttype TreeLeafValue,\n\ttype ImplicitAllowedTypes,\n\ttype TreeNodeFromImplicitAllowedTypes,\n\tnormalizeAllowedTypes,\n\ttype TreeNodeKernel,\n} from \"../core/index.js\";\nimport { type ImplicitFieldSchema, FieldSchema } from \"../fieldSchema.js\";\nimport { tryGetTreeNodeForField } from \"../getTreeNodeForField.js\";\nimport {\n\tbooleanSchema,\n\thandleSchema,\n\tnullSchema,\n\tnumberSchema,\n\tstringSchema,\n} from \"../leafNodeSchema.js\";\nimport { isArrayNodeSchema, isObjectNodeSchema } from \"../node-kinds/index.js\";\n\nimport type { TreeChangeEvents } from \"./treeChangeEvents.js\";\n\n/**\n * A `\"retain\"` op in an {@link ArrayNodeDeltaOp} sequence.\n * Represents elements that were neither inserted into nor removed from the array.\n * @sealed @alpha\n */\nexport interface ArrayNodeRetainOp {\n\treadonly type: \"retain\";\n\treadonly count: number;\n}\n\n/**\n * A `\"retain\"` op in an {@link ArrayNodeTreeChangedDeltaOp} sequence, used in\n * {@link NodeChangedDataTreeDelta} payloads delivered to\n * {@link TreeChangeEventsAlpha.treeChanged} on array nodes.\n *\n * Extends {@link ArrayNodeRetainOp} with a {@link ArrayNodeTreeChangedRetainOp.subtreeChanged}\n * flag that indicates whether any descendant of the retained element changed.\n * @sealed @alpha\n */\nexport interface ArrayNodeTreeChangedRetainOp extends ArrayNodeRetainOp {\n\t/**\n\t * Whether any descendant of this retained element changed.\n\t * `true` if the element's subtree changed; `false` if nothing changed within it.\n\t * @remarks\n\t * Subscribe to `nodeChanged` or `treeChanged` on the element node itself for details.\n\t */\n\treadonly subtreeChanged: boolean;\n}\n\n/**\n * A single operation in an array-node delta delivered by {@link TreeChangeEventsAlpha.treeChanged}.\n * Extends {@link ArrayNodeDeltaOp}: retain ops carry a {@link ArrayNodeTreeChangedRetainOp.subtreeChanged}\n * flag indicating whether any descendant of the retained element changed.\n * @alpha\n */\nexport type ArrayNodeTreeChangedDeltaOp =\n\t| ArrayNodeTreeChangedRetainOp\n\t| ArrayNodeInsertOp\n\t| ArrayNodeRemoveOp;\n\n/**\n * An `\"insert\"` op in an {@link ArrayNodeDeltaOp} sequence.\n * Represents elements added to the array.\n * Read the new element values from the current tree at the positions described by this op.\n * @sealed @alpha\n */\nexport interface ArrayNodeInsertOp {\n\treadonly type: \"insert\";\n\treadonly count: number;\n}\n\n/**\n * A `\"remove\"` op in an {@link ArrayNodeDeltaOp} sequence.\n * Represents elements removed from the array.\n * @sealed @alpha\n */\nexport interface ArrayNodeRemoveOp {\n\treadonly type: \"remove\";\n\treadonly count: number;\n}\n\n/**\n * A single operation in an array node change delta. Used to efficiently sync an external\n * representation of an array (e.g. a text editor or virtual list) with tree changes without\n * needing to snapshot the old state or diff the entire array. Each op describes a contiguous run\n * of positions in the array before the change. For inserts, read the new element values from the\n * current tree at those positions.\n *\n * @remarks\n * There is no dedicated `\"move\"` op. Moves are represented as `\"remove\"` + `\"insert\"`.\n * When an element is moved within the same array it appears\n * as a `\"remove\"` at the source position followed by an `\"insert\"` at the destination position.\n * When an element is moved across two different arrays, the source array's delta contains a\n * `\"remove\"` and the destination array's delta contains an `\"insert\"` — they cannot be\n * correlated without additional bookkeeping on the caller's side.\n *\n * The operations cover the complete array: trailing elements that were not changed are included\n * in a final `\"retain\"` op. Applying every operation therefore consumes the entire pre-edit array\n * and produces the entire post-edit array.\n *\n * @sealed @alpha\n */\nexport type ArrayNodeDeltaOp = ArrayNodeRetainOp | ArrayNodeInsertOp | ArrayNodeRemoveOp;\n\n/**\n * Provides various functions for analyzing {@link TreeNode}s.\n *\n * @remarks\n * With the exception of {@link TreeNodeApi.status}, these functions should not be called with nodes that have\n * been {@link TreeStatus.Deleted | deleted}.\n * To verify whether or not a node already has been deleted, use the {@link TreeNodeApi.status} function.\n *\n * This type should only be used via the public {@link (Tree:variable)} export.\n *\n * @privateRemarks\n * Due to limitations of API-Extractor link resolution, this type can't be moved into internalTypes but should be considered just an implementation detail of the `Tree` export.\n *\n * Inlining the typing of this interface onto the `Tree` object provides slightly different .d.ts generation,\n * which avoids typescript expanding the type of TreeNodeSchema and thus encountering\n * https://github.com/microsoft/rushstack/issues/1958.\n * @sealed @public\n */\nexport interface TreeNodeApi {\n\t/**\n\t * The schema information for this node.\n\t */\n\tschema(node: TreeNode | TreeLeafValue): TreeNodeSchema;\n\n\t/**\n\t * Narrow the type of the given value if it satisfies the given schema.\n\t * @example\n\t * ```ts\n\t * if (node.is(myNode, Point)) {\n\t *     const y = myNode.y; // `myNode` is now known to satisfy the `Point` schema and therefore has a `y` coordinate.\n\t * }\n\t * ```\n\t */\n\tis<TSchema extends ImplicitAllowedTypes>(\n\t\tvalue: unknown,\n\t\tschema: TSchema,\n\t): value is TreeNodeFromImplicitAllowedTypes<TSchema>;\n\n\t/**\n\t * Return the node under which this node resides in the tree (or undefined if this is a root node of the tree).\n\t *\n\t * @throws A {@link @fluidframework/telemetry-utils#UsageError} if the node has been {@link TreeStatus.Deleted | deleted}.\n\t *\n\t * @see {@link (TreeAlpha:interface).child}\n\t * @see {@link (TreeAlpha:interface).children}\n\t */\n\tparent(node: TreeNode): TreeNode | undefined;\n\n\t/**\n\t * The key of the given node under its parent.\n\t *\n\t * @remarks\n\t * If `node` is an element in a {@link (TreeArrayNode:interface)}, this returns the index of `node` in the array node (a `number`).\n\t * Otherwise, this returns the key of the field that it is under (a `string`).\n\t *\n\t * @throws A {@link @fluidframework/telemetry-utils#UsageError} if the node has been {@link TreeStatus.Deleted | deleted}.\n\t */\n\tkey(node: TreeNode): string | number;\n\n\t/**\n\t * Register an event listener on the given node.\n\t * @param node - The node whose events should be subscribed to.\n\t * @param eventName - Which event to subscribe to.\n\t * @param listener - The callback to trigger for the event. The tree can be read during the callback, but it is invalid to modify the tree during this callback.\n\t * @returns A callback function which will deregister the event.\n\t * This callback should be called only once.\n\t * @remarks\n\t * The returned unsubscribe function should be called any time the need for the `listener` callback ends before the node is {@link TreeStatus.Deleted | deleted} (Not just {@link TreeStatus.Removed | removed}).\n\t * Doing so removes the overhead of tracking and triggering the event, and also avoids leaking any memory retained by the callback.\n\t */\n\ton<K extends keyof TreeChangeEvents>(\n\t\tnode: TreeNode,\n\t\teventName: K,\n\t\tlistener: TreeChangeEvents[K],\n\t): () => void;\n\n\t/**\n\t * Returns the {@link TreeStatus} of the given node.\n\t */\n\tstatus(node: TreeNode): TreeStatus;\n\n\t/**\n\t * Returns the {@link SchemaFactory.identifier | identifier} of the given node in the most compressed form possible.\n\t * @remarks\n\t * If the node is {@link Unhydrated | hydrated}  and its identifier is a valid UUID that was automatically generated by the SharedTree it is part of (or something else using the same {@link @fluidframework/id-compressor#IIdCompressor}), then this will return a process-unique integer corresponding to that identifier.\n\t * This is useful for performance-sensitive scenarios involving many nodes with identifiers that need to be compactly retained in memory or used for efficient lookup.\n\t * Note that automatically generated identifiers that were accessed before the node was hydrated will return the generated UUID, not the process-unique integer.\n\t *\n\t * If the node's identifier is any other user-provided string, then this will return that string.\n\t *\n\t * If the node has no identifier (that is, it has no {@link SchemaFactory.identifier | identifier} field), then this returns `undefined`.\n\t *\n\t * If the node has more than one identifier, then this will throw an error.\n\t *\n\t * The returned integer should not be serialized or preserved outside of the current process.\n\t * Its lifetime is that of the current in-memory instance of the FF container for this client, and it is not guaranteed to be unique or stable outside of that context.\n\t * The same node's identifier may, for example, be different across multiple sessions for the same client and document, or different across two clients in the same session.\n\t */\n\tshortId(node: TreeNode): number | string | undefined;\n}\n\n/**\n * {@inheritDoc TreeNodeApi}\n */\nexport const treeNodeApi: TreeNodeApi = {\n\tparent(node: TreeNode): TreeNode | undefined {\n\t\tconst editNode = getInnerNode(node).parentField.parent.parent;\n\t\tif (editNode === undefined) {\n\t\t\treturn undefined;\n\t\t}\n\n\t\tconst output = getOrCreateNodeFromInnerNode(editNode);\n\t\tassert(\n\t\t\t!isTreeValue(output),\n\t\t\t0x87f /* Parent can't be a leaf, so it should be a node not a value */,\n\t\t);\n\t\treturn output;\n\t},\n\tkey(node: TreeNode): string | number {\n\t\t// If the parent is undefined, then this node is under the root field,\n\t\t// so we know its key is the special root one.\n\t\tconst parent = treeNodeApi.parent(node);\n\t\tif (parent === undefined) {\n\t\t\treturn rootFieldKey;\n\t\t}\n\n\t\t// The flex-domain strictly operates in terms of \"stored keys\".\n\t\t// To find the associated developer-facing \"property key\", we need to look up the field associated with\n\t\t// the stored key from the flex-domain, and get property key its simple-domain counterpart was created with.\n\t\tconst storedKey = getStoredKey(node);\n\t\tconst parentSchema = treeNodeApi.schema(parent);\n\t\tconst propertyKey = getPropertyKeyFromStoredKey(parentSchema, storedKey);\n\t\treturn propertyKey;\n\t},\n\ton<K extends keyof TreeChangeEvents>(\n\t\tnode: TreeNode,\n\t\teventName: K,\n\t\tlistener: TreeChangeEvents[K],\n\t): Off {\n\t\tconst kernel = getKernel(node);\n\t\tswitch (eventName) {\n\t\t\tcase \"nodeChanged\": {\n\t\t\t\tconst nodeSchema = kernel.schema;\n\t\t\t\tif (isObjectNodeSchema(nodeSchema)) {\n\t\t\t\t\treturn kernel.events.on(\"childrenChangedAfterBatch\", ({ changedFields }) => {\n\t\t\t\t\t\tconst changedProperties = new Set(\n\t\t\t\t\t\t\tArray.from(\n\t\t\t\t\t\t\t\tchangedFields,\n\t\t\t\t\t\t\t\t(field) =>\n\t\t\t\t\t\t\t\t\tnodeSchema.storedKeyToPropertyKey.get(field) ??\n\t\t\t\t\t\t\t\t\tfail(0xb36 /* Could not find stored key in schema. */),\n\t\t\t\t\t\t\t),\n\t\t\t\t\t\t);\n\t\t\t\t\t\tlistener({ changedProperties });\n\t\t\t\t\t});\n\t\t\t\t} else if (isArrayNodeSchema(nodeSchema)) {\n\t\t\t\t\treturn kernel.events.on(\"childrenChangedAfterBatch\", ({ fieldMarks }) => {\n\t\t\t\t\t\tconst marks = fieldMarks.get(EmptyKey);\n\t\t\t\t\t\t// nodeChanged fires only for shallow changes (insert, remove, move).\n\t\t\t\t\t\t// Deep changes (e.g. a property of an element changed) are\n\t\t\t\t\t\t// surfaced via TreeChangeEventsAlpha.treeChanged with a delta payload instead.\n\t\t\t\t\t\t// When marks are undefined (marks could not be composed across multiple\n\t\t\t\t\t\t// internal passes), we conservatively fire nodeChanged rather than silently\n\t\t\t\t\t\t// dropping the event, even though the underlying change may have been\n\t\t\t\t\t\t// purely deep. This is a known limitation of the current eventing stack.\n\t\t\t\t\t\tconst hasShallowChange =\n\t\t\t\t\t\t\tmarks === undefined ||\n\t\t\t\t\t\t\tmarks.some((m) => m.attach !== undefined || m.detach !== undefined);\n\t\t\t\t\t\tif (!hasShallowChange) {\n\t\t\t\t\t\t\treturn;\n\t\t\t\t\t\t}\n\t\t\t\t\t\t// `marks` is undefined when the field was modified across multiple batches\n\t\t\t\t\t\t// within a single flush (e.g. due to an interleaved schema change) and the\n\t\t\t\t\t\t// marks could not be composed. Emit `undefined` so callers know the delta is\n\t\t\t\t\t\t// unavailable rather than receiving stale marks from only the first batch.\n\t\t\t\t\t\t// TODO: Once the eventing stack is rewritten to walk the composed delta at\n\t\t\t\t\t\t// flush time, `marks` will always be defined. Remove the `undefined` fallback.\n\t\t\t\t\t\tconst delta =\n\t\t\t\t\t\t\tmarks === undefined\n\t\t\t\t\t\t\t\t? undefined\n\t\t\t\t\t\t\t\t: deltaMarksToArrayOpsWithRetain(marks, getArrayLength(kernel), (count) => ({\n\t\t\t\t\t\t\t\t\t\ttype: \"retain\",\n\t\t\t\t\t\t\t\t\t\tcount,\n\t\t\t\t\t\t\t\t\t}));\n\t\t\t\t\t\tlistener({ delta });\n\t\t\t\t\t});\n\t\t\t\t} else {\n\t\t\t\t\treturn kernel.events.on(\"childrenChangedAfterBatch\", ({ changedFields }) => {\n\t\t\t\t\t\tlistener({ changedProperties: changedFields });\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t}\n\t\t\tcase \"treeChanged\": {\n\t\t\t\tif (isArrayNodeSchema(kernel.schema)) {\n\t\t\t\t\t// For array nodes, treeChanged fires via childrenChangedAfterBatch so that a\n\t\t\t\t\t// delta payload can be provided. This covers both shallow changes\n\t\t\t\t\t// (insert/remove/move) and deep element changes. Stable (non-alpha) listeners\n\t\t\t\t\t// typed as () => void will silently ignore the extra argument at runtime.\n\t\t\t\t\treturn kernel.events.on(\"childrenChangedAfterBatch\", ({ fieldMarks }) => {\n\t\t\t\t\t\tconst marks = fieldMarks.get(EmptyKey);\n\t\t\t\t\t\tconst delta =\n\t\t\t\t\t\t\tmarks === undefined\n\t\t\t\t\t\t\t\t? undefined\n\t\t\t\t\t\t\t\t: deltaMarksToArrayOpsWithRetain(\n\t\t\t\t\t\t\t\t\t\tmarks,\n\t\t\t\t\t\t\t\t\t\tgetArrayLength(kernel),\n\t\t\t\t\t\t\t\t\t\t(count, subtreeChanged) => ({\n\t\t\t\t\t\t\t\t\t\t\ttype: \"retain\",\n\t\t\t\t\t\t\t\t\t\t\tcount,\n\t\t\t\t\t\t\t\t\t\t\tsubtreeChanged,\n\t\t\t\t\t\t\t\t\t\t}),\n\t\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t(listener as (data: { readonly delta: typeof delta }) => void)({ delta });\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t\treturn kernel.events.on(\"subtreeChangedAfterBatch\", () => listener({}));\n\t\t\t}\n\t\t\tdefault: {\n\t\t\t\tthrow new UsageError(`No event named ${JSON.stringify(eventName)}.`);\n\t\t\t}\n\t\t}\n\t},\n\tstatus(node: TreeNode): TreeStatus {\n\t\treturn getKernel(node).getStatus();\n\t},\n\tis<TSchema extends ImplicitAllowedTypes>(\n\t\tvalue: unknown,\n\t\tschema: TSchema,\n\t): value is TreeNodeFromImplicitAllowedTypes<TSchema> {\n\t\t// This \"is\" utility would return false if the provided schema is a base type of the actual schema.\n\t\t// This could be confusing, and that case can only be hit when violating the rule that there is a single most derived schema that gets used (See documentation on TreeNodeSchemaClass).\n\t\t// Therefore this uses markSchemaMostDerived to ensure an informative usage error is thrown in the case where a base type is used.\n\n\t\tconst actualSchema = tryGetSchema(value);\n\t\tif (actualSchema === undefined) {\n\t\t\treturn false;\n\t\t}\n\t\treturn normalizeAllowedTypes(schema).evaluateSet().has(actualSchema);\n\t},\n\tschema(node: TreeNode | TreeLeafValue): TreeNodeSchema {\n\t\treturn tryGetSchema(node) ?? fail(0xb37 /* Not a tree node */);\n\t},\n\tshortId(node: TreeNode): number | string | undefined {\n\t\treturn getIdentifierFromNode(node, \"preferCompressed\");\n\t},\n};\n\n/**\n * Converts internal {@link DeltaMark}s for an array's sequence field into sequential array delta\n * operations.\n *\n * @remarks\n * Each mark describes a contiguous run:\n * - A mark with only `count` becomes a retain.\n * - A mark with only `attach` becomes an insert.\n * - A mark with only `detach` becomes a remove.\n * - A mark with both `attach` and `detach` becomes a remove followed by an insert.\n *\n * Internal mark arrays may omit an unchanged suffix. The returned operations always cover the\n * complete array, so this function uses the array's post-edit length to append a trailing retain\n * when needed.\n *\n * @param marks - The low-level delta marks for the array's sequence field.\n * @param postEditLength - The array's length after the edit.\n * @param buildRetainOp - Builds a retain operation. Its second argument indicates whether the\n * retained element's subtree changed; it is `false` for a synthesized trailing retain.\n *\n * @privateRemarks\n * The case where both `attach` and `detach` are set is unreachable today: the sequence-field\n * encoder never emits such marks for array (`EmptyKey`) fields. It is handled defensively.\n */\nexport function deltaMarksToArrayOpsWithRetain<TRetain extends ArrayNodeRetainOp>(\n\tmarks: readonly DeltaMark[],\n\tpostEditLength: number,\n\tbuildRetainOp: (count: number, subtreeChanged: boolean) => TRetain,\n): (TRetain | ArrayNodeInsertOp | ArrayNodeRemoveOp)[] {\n\tconst ops: (TRetain | ArrayNodeInsertOp | ArrayNodeRemoveOp)[] = [];\n\tlet processedLength = 0;\n\tfor (const mark of marks) {\n\t\tif (mark.detach !== undefined) {\n\t\t\tops.push({ type: \"remove\", count: mark.count });\n\t\t}\n\t\tif (mark.attach !== undefined) {\n\t\t\tops.push({ type: \"insert\", count: mark.count });\n\t\t\tprocessedLength += mark.count;\n\t\t} else if (mark.detach === undefined) {\n\t\t\t// When `fields` is set, `count` is guaranteed to be 1 (DeltaMark invariant).\n\t\t\tops.push(buildRetainOp(mark.count, mark.fields !== undefined));\n\t\t\tprocessedLength += mark.count;\n\t\t}\n\t}\n\t// DeltaMark arrays are allowed to omit the trailing retain, while our user facing array equivalents are not, so add it if necessary.\n\tassert(\n\t\tprocessedLength <= postEditLength,\n\t\t0xd19 /* Array delta exceeds post-edit array length */,\n\t);\n\tif (processedLength < postEditLength) {\n\t\tops.push(buildRetainOp(postEditLength - processedLength, false));\n\t}\n\treturn ops;\n}\n\n/**\n * Returns the length of the `EmptyKey` field under the provided node kernel.\n * @remarks\n * Use this with the kernel of an array node to get the current length of the array.\n * This is the same as `.length` on the array node, but is usable without having to get (and possible create) the node and narrow to the proper type to access that.\n */\nfunction getArrayLength(arrayNodeKernel: TreeNodeKernel): number {\n\treturn arrayNodeKernel.getInnerNode().getBoxed(EmptyKey).length;\n}\n\n/**\n * Returns a schema for a value if the value is a {@link TreeNode} or a {@link TreeLeafValue}.\n * Returns undefined for other values.\n */\nexport function tryGetSchema(value: unknown): undefined | TreeNodeSchema {\n\tswitch (typeof value) {\n\t\tcase \"string\": {\n\t\t\treturn stringSchema;\n\t\t}\n\t\tcase \"number\": {\n\t\t\treturn numberSchema;\n\t\t}\n\t\tcase \"boolean\": {\n\t\t\treturn booleanSchema;\n\t\t}\n\t\tcase \"object\": {\n\t\t\tif (isTreeNode(value)) {\n\t\t\t\t// TODO: This case could be optimized, for example by placing the simple schema in a symbol on tree nodes.\n\t\t\t\treturn tryGetTreeNodeSchema(value);\n\t\t\t}\n\t\t\tif (value === null) {\n\t\t\t\treturn nullSchema;\n\t\t\t}\n\t\t\tif (isFluidHandle(value)) {\n\t\t\t\treturn handleSchema;\n\t\t\t}\n\t\t}\n\t\tdefault: {\n\t\t\treturn undefined;\n\t\t}\n\t}\n}\n\n/**\n * Gets the identifier from a node.\n *\n * @param node - {@link TreeNode} where you want to extract the identifier from.\n * @param compression - string value to determine what type of identifier you want to retrieve.\n *\n * @remarks\n * If the node does not contain an identifier field, it returns undefined.\n *\n * If `compression` is set to `compressed`:\n *\n * - If the node contains a compressible identifier known by the id compressor, the compressed identifier is returned.\n *\n * - If the node contains an identifier, but is not compressible or unknown by the id compressor, `undefined` is returned.\n *\n * If `compression` is set to `preferCompressed`:\n *\n * - If the node contains a compressible identifier known by the id compressor, the compressed identifier is returned.\n *\n * - If the node contains an identifier, but is not compressible or unknown by the id compressor, the uncompressed identifier is returned.\n *\n * If `compression` is set to `uncompressed`:\n * - If the node contains an identifier field, the uncompressed identifier is returned.\n */\nexport function getIdentifierFromNode(\n\tnode: TreeNode,\n\tcompression: \"preferCompressed\",\n): number | string | undefined;\nexport function getIdentifierFromNode(\n\tnode: TreeNode,\n\tcompression: \"compressed\",\n): number | undefined;\nexport function getIdentifierFromNode(\n\tnode: TreeNode,\n\tcompression: \"uncompressed\",\n): string | undefined;\nexport function getIdentifierFromNode(\n\tnode: TreeNode,\n\tcompression: \"preferCompressed\" | \"compressed\" | \"uncompressed\",\n): number | string | undefined {\n\tconst schema = node[typeSchemaSymbol];\n\tif (!isObjectNodeSchema(schema)) {\n\t\treturn undefined;\n\t}\n\n\tconst flexNode = getInnerNode(node);\n\tconst identifierFieldKeys = schema.identifierFieldKeys;\n\n\tswitch (identifierFieldKeys.length) {\n\t\tcase 0: {\n\t\t\treturn undefined;\n\t\t}\n\t\tcase 1: {\n\t\t\tconst key = identifierFieldKeys[0] ?? oob();\n\t\t\tconst identifierField = flexNode.tryGetField(key);\n\t\t\tassert(identifierField !== undefined, 0xbb5 /* missing identifier field */);\n\t\t\tconst identifierValue = tryGetTreeNodeForField(identifierField);\n\t\t\tassert(typeof identifierValue === \"string\", 0xbb6 /* identifier not a string */);\n\n\t\t\tconst context = flexNode.context;\n\t\t\tswitch (compression) {\n\t\t\t\tcase \"preferCompressed\": {\n\t\t\t\t\tif (context.isHydrated()) {\n\t\t\t\t\t\tconst localNodeKey =\n\t\t\t\t\t\t\tcontext.nodeKeyManager.tryLocalizeNodeIdentifier(identifierValue);\n\t\t\t\t\t\treturn localNodeKey === undefined\n\t\t\t\t\t\t\t? identifierValue\n\t\t\t\t\t\t\t: extractFromOpaque(localNodeKey);\n\t\t\t\t\t} else {\n\t\t\t\t\t\treturn identifierValue;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tcase \"compressed\": {\n\t\t\t\t\tif (context.isHydrated()) {\n\t\t\t\t\t\tconst localNodeKey =\n\t\t\t\t\t\t\tcontext.nodeKeyManager.tryLocalizeNodeIdentifier(identifierValue);\n\t\t\t\t\t\treturn localNodeKey === undefined ? undefined : extractFromOpaque(localNodeKey);\n\t\t\t\t\t} else {\n\t\t\t\t\t\treturn undefined;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tcase \"uncompressed\": {\n\t\t\t\t\treturn identifierValue;\n\t\t\t\t}\n\t\t\t\tdefault: {\n\t\t\t\t\tunreachableCase(compression);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tdefault: {\n\t\t\tthrow new UsageError(\n\t\t\t\t\"The node has more than one identifier. Retrieve identifiers individually via their fields instead.\",\n\t\t\t);\n\t\t}\n\t}\n}\n\n/**\n * Gets the stored key with which the provided node is associated in the parent.\n */\nexport function getStoredKey(node: TreeNode): string | number {\n\t// Note: the flex domain strictly works with \"stored keys\", and knows nothing about the developer-facing\n\t// \"property keys\".\n\tconst parentField = getInnerNode(node).parentField;\n\tif (parentField.parent.schema === FieldKinds.sequence.identifier) {\n\t\t// The parent of `node` is an array node\n\t\tassert(\n\t\t\tparentField.parent.key === EmptyKey,\n\t\t\t0xa28 /* When using index as key, field should use EmptyKey */,\n\t\t);\n\t\treturn parentField.index;\n\t}\n\n\t// The parent of `node` is an object, a map, or undefined. If undefined, then `node` is a root/detached node.\n\tassert(parentField.index === 0, 0xa29 /* When using field key as key, index should be 0 */);\n\treturn parentField.parent.key;\n}\n\n/**\n * Given a node schema, gets the property key corresponding with the provided {@link FieldProps.key | stored key}.\n */\nexport function getPropertyKeyFromStoredKey(\n\tschema: TreeNodeSchema,\n\tstoredKey: string | number,\n): string | number {\n\t// Only object nodes have the concept of a \"stored key\", differentiated from the developer-facing \"property key\".\n\t// For any other kind of node, the stored key and the property key are the same.\n\tif (schema.kind !== NodeKind.Object) {\n\t\treturn storedKey;\n\t}\n\n\tconst fields = schema.info as Record<string, ImplicitFieldSchema>;\n\n\t// Invariants:\n\t// - The set of all property keys under an object must be unique.\n\t// - The set of all stored keys (including those implicitly created from property keys) must be unique.\n\t// To find the property key associated with the provided stored key, first check for any stored key matches (which are optionally populated).\n\t// If we don't find any, then search for a matching property key.\n\tfor (const [propertyKey, fieldSchema] of Object.entries(fields)) {\n\t\tif (fieldSchema instanceof FieldSchema && fieldSchema.props?.key === storedKey) {\n\t\t\treturn propertyKey;\n\t\t}\n\t}\n\n\tif (fields[storedKey] === undefined) {\n\t\tfail(0xb38 /* Existing stored key should always map to a property key */);\n\t}\n\n\treturn storedKey;\n}\n"]}
+{"version":3,"file":"treeNodeApi.js","sourceRoot":"","sources":["../../../src/simple-tree/api/treeNodeApi.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport type { Off } from \"@fluidframework/core-interfaces\";\nimport { assert, oob, fail, unreachableCase } from \"@fluidframework/core-utils/internal\";\nimport { isFluidHandle } from \"@fluidframework/runtime-utils/internal\";\nimport { UsageError } from \"@fluidframework/telemetry-utils/internal\";\n\nimport { EmptyKey, rootFieldKey, type DeltaMark } from \"../../core/index.js\";\nimport { type TreeStatus, isTreeValue, FieldKinds } from \"../../feature-libraries/index.js\";\nimport { extractFromOpaque } from \"../../util/index.js\";\nimport {\n\tgetKernel,\n\tisTreeNode,\n\ttype TreeNodeSchema,\n\tNodeKind,\n\ttype TreeNode,\n\ttryGetTreeNodeSchema,\n\tgetOrCreateNodeFromInnerNode,\n\ttypeSchemaSymbol,\n\tgetInnerNode,\n\ttype TreeLeafValue,\n\ttype ImplicitAllowedTypes,\n\ttype TreeNodeFromImplicitAllowedTypes,\n\tnormalizeAllowedTypes,\n\ttype TreeNodeKernel,\n} from \"../core/index.js\";\nimport { type ImplicitFieldSchema, FieldSchema } from \"../fieldSchema.js\";\nimport { tryGetTreeNodeForField } from \"../getTreeNodeForField.js\";\nimport {\n\tbooleanSchema,\n\thandleSchema,\n\tnullSchema,\n\tnumberSchema,\n\tstringSchema,\n} from \"../leafNodeSchema.js\";\nimport { isArrayNodeSchema, isObjectNodeSchema } from \"../node-kinds/index.js\";\n\nimport type { TreeChangeEvents } from \"./treeChangeEvents.js\";\nimport type {\n\tArrayNodeInsertOp,\n\tArrayNodeRemoveOp,\n\tArrayNodeRetainOp,\n} from \"./treeChangeEventsBeta.js\";\n\n/**\n * Provides various functions for analyzing {@link TreeNode}s.\n *\n * @remarks\n * With the exception of {@link TreeNodeApi.status}, these functions should not be called with nodes that have\n * been {@link TreeStatus.Deleted | deleted}.\n * To verify whether or not a node already has been deleted, use the {@link TreeNodeApi.status} function.\n *\n * This type should only be used via the public {@link (Tree:variable)} export.\n *\n * @privateRemarks\n * Due to limitations of API-Extractor link resolution, this type can't be moved into internalTypes but should be considered just an implementation detail of the `Tree` export.\n *\n * Inlining the typing of this interface onto the `Tree` object provides slightly different .d.ts generation,\n * which avoids typescript expanding the type of TreeNodeSchema and thus encountering\n * https://github.com/microsoft/rushstack/issues/1958.\n * @sealed @public\n */\nexport interface TreeNodeApi {\n\t/**\n\t * The schema information for this node.\n\t */\n\tschema(node: TreeNode | TreeLeafValue): TreeNodeSchema;\n\n\t/**\n\t * Narrow the type of the given value if it satisfies the given schema.\n\t * @example\n\t * ```ts\n\t * if (node.is(myNode, Point)) {\n\t *     const y = myNode.y; // `myNode` is now known to satisfy the `Point` schema and therefore has a `y` coordinate.\n\t * }\n\t * ```\n\t */\n\tis<TSchema extends ImplicitAllowedTypes>(\n\t\tvalue: unknown,\n\t\tschema: TSchema,\n\t): value is TreeNodeFromImplicitAllowedTypes<TSchema>;\n\n\t/**\n\t * Return the node under which this node resides in the tree (or undefined if this is a root node of the tree).\n\t *\n\t * @throws A {@link @fluidframework/telemetry-utils#UsageError} if the node has been {@link TreeStatus.Deleted | deleted}.\n\t *\n\t * @see {@link (TreeAlpha:interface).child}\n\t * @see {@link (TreeAlpha:interface).children}\n\t */\n\tparent(node: TreeNode): TreeNode | undefined;\n\n\t/**\n\t * The key of the given node under its parent.\n\t *\n\t * @remarks\n\t * If `node` is an element in a {@link (TreeArrayNode:interface)}, this returns the index of `node` in the array node (a `number`).\n\t * Otherwise, this returns the key of the field that it is under (a `string`).\n\t *\n\t * @throws A {@link @fluidframework/telemetry-utils#UsageError} if the node has been {@link TreeStatus.Deleted | deleted}.\n\t */\n\tkey(node: TreeNode): string | number;\n\n\t/**\n\t * Register an event listener on the given node.\n\t * @param node - The node whose events should be subscribed to.\n\t * @param eventName - Which event to subscribe to.\n\t * @param listener - The callback to trigger for the event. The tree can be read during the callback, but it is invalid to modify the tree during this callback.\n\t * @returns A callback function which will deregister the event.\n\t * This callback should be called only once.\n\t * @remarks\n\t * The returned unsubscribe function should be called any time the need for the `listener` callback ends before the node is {@link TreeStatus.Deleted | deleted} (Not just {@link TreeStatus.Removed | removed}).\n\t * Doing so removes the overhead of tracking and triggering the event, and also avoids leaking any memory retained by the callback.\n\t */\n\ton<K extends keyof TreeChangeEvents>(\n\t\tnode: TreeNode,\n\t\teventName: K,\n\t\tlistener: TreeChangeEvents[K],\n\t): () => void;\n\n\t/**\n\t * Returns the {@link TreeStatus} of the given node.\n\t */\n\tstatus(node: TreeNode): TreeStatus;\n\n\t/**\n\t * Returns the {@link SchemaFactory.identifier | identifier} of the given node in the most compressed form possible.\n\t * @remarks\n\t * If the node is {@link Unhydrated | hydrated}  and its identifier is a valid UUID that was automatically generated by the SharedTree it is part of (or something else using the same {@link @fluidframework/id-compressor#IIdCompressor}), then this will return a process-unique integer corresponding to that identifier.\n\t * This is useful for performance-sensitive scenarios involving many nodes with identifiers that need to be compactly retained in memory or used for efficient lookup.\n\t * Note that automatically generated identifiers that were accessed before the node was hydrated will return the generated UUID, not the process-unique integer.\n\t *\n\t * If the node's identifier is any other user-provided string, then this will return that string.\n\t *\n\t * If the node has no identifier (that is, it has no {@link SchemaFactory.identifier | identifier} field), then this returns `undefined`.\n\t *\n\t * If the node has more than one identifier, then this will throw an error.\n\t *\n\t * The returned integer should not be serialized or preserved outside of the current process.\n\t * Its lifetime is that of the current in-memory instance of the FF container for this client, and it is not guaranteed to be unique or stable outside of that context.\n\t * The same node's identifier may, for example, be different across multiple sessions for the same client and document, or different across two clients in the same session.\n\t */\n\tshortId(node: TreeNode): number | string | undefined;\n}\n\n/**\n * {@inheritDoc TreeNodeApi}\n */\nexport const treeNodeApi: TreeNodeApi = {\n\tparent(node: TreeNode): TreeNode | undefined {\n\t\tconst editNode = getInnerNode(node).parentField.parent.parent;\n\t\tif (editNode === undefined) {\n\t\t\treturn undefined;\n\t\t}\n\n\t\tconst output = getOrCreateNodeFromInnerNode(editNode);\n\t\tassert(\n\t\t\t!isTreeValue(output),\n\t\t\t0x87f /* Parent can't be a leaf, so it should be a node not a value */,\n\t\t);\n\t\treturn output;\n\t},\n\tkey(node: TreeNode): string | number {\n\t\t// If the parent is undefined, then this node is under the root field,\n\t\t// so we know its key is the special root one.\n\t\tconst parent = treeNodeApi.parent(node);\n\t\tif (parent === undefined) {\n\t\t\treturn rootFieldKey;\n\t\t}\n\n\t\t// The flex-domain strictly operates in terms of \"stored keys\".\n\t\t// To find the associated developer-facing \"property key\", we need to look up the field associated with\n\t\t// the stored key from the flex-domain, and get property key its simple-domain counterpart was created with.\n\t\tconst storedKey = getStoredKey(node);\n\t\tconst parentSchema = treeNodeApi.schema(parent);\n\t\tconst propertyKey = getPropertyKeyFromStoredKey(parentSchema, storedKey);\n\t\treturn propertyKey;\n\t},\n\ton<K extends keyof TreeChangeEvents>(\n\t\tnode: TreeNode,\n\t\teventName: K,\n\t\tlistener: TreeChangeEvents[K],\n\t): Off {\n\t\tconst kernel = getKernel(node);\n\t\tswitch (eventName) {\n\t\t\tcase \"nodeChanged\": {\n\t\t\t\tconst nodeSchema = kernel.schema;\n\t\t\t\tif (isObjectNodeSchema(nodeSchema)) {\n\t\t\t\t\treturn kernel.events.on(\"childrenChangedAfterBatch\", ({ changedFields }) => {\n\t\t\t\t\t\tconst changedProperties = new Set(\n\t\t\t\t\t\t\tArray.from(\n\t\t\t\t\t\t\t\tchangedFields,\n\t\t\t\t\t\t\t\t(field) =>\n\t\t\t\t\t\t\t\t\tnodeSchema.storedKeyToPropertyKey.get(field) ??\n\t\t\t\t\t\t\t\t\tfail(0xb36 /* Could not find stored key in schema. */),\n\t\t\t\t\t\t\t),\n\t\t\t\t\t\t);\n\t\t\t\t\t\tlistener({ changedProperties });\n\t\t\t\t\t});\n\t\t\t\t} else if (isArrayNodeSchema(nodeSchema)) {\n\t\t\t\t\treturn kernel.events.on(\"childrenChangedAfterBatch\", ({ fieldMarks }) => {\n\t\t\t\t\t\tconst marks = fieldMarks.get(EmptyKey);\n\t\t\t\t\t\t// nodeChanged fires only for shallow changes (insert, remove, move).\n\t\t\t\t\t\t// Deep changes (e.g. a property of an element changed) are\n\t\t\t\t\t\t// surfaced via TreeChangeEventsBeta.treeChanged with a delta payload instead.\n\t\t\t\t\t\t// When marks are undefined (marks could not be composed across multiple\n\t\t\t\t\t\t// internal passes), we conservatively fire nodeChanged rather than silently\n\t\t\t\t\t\t// dropping the event, even though the underlying change may have been\n\t\t\t\t\t\t// purely deep. This is a known limitation of the current eventing stack.\n\t\t\t\t\t\tconst hasShallowChange =\n\t\t\t\t\t\t\tmarks === undefined ||\n\t\t\t\t\t\t\tmarks.some((m) => m.attach !== undefined || m.detach !== undefined);\n\t\t\t\t\t\tif (!hasShallowChange) {\n\t\t\t\t\t\t\treturn;\n\t\t\t\t\t\t}\n\t\t\t\t\t\t// `marks` is undefined when the field was modified across multiple batches\n\t\t\t\t\t\t// within a single flush (e.g. due to an interleaved schema change) and the\n\t\t\t\t\t\t// marks could not be composed. Emit `undefined` so callers know the delta is\n\t\t\t\t\t\t// unavailable rather than receiving stale marks from only the first batch.\n\t\t\t\t\t\t// TODO: Once the eventing stack is rewritten to walk the composed delta at\n\t\t\t\t\t\t// flush time, `marks` will always be defined. Remove the `undefined` fallback.\n\t\t\t\t\t\tconst delta =\n\t\t\t\t\t\t\tmarks === undefined\n\t\t\t\t\t\t\t\t? undefined\n\t\t\t\t\t\t\t\t: deltaMarksToArrayOpsWithRetain(marks, getArrayLength(kernel), (count) => ({\n\t\t\t\t\t\t\t\t\t\ttype: \"retain\",\n\t\t\t\t\t\t\t\t\t\tcount,\n\t\t\t\t\t\t\t\t\t}));\n\t\t\t\t\t\tlistener({ delta });\n\t\t\t\t\t});\n\t\t\t\t} else {\n\t\t\t\t\treturn kernel.events.on(\"childrenChangedAfterBatch\", ({ changedFields }) => {\n\t\t\t\t\t\tlistener({ changedProperties: changedFields });\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t}\n\t\t\tcase \"treeChanged\": {\n\t\t\t\tif (isArrayNodeSchema(kernel.schema)) {\n\t\t\t\t\t// For array nodes, treeChanged fires via childrenChangedAfterBatch so that a\n\t\t\t\t\t// delta payload can be provided. This covers both shallow changes\n\t\t\t\t\t// (insert/remove/move) and deep element changes. Stable (non-alpha) listeners\n\t\t\t\t\t// typed as () => void will silently ignore the extra argument at runtime.\n\t\t\t\t\treturn kernel.events.on(\"childrenChangedAfterBatch\", ({ fieldMarks }) => {\n\t\t\t\t\t\tconst marks = fieldMarks.get(EmptyKey);\n\t\t\t\t\t\tconst delta =\n\t\t\t\t\t\t\tmarks === undefined\n\t\t\t\t\t\t\t\t? undefined\n\t\t\t\t\t\t\t\t: deltaMarksToArrayOpsWithRetain(\n\t\t\t\t\t\t\t\t\t\tmarks,\n\t\t\t\t\t\t\t\t\t\tgetArrayLength(kernel),\n\t\t\t\t\t\t\t\t\t\t(count, subtreeChanged) => ({\n\t\t\t\t\t\t\t\t\t\t\ttype: \"retain\",\n\t\t\t\t\t\t\t\t\t\t\tcount,\n\t\t\t\t\t\t\t\t\t\t\tsubtreeChanged,\n\t\t\t\t\t\t\t\t\t\t}),\n\t\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t(listener as (data: { readonly delta: typeof delta }) => void)({ delta });\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t\treturn kernel.events.on(\"subtreeChangedAfterBatch\", () => listener({}));\n\t\t\t}\n\t\t\tdefault: {\n\t\t\t\tthrow new UsageError(`No event named ${JSON.stringify(eventName)}.`);\n\t\t\t}\n\t\t}\n\t},\n\tstatus(node: TreeNode): TreeStatus {\n\t\treturn getKernel(node).getStatus();\n\t},\n\tis<TSchema extends ImplicitAllowedTypes>(\n\t\tvalue: unknown,\n\t\tschema: TSchema,\n\t): value is TreeNodeFromImplicitAllowedTypes<TSchema> {\n\t\t// This \"is\" utility would return false if the provided schema is a base type of the actual schema.\n\t\t// This could be confusing, and that case can only be hit when violating the rule that there is a single most derived schema that gets used (See documentation on TreeNodeSchemaClass).\n\t\t// Therefore this uses markSchemaMostDerived to ensure an informative usage error is thrown in the case where a base type is used.\n\n\t\tconst actualSchema = tryGetSchema(value);\n\t\tif (actualSchema === undefined) {\n\t\t\treturn false;\n\t\t}\n\t\treturn normalizeAllowedTypes(schema).evaluateSet().has(actualSchema);\n\t},\n\tschema(node: TreeNode | TreeLeafValue): TreeNodeSchema {\n\t\treturn tryGetSchema(node) ?? fail(0xb37 /* Not a tree node */);\n\t},\n\tshortId(node: TreeNode): number | string | undefined {\n\t\treturn getIdentifierFromNode(node, \"preferCompressed\");\n\t},\n};\n\n/**\n * Converts internal {@link DeltaMark}s for an array's sequence field into sequential array delta\n * operations.\n *\n * @remarks\n * Each mark describes a contiguous run:\n * - A mark with only `count` becomes a retain.\n * - A mark with only `attach` becomes an insert.\n * - A mark with only `detach` becomes a remove.\n * - A mark with both `attach` and `detach` becomes a remove followed by an insert.\n *\n * Internal mark arrays may omit an unchanged suffix. The returned operations always cover the\n * complete array, so this function uses the array's post-edit length to append a trailing retain\n * when needed.\n *\n * @param marks - The low-level delta marks for the array's sequence field.\n * @param postEditLength - The array's length after the edit.\n * @param buildRetainOp - Builds a retain operation. Its second argument indicates whether the\n * retained element's subtree changed; it is `false` for a synthesized trailing retain.\n *\n * @privateRemarks\n * The case where both `attach` and `detach` are set is unreachable today: the sequence-field\n * encoder never emits such marks for array (`EmptyKey`) fields. It is handled defensively.\n */\nexport function deltaMarksToArrayOpsWithRetain<TRetain extends ArrayNodeRetainOp>(\n\tmarks: readonly DeltaMark[],\n\tpostEditLength: number,\n\tbuildRetainOp: (count: number, subtreeChanged: boolean) => TRetain,\n): (TRetain | ArrayNodeInsertOp | ArrayNodeRemoveOp)[] {\n\tconst ops: (TRetain | ArrayNodeInsertOp | ArrayNodeRemoveOp)[] = [];\n\tlet processedLength = 0;\n\tfor (const mark of marks) {\n\t\tif (mark.detach !== undefined) {\n\t\t\tops.push({ type: \"remove\", count: mark.count });\n\t\t}\n\t\tif (mark.attach !== undefined) {\n\t\t\tops.push({ type: \"insert\", count: mark.count });\n\t\t\tprocessedLength += mark.count;\n\t\t} else if (mark.detach === undefined) {\n\t\t\t// When `fields` is set, `count` is guaranteed to be 1 (DeltaMark invariant).\n\t\t\tops.push(buildRetainOp(mark.count, mark.fields !== undefined));\n\t\t\tprocessedLength += mark.count;\n\t\t}\n\t}\n\t// DeltaMark arrays are allowed to omit the trailing retain, while our user facing array equivalents are not, so add it if necessary.\n\tassert(\n\t\tprocessedLength <= postEditLength,\n\t\t0xd19 /* Array delta exceeds post-edit array length */,\n\t);\n\tif (processedLength < postEditLength) {\n\t\tops.push(buildRetainOp(postEditLength - processedLength, false));\n\t}\n\treturn ops;\n}\n\n/**\n * Returns the length of the `EmptyKey` field under the provided node kernel.\n * @remarks\n * Use this with the kernel of an array node to get the current length of the array.\n * This is the same as `.length` on the array node, but is usable without having to get (and possible create) the node and narrow to the proper type to access that.\n */\nfunction getArrayLength(arrayNodeKernel: TreeNodeKernel): number {\n\treturn arrayNodeKernel.getInnerNode().getBoxed(EmptyKey).length;\n}\n\n/**\n * Returns a schema for a value if the value is a {@link TreeNode} or a {@link TreeLeafValue}.\n * Returns undefined for other values.\n */\nexport function tryGetSchema(value: unknown): undefined | TreeNodeSchema {\n\tswitch (typeof value) {\n\t\tcase \"string\": {\n\t\t\treturn stringSchema;\n\t\t}\n\t\tcase \"number\": {\n\t\t\treturn numberSchema;\n\t\t}\n\t\tcase \"boolean\": {\n\t\t\treturn booleanSchema;\n\t\t}\n\t\tcase \"object\": {\n\t\t\tif (isTreeNode(value)) {\n\t\t\t\t// TODO: This case could be optimized, for example by placing the simple schema in a symbol on tree nodes.\n\t\t\t\treturn tryGetTreeNodeSchema(value);\n\t\t\t}\n\t\t\tif (value === null) {\n\t\t\t\treturn nullSchema;\n\t\t\t}\n\t\t\tif (isFluidHandle(value)) {\n\t\t\t\treturn handleSchema;\n\t\t\t}\n\t\t}\n\t\tdefault: {\n\t\t\treturn undefined;\n\t\t}\n\t}\n}\n\n/**\n * Gets the identifier from a node.\n *\n * @param node - {@link TreeNode} where you want to extract the identifier from.\n * @param compression - string value to determine what type of identifier you want to retrieve.\n *\n * @remarks\n * If the node does not contain an identifier field, it returns undefined.\n *\n * If `compression` is set to `compressed`:\n *\n * - If the node contains a compressible identifier known by the id compressor, the compressed identifier is returned.\n *\n * - If the node contains an identifier, but is not compressible or unknown by the id compressor, `undefined` is returned.\n *\n * If `compression` is set to `preferCompressed`:\n *\n * - If the node contains a compressible identifier known by the id compressor, the compressed identifier is returned.\n *\n * - If the node contains an identifier, but is not compressible or unknown by the id compressor, the uncompressed identifier is returned.\n *\n * If `compression` is set to `uncompressed`:\n * - If the node contains an identifier field, the uncompressed identifier is returned.\n */\nexport function getIdentifierFromNode(\n\tnode: TreeNode,\n\tcompression: \"preferCompressed\",\n): number | string | undefined;\nexport function getIdentifierFromNode(\n\tnode: TreeNode,\n\tcompression: \"compressed\",\n): number | undefined;\nexport function getIdentifierFromNode(\n\tnode: TreeNode,\n\tcompression: \"uncompressed\",\n): string | undefined;\nexport function getIdentifierFromNode(\n\tnode: TreeNode,\n\tcompression: \"preferCompressed\" | \"compressed\" | \"uncompressed\",\n): number | string | undefined {\n\tconst schema = node[typeSchemaSymbol];\n\tif (!isObjectNodeSchema(schema)) {\n\t\treturn undefined;\n\t}\n\n\tconst flexNode = getInnerNode(node);\n\tconst identifierFieldKeys = schema.identifierFieldKeys;\n\n\tswitch (identifierFieldKeys.length) {\n\t\tcase 0: {\n\t\t\treturn undefined;\n\t\t}\n\t\tcase 1: {\n\t\t\tconst key = identifierFieldKeys[0] ?? oob();\n\t\t\tconst identifierField = flexNode.tryGetField(key);\n\t\t\tassert(identifierField !== undefined, 0xbb5 /* missing identifier field */);\n\t\t\tconst identifierValue = tryGetTreeNodeForField(identifierField);\n\t\t\tassert(typeof identifierValue === \"string\", 0xbb6 /* identifier not a string */);\n\n\t\t\tconst context = flexNode.context;\n\t\t\tswitch (compression) {\n\t\t\t\tcase \"preferCompressed\": {\n\t\t\t\t\tif (context.isHydrated()) {\n\t\t\t\t\t\tconst localNodeKey =\n\t\t\t\t\t\t\tcontext.nodeKeyManager.tryLocalizeNodeIdentifier(identifierValue);\n\t\t\t\t\t\treturn localNodeKey === undefined\n\t\t\t\t\t\t\t? identifierValue\n\t\t\t\t\t\t\t: extractFromOpaque(localNodeKey);\n\t\t\t\t\t} else {\n\t\t\t\t\t\treturn identifierValue;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tcase \"compressed\": {\n\t\t\t\t\tif (context.isHydrated()) {\n\t\t\t\t\t\tconst localNodeKey =\n\t\t\t\t\t\t\tcontext.nodeKeyManager.tryLocalizeNodeIdentifier(identifierValue);\n\t\t\t\t\t\treturn localNodeKey === undefined ? undefined : extractFromOpaque(localNodeKey);\n\t\t\t\t\t} else {\n\t\t\t\t\t\treturn undefined;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tcase \"uncompressed\": {\n\t\t\t\t\treturn identifierValue;\n\t\t\t\t}\n\t\t\t\tdefault: {\n\t\t\t\t\tunreachableCase(compression);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tdefault: {\n\t\t\tthrow new UsageError(\n\t\t\t\t\"The node has more than one identifier. Retrieve identifiers individually via their fields instead.\",\n\t\t\t);\n\t\t}\n\t}\n}\n\n/**\n * Gets the stored key with which the provided node is associated in the parent.\n */\nexport function getStoredKey(node: TreeNode): string | number {\n\t// Note: the flex domain strictly works with \"stored keys\", and knows nothing about the developer-facing\n\t// \"property keys\".\n\tconst parentField = getInnerNode(node).parentField;\n\tif (parentField.parent.schema === FieldKinds.sequence.identifier) {\n\t\t// The parent of `node` is an array node\n\t\tassert(\n\t\t\tparentField.parent.key === EmptyKey,\n\t\t\t0xa28 /* When using index as key, field should use EmptyKey */,\n\t\t);\n\t\treturn parentField.index;\n\t}\n\n\t// The parent of `node` is an object, a map, or undefined. If undefined, then `node` is a root/detached node.\n\tassert(parentField.index === 0, 0xa29 /* When using field key as key, index should be 0 */);\n\treturn parentField.parent.key;\n}\n\n/**\n * Given a node schema, gets the property key corresponding with the provided {@link FieldProps.key | stored key}.\n */\nexport function getPropertyKeyFromStoredKey(\n\tschema: TreeNodeSchema,\n\tstoredKey: string | number,\n): string | number {\n\t// Only object nodes have the concept of a \"stored key\", differentiated from the developer-facing \"property key\".\n\t// For any other kind of node, the stored key and the property key are the same.\n\tif (schema.kind !== NodeKind.Object) {\n\t\treturn storedKey;\n\t}\n\n\tconst fields = schema.info as Record<string, ImplicitFieldSchema>;\n\n\t// Invariants:\n\t// - The set of all property keys under an object must be unique.\n\t// - The set of all stored keys (including those implicitly created from property keys) must be unique.\n\t// To find the property key associated with the provided stored key, first check for any stored key matches (which are optionally populated).\n\t// If we don't find any, then search for a matching property key.\n\tfor (const [propertyKey, fieldSchema] of Object.entries(fields)) {\n\t\tif (fieldSchema instanceof FieldSchema && fieldSchema.props?.key === storedKey) {\n\t\t\treturn propertyKey;\n\t\t}\n\t}\n\n\tif (fields[storedKey] === undefined) {\n\t\tfail(0xb38 /* Existing stored key should always map to a property key */);\n\t}\n\n\treturn storedKey;\n}\n"]}