@fluidframework/tree 2.0.0-dev-rc.1.0.0.224419

package/dist/feature-libraries/flex-tree/navigation.js

@@ -0,0 +1,104 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.visitBipartiteIterableTreeWithState = exports.visitBipartiteIterableTree = exports.visitIterableTreeWithState = exports.visitIterableTree = exports.Skip = void 0;
+exports.Skip = Symbol("Skip");
+/**
+ * Visit iterable tree.
+ *
+ * @remarks
+ * Non-recursive depth first traversal.
+ */
+function visitIterableTree(root, iterator, visitor) {
+    const queue = [[root]];
+    let next;
+    while ((next = queue.pop())) {
+        for (const child of next) {
+            if (visitor(child) !== exports.Skip) {
+                queue.push(iterator(child));
+            }
+        }
+    }
+}
+exports.visitIterableTree = visitIterableTree;
+/**
+ * Visit iterable tree.
+ * Allows state to be computed in parents and passed to children.
+ *
+ * @remarks
+ * Non-recursive depth first traversal.
+ */
+function visitIterableTreeWithState(root, initial, visitor) {
+    const queue = [[initial, root]];
+    let next;
+    while ((next = queue.pop())) {
+        const [state, nestItem] = next;
+        for (const child of nestItem) {
+            const result = visitor(child, state);
+            if (result !== exports.Skip) {
+                queue.push([result, child]);
+            }
+        }
+    }
+}
+exports.visitIterableTreeWithState = visitIterableTreeWithState;
+/**
+ * Visit bipartite iterable tree.
+ *
+ * @remarks
+ * Non-recursive depth first traversal.
+ *
+ * Particularly useful for processing trees with their alternating node and field levels.
+ */
+function visitBipartiteIterableTree(root, visitorA, visitorB) {
+    const queueA = [root];
+    let nextA;
+    while ((nextA = queueA.pop())) {
+        if (visitorA(nextA) !== exports.Skip) {
+            for (const nextB of nextA) {
+                if (visitorB(nextB) !== exports.Skip) {
+                    for (const child of nextB) {
+                        queueA.push(child);
+                    }
+                }
+            }
+        }
+    }
+}
+exports.visitBipartiteIterableTree = visitBipartiteIterableTree;
+/**
+ * Visit bipartite iterable tree.
+ * Allows state to be computed in parents and passed to children.
+ *
+ * @remarks
+ * Non-recursive depth first traversal.
+ *
+ * Particularly useful for processing trees with their alternating node and field levels.
+ *
+ * @privateRemarks
+ * Other traversal cases, like ones passing data up (via map or reduce patterns) could be supported by extending this or adding more utilities.
+ * Such utility functions really only provide an improvement of hand coding each cases if the non-recessiveness is required.
+ * Since supporting very deeps trees hasn't been a priority, such visitors are also not a priority, and are thus not included here for now.
+ */
+function visitBipartiteIterableTreeWithState(root, fromAbove, iterateA, iterateB, visitorA, visitorB) {
+    const queueA = [[root, fromAbove]];
+    let next;
+    while ((next = queueA.pop())) {
+        const result = visitorA(...next);
+        if (result !== exports.Skip) {
+            for (const nextB of iterateA(next[0])) {
+                const resultB = visitorB(nextB, result);
+                if (resultB !== exports.Skip) {
+                    for (const child of iterateB(nextB)) {
+                        queueA.push([child, resultB]);
+                    }
+                }
+            }
+        }
+    }
+}
+exports.visitBipartiteIterableTreeWithState = visitBipartiteIterableTreeWithState;
+//# sourceMappingURL=navigation.js.map

package/dist/feature-libraries/flex-tree/navigation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"navigation.js","sourceRoot":"","sources":["../../../src/feature-libraries/flex-tree/navigation.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEU,QAAA,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;AAGnC;;;;;GAKG;AACH,SAAgB,iBAAiB,CAChC,IAAO,EACP,QAA+B,EAC/B,OAAiC;IAEjC,MAAM,KAAK,GAAkB,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;IACtC,IAAI,IAA6B,CAAC;IAClC,OAAO,CAAC,IAAI,GAAG,KAAK,CAAC,GAAG,EAAE,CAAC,EAAE;QAC5B,KAAK,MAAM,KAAK,IAAI,IAAI,EAAE;YACzB,IAAI,OAAO,CAAC,KAAK,CAAC,KAAK,YAAI,EAAE;gBAC5B,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC;aAC5B;SACD;KACD;AACF,CAAC;AAdD,8CAcC;AAED;;;;;;GAMG;AACH,SAAgB,0BAA0B,CACzC,IAAO,EACP,OAAwB,EACxB,OAAwE;IAExE,MAAM,KAAK,GAAqC,CAAC,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC;IAClE,IAAI,IAAgD,CAAC;IACrD,OAAO,CAAC,IAAI,GAAG,KAAK,CAAC,GAAG,EAAE,CAAC,EAAE;QAC5B,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAC,GAAG,IAAI,CAAC;QAC/B,KAAK,MAAM,KAAK,IAAI,QAAQ,EAAE;YAC7B,MAAM,MAAM,GAAG,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;YACrC,IAAI,MAAM,KAAK,YAAI,EAAE;gBACpB,KAAK,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC;aAC5B;SACD;KACD;AACF,CAAC;AAhBD,gEAgBC;AAED;;;;;;;GAOG;AACH,SAAgB,0BAA0B,CACzC,IAAO,EACP,QAAuC,EACvC,QAAuC;IAEvC,MAAM,MAAM,GAAG,CAAC,IAAI,CAAC,CAAC;IACtB,IAAI,KAAoB,CAAC;IACzB,OAAO,CAAC,KAAK,GAAG,MAAM,CAAC,GAAG,EAAE,CAAC,EAAE;QAC9B,IAAI,QAAQ,CAAC,KAAK,CAAC,KAAK,YAAI,EAAE;YAC7B,KAAK,MAAM,KAAK,IAAI,KAAK,EAAE;gBAC1B,IAAI,QAAQ,CAAC,KAAK,CAAC,KAAK,YAAI,EAAE;oBAC7B,KAAK,MAAM,KAAK,IAAI,KAAK,EAAE;wBAC1B,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;qBACnB;iBACD;aACD;SACD;KACD;AACF,CAAC;AAlBD,gEAkBC;AAED;;;;;;;;;;;;;GAaG;AACH,SAAgB,mCAAmC,CAClD,IAAO,EACP,SAAiB,EACjB,QAA+B,EAC/B,QAA+B,EAC/B,QAAuD,EACvD,QAAuD;IAEvD,MAAM,MAAM,GAAkB,CAAC,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC;IAClD,IAAI,IAA6B,CAAC;IAClC,OAAO,CAAC,IAAI,GAAG,MAAM,CAAC,GAAG,EAAE,CAAC,EAAE;QAC7B,MAAM,MAAM,GAAG,QAAQ,CAAC,GAAG,IAAI,CAAC,CAAC;QACjC,IAAI,MAAM,KAAK,YAAI,EAAE;YACpB,KAAK,MAAM,KAAK,IAAI,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE;gBACtC,MAAM,OAAO,GAAG,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;gBACxC,IAAI,OAAO,KAAK,YAAI,EAAE;oBACrB,KAAK,MAAM,KAAK,IAAI,QAAQ,CAAC,KAAK,CAAC,EAAE;wBACpC,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC;qBAC9B;iBACD;aACD;SACD;KACD;AACF,CAAC;AAvBD,kFAuBC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nexport const Skip = Symbol(\"Skip\");\nexport type Skip = typeof Skip;\n\n/**\n * Visit iterable tree.\n *\n * @remarks\n * Non-recursive depth first traversal.\n */\nexport function visitIterableTree<T>(\n\troot: T,\n\titerator: (t: T) => Iterable<T>,\n\tvisitor: (item: T) => Skip | void,\n): void {\n\tconst queue: Iterable<T>[] = [[root]];\n\tlet next: Iterable<T> | undefined;\n\twhile ((next = queue.pop())) {\n\t\tfor (const child of next) {\n\t\t\tif (visitor(child) !== Skip) {\n\t\t\t\tqueue.push(iterator(child));\n\t\t\t}\n\t\t}\n\t}\n}\n\n/**\n * Visit iterable tree.\n * Allows state to be computed in parents and passed to children.\n *\n * @remarks\n * Non-recursive depth first traversal.\n */\nexport function visitIterableTreeWithState<T extends Iterable<T>, StatePassedDown>(\n\troot: T,\n\tinitial: StatePassedDown,\n\tvisitor: (item: T, fromAbove: StatePassedDown) => Skip | StatePassedDown,\n): void {\n\tconst queue: [StatePassedDown, Iterable<T>][] = [[initial, root]];\n\tlet next: [StatePassedDown, Iterable<T>] | undefined;\n\twhile ((next = queue.pop())) {\n\t\tconst [state, nestItem] = next;\n\t\tfor (const child of nestItem) {\n\t\t\tconst result = visitor(child, state);\n\t\t\tif (result !== Skip) {\n\t\t\t\tqueue.push([result, child]);\n\t\t\t}\n\t\t}\n\t}\n}\n\n/**\n * Visit bipartite iterable tree.\n *\n * @remarks\n * Non-recursive depth first traversal.\n *\n * Particularly useful for processing trees with their alternating node and field levels.\n */\nexport function visitBipartiteIterableTree<A extends Iterable<B>, B extends Iterable<A>>(\n\troot: A,\n\tvisitorA: (item: A) => Skip | undefined,\n\tvisitorB: (item: B) => Skip | undefined,\n) {\n\tconst queueA = [root];\n\tlet nextA: A | undefined;\n\twhile ((nextA = queueA.pop())) {\n\t\tif (visitorA(nextA) !== Skip) {\n\t\t\tfor (const nextB of nextA) {\n\t\t\t\tif (visitorB(nextB) !== Skip) {\n\t\t\t\t\tfor (const child of nextB) {\n\t\t\t\t\t\tqueueA.push(child);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}\n\n/**\n * Visit bipartite iterable tree.\n * Allows state to be computed in parents and passed to children.\n *\n * @remarks\n * Non-recursive depth first traversal.\n *\n * Particularly useful for processing trees with their alternating node and field levels.\n *\n * @privateRemarks\n * Other traversal cases, like ones passing data up (via map or reduce patterns) could be supported by extending this or adding more utilities.\n * Such utility functions really only provide an improvement of hand coding each cases if the non-recessiveness is required.\n * Since supporting very deeps trees hasn't been a priority, such visitors are also not a priority, and are thus not included here for now.\n */\nexport function visitBipartiteIterableTreeWithState<A, B, StateA, StateB>(\n\troot: A,\n\tfromAbove: StateA,\n\titerateA: (a: A) => Iterable<B>,\n\titerateB: (b: B) => Iterable<A>,\n\tvisitorA: (item: A, fromAbove: StateA) => Skip | StateB,\n\tvisitorB: (item: B, fromAbove: StateB) => Skip | StateA,\n) {\n\tconst queueA: [A, StateA][] = [[root, fromAbove]];\n\tlet next: [A, StateA] | undefined;\n\twhile ((next = queueA.pop())) {\n\t\tconst result = visitorA(...next);\n\t\tif (result !== Skip) {\n\t\t\tfor (const nextB of iterateA(next[0])) {\n\t\t\t\tconst resultB = visitorB(nextB, result);\n\t\t\t\tif (resultB !== Skip) {\n\t\t\t\t\tfor (const child of iterateB(nextB)) {\n\t\t\t\t\t\tqueueA.push([child, resultB]);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}\n"]}

package/dist/feature-libraries/flex-tree/nodeKeys.d.ts

@@ -0,0 +1,42 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { LocalNodeKey, NodeKeyIndex, NodeKeyManager, StableNodeKey } from "../node-key";
+import { FlexTreeObjectNode } from "./flexTreeTypes";
+/**
+ * A collection of utilities for managing {@link StableNodeKey}s.
+ * A node key can be assigned to a node and allows that node to be easily retrieved from the tree at a later time. (see `nodeKey.map`).
+ * @remarks {@link LocalNodeKey}s are put on {@link FlexTreeObjectNode}s via a special field.
+ * A node with a node key in its schema must always have a node key.
+ * @internal
+ */
+export interface NodeKeys {
+    /**
+     * Create a new {@link LocalNodeKey} which can be used as the key for a node in the tree.
+     */
+    generate(): LocalNodeKey;
+    /**
+     * Convert the given {@link LocalNodeKey} into a UUID that can be serialized.
+     * @param key - the key to convert
+     */
+    stabilize(key: LocalNodeKey): StableNodeKey;
+    /**
+     * Convert a {@link StableNodeKey} back into its {@link LocalNodeKey} form.
+     * @param key - the key to convert
+     */
+    localize(key: StableNodeKey): LocalNodeKey;
+    /**
+     * A map of all {@link LocalNodeKey}s in the document to their corresponding nodes.
+     */
+    readonly map: ReadonlyMap<LocalNodeKey, FlexTreeObjectNode>;
+}
+export declare class SimpleNodeKeys implements NodeKeys {
+    readonly map: NodeKeyIndex;
+    private readonly manager;
+    constructor(map: NodeKeyIndex, manager: NodeKeyManager);
+    generate(): LocalNodeKey;
+    stabilize(key: LocalNodeKey): StableNodeKey;
+    localize(key: StableNodeKey): LocalNodeKey;
+}
+//# sourceMappingURL=nodeKeys.d.ts.map

package/dist/feature-libraries/flex-tree/nodeKeys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodeKeys.d.ts","sourceRoot":"","sources":["../../../src/feature-libraries/flex-tree/nodeKeys.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACxF,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAErD;;;;;;GAMG;AACH,MAAM,WAAW,QAAQ;IACxB;;OAEG;IACH,QAAQ,IAAI,YAAY,CAAC;IACzB;;;OAGG;IACH,SAAS,CAAC,GAAG,EAAE,YAAY,GAAG,aAAa,CAAC;IAC5C;;;OAGG;IACH,QAAQ,CAAC,GAAG,EAAE,aAAa,GAAG,YAAY,CAAC;IAC3C;;OAEG;IACH,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAC,YAAY,EAAE,kBAAkB,CAAC,CAAC;CAC5D;AAED,qBAAa,cAAe,YAAW,QAAQ;aAE7B,GAAG,EAAE,YAAY;IACjC,OAAO,CAAC,QAAQ,CAAC,OAAO;gBADR,GAAG,EAAE,YAAY,EAChB,OAAO,EAAE,cAAc;IAElC,QAAQ,IAAI,YAAY;IAGxB,SAAS,CAAC,GAAG,EAAE,YAAY,GAAG,aAAa;IAG3C,QAAQ,CAAC,GAAG,EAAE,aAAa,GAAG,YAAY;CAGjD"}

package/dist/feature-libraries/flex-tree/nodeKeys.js

@@ -0,0 +1,24 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleNodeKeys = void 0;
+class SimpleNodeKeys {
+    constructor(map, manager) {
+        this.map = map;
+        this.manager = manager;
+    }
+    generate() {
+        return this.manager.generateLocalNodeKey();
+    }
+    stabilize(key) {
+        return this.manager.stabilizeNodeKey(key);
+    }
+    localize(key) {
+        return this.manager.localizeNodeKey(key);
+    }
+}
+exports.SimpleNodeKeys = SimpleNodeKeys;
+//# sourceMappingURL=nodeKeys.js.map

package/dist/feature-libraries/flex-tree/nodeKeys.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodeKeys.js","sourceRoot":"","sources":["../../../src/feature-libraries/flex-tree/nodeKeys.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAiCH,MAAa,cAAc;IAC1B,YACiB,GAAiB,EAChB,OAAuB;QADxB,QAAG,GAAH,GAAG,CAAc;QAChB,YAAO,GAAP,OAAO,CAAgB;IACtC,CAAC;IACG,QAAQ;QACd,OAAO,IAAI,CAAC,OAAO,CAAC,oBAAoB,EAAE,CAAC;IAC5C,CAAC;IACM,SAAS,CAAC,GAAiB;QACjC,OAAO,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;IAC3C,CAAC;IACM,QAAQ,CAAC,GAAkB;QACjC,OAAO,IAAI,CAAC,OAAO,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC;IAC1C,CAAC;CACD;AAdD,wCAcC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { LocalNodeKey, NodeKeyIndex, NodeKeyManager, StableNodeKey } from \"../node-key\";\nimport { FlexTreeObjectNode } from \"./flexTreeTypes\";\n\n/**\n * A collection of utilities for managing {@link StableNodeKey}s.\n * A node key can be assigned to a node and allows that node to be easily retrieved from the tree at a later time. (see `nodeKey.map`).\n * @remarks {@link LocalNodeKey}s are put on {@link FlexTreeObjectNode}s via a special field.\n * A node with a node key in its schema must always have a node key.\n * @internal\n */\nexport interface NodeKeys {\n\t/**\n\t * Create a new {@link LocalNodeKey} which can be used as the key for a node in the tree.\n\t */\n\tgenerate(): LocalNodeKey;\n\t/**\n\t * Convert the given {@link LocalNodeKey} into a UUID that can be serialized.\n\t * @param key - the key to convert\n\t */\n\tstabilize(key: LocalNodeKey): StableNodeKey;\n\t/**\n\t * Convert a {@link StableNodeKey} back into its {@link LocalNodeKey} form.\n\t * @param key - the key to convert\n\t */\n\tlocalize(key: StableNodeKey): LocalNodeKey;\n\t/**\n\t * A map of all {@link LocalNodeKey}s in the document to their corresponding nodes.\n\t */\n\treadonly map: ReadonlyMap<LocalNodeKey, FlexTreeObjectNode>;\n}\n\nexport class SimpleNodeKeys implements NodeKeys {\n\tpublic constructor(\n\t\tpublic readonly map: NodeKeyIndex,\n\t\tprivate readonly manager: NodeKeyManager,\n\t) {}\n\tpublic generate(): LocalNodeKey {\n\t\treturn this.manager.generateLocalNodeKey();\n\t}\n\tpublic stabilize(key: LocalNodeKey): StableNodeKey {\n\t\treturn this.manager.stabilizeNodeKey(key);\n\t}\n\tpublic localize(key: StableNodeKey): LocalNodeKey {\n\t\treturn this.manager.localizeNodeKey(key);\n\t}\n}\n"]}

package/dist/feature-libraries/flex-tree/treeEvents.d.ts

@@ -0,0 +1,111 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { UpPath, PathVisitor } from "../../core";
+import { FlexTreeNode } from "./flexTreeTypes";
+/**
+ * This file provides an API for working with trees which is type safe even when schema is not known.
+ * This means no editing is allowed.
+ *
+ * Schema aware APIs for working with trees should superset this, while sub-setting EditableTree.
+ *
+ * TODO:
+ * This API should replace EditableTree as the default public API for tree access.
+ * SchemaAware builds on this, adding editing and type safe APIs which can be accessed via SchematizeView.
+ * Once this is finished, the unsafe EditableTree types can be removed (or converted to package internal documentation for the proxies).
+ */
+/**
+ * An event raised on a {@link FlexTreeNode}.
+ *
+ * @internal
+ */
+export interface TreeEvent {
+    /**
+     * The node of the tree where the listener receiving the event is attached.
+     */
+    readonly target: FlexTreeNode;
+}
+/**
+ * A collection of events that can be raised by a {@link FlexTreeNode}.
+ * These events are triggered while the internal data structures are being updated.
+ * Thus these events must not trigger reading of the anchorSet or forest.
+ *
+ * TODO:
+ * - Design how events should be ordered.
+ * - Include sub-deltas in events.
+ * - Add more events.
+ * - Have some events (or a way to defer events) until the tree can be read.
+ *
+ * @internal
+ */
+export interface EditableTreeEvents {
+    /**
+     * Raised when a specific EditableTree node is changing.
+     * This includes its fields.
+     * @param upPath - the path corresponding to the location of the node being changed, upward.
+     */
+    changing(upPath: UpPath): void;
+    /**
+     * Raised when something in the tree is changing, including this node and its descendants.
+     * The event can optionally return a {@link PathVisitor} to traverse the subtree
+     * This event is called on every parent (transitively) when a change is occurring.
+     * Includes changes to this node itself.
+     * @param upPath - the path corresponding to the location of the node being changed, upward.
+     * @returns a visitor to traverse the subtree or `void`.
+     */
+    subtreeChanging(upPath: UpPath): PathVisitor | void;
+    /**
+     * Raised on a node right before a change is applied to one of its fields or the fields of a descendant node.
+     *
+     * @param event - The event object. See {@link TreeEvent} for details.
+     *
+     * @remarks
+     * What exactly qualifies as a change that triggers this event (or {@link EditableTreeEvents.afterChange}) is dependent
+     * on the implementation of SharedTree. In general, these events will fire once for every atomic editing operation
+     * supported by SharedTree; {@link EditableTreeEvents.beforeChange} before the change is applied, and
+     * {@link EditableTreeEvents.afterChange} after it is.
+     *
+     * {@link FieldKinds.sequence} fields present two exceptions:
+     *
+     * The first one is that events will fire separately for each node involved in the operation (when inserting, removing,
+     * or moving more than one node at a time). This means that, for example, when inserting two nodes into a {@link FieldKinds.sequence}
+     * field the following will happen:
+     * - {@link EditableTreeEvents.beforeChange} will fire once before either new node is present in the tree.
+     * - {@link EditableTreeEvents.afterChange} will fire once after the first node is present in the tree, but the second one isn't.
+     * - {@link EditableTreeEvents.beforeChange} will fire once before the second node is present in the tree, but the first one already is.
+     * - {@link EditableTreeEvents.afterChange} will fire once after the second node is present in the tree (so at this point both nodes are).
+     * Something similar applies to removing nodes from a sequence, and moving them to another sequence.
+     *
+     * The second one is that for an operation to move nodes, events will fire *twice* for each node being moved; once
+     * while they are being detached from their source location, and once when they are being attached at the target location.
+     */
+    beforeChange(event: TreeEvent): void;
+    /**
+     * Raised on a node right after a change is applied to one of its fields or the fields of a descendant node.
+     *
+     * @param event - The event object. See {@link TreeEvent} for details.
+     *
+     * @remarks
+     * What exactly qualifies as a change that triggers this event (or {@link EditableTreeEvents.beforeChange}) is dependent
+     * on the implementation of SharedTree. In general, these events will fire once for every atomic editing operation supported
+     * by SharedTree; {@link EditableTreeEvents.beforeChange} before the change is applied, and
+     * {@link EditableTreeEvents.afterChange} after it is.
+     *
+     * {@link FieldKinds.sequence} present two exceptions:
+     *
+     * The first one is that events will fire separately for each node involved in the operation (when inserting, removing,
+     * or moving more than one node at a time). This means that, for example, when inserting two nodes into a {@link FieldKinds.sequence}
+     * field the following will happen:
+     * - {@link EditableTreeEvents.beforeChange} will fire once before either new node is present in the tree.
+     * - {@link EditableTreeEvents.afterChange} will fire once after the first node is present in the tree, but the second one isn't.
+     * - {@link EditableTreeEvents.beforeChange} will fire once before the second node is present in the tree, but the first one already is.
+     * - {@link EditableTreeEvents.afterChange} will fire once after the second node is present in the tree (so at this point both nodes are).
+     * Something similar applies to removing nodes from a sequence, and moving them to another sequence.
+     *
+     * The second one is that for an operation to move nodes, events will fire *twice* for each node being moved; once
+     * while they are being detached from their source location, and once when they are being attached at the target location.
+     */
+    afterChange(event: TreeEvent): void;
+}
+//# sourceMappingURL=treeEvents.d.ts.map

package/dist/feature-libraries/flex-tree/treeEvents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"treeEvents.d.ts","sourceRoot":"","sources":["../../../src/feature-libraries/flex-tree/treeEvents.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACjD,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAE/C;;;;;;;;;;GAUG;AAEH;;;;GAIG;AACH,MAAM,WAAW,SAAS;IACzB;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;CAC9B;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,kBAAkB;IAClC;;;;OAIG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAE/B;;;;;;;OAOG;IACH,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAAC;IAEpD;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,YAAY,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI,CAAC;IAErC;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,WAAW,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI,CAAC;CACpC"}

package/dist/feature-libraries/flex-tree/treeEvents.js

@@ -0,0 +1,7 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=treeEvents.js.map

package/dist/feature-libraries/flex-tree/treeEvents.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"treeEvents.js","sourceRoot":"","sources":["../../../src/feature-libraries/flex-tree/treeEvents.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 { UpPath, PathVisitor } from \"../../core\";\nimport { FlexTreeNode } from \"./flexTreeTypes\";\n\n/**\n * This file provides an API for working with trees which is type safe even when schema is not known.\n * This means no editing is allowed.\n *\n * Schema aware APIs for working with trees should superset this, while sub-setting EditableTree.\n *\n * TODO:\n * This API should replace EditableTree as the default public API for tree access.\n * SchemaAware builds on this, adding editing and type safe APIs which can be accessed via SchematizeView.\n * Once this is finished, the unsafe EditableTree types can be removed (or converted to package internal documentation for the proxies).\n */\n\n/**\n * An event raised on a {@link FlexTreeNode}.\n *\n * @internal\n */\nexport interface TreeEvent {\n\t/**\n\t * The node of the tree where the listener receiving the event is attached.\n\t */\n\treadonly target: FlexTreeNode;\n}\n\n/**\n * A collection of events that can be raised by a {@link FlexTreeNode}.\n * These events are triggered while the internal data structures are being updated.\n * Thus these events must not trigger reading of the anchorSet or forest.\n *\n * TODO:\n * - Design how events should be ordered.\n * - Include sub-deltas in events.\n * - Add more events.\n * - Have some events (or a way to defer events) until the tree can be read.\n *\n * @internal\n */\nexport interface EditableTreeEvents {\n\t/**\n\t * Raised when a specific EditableTree node is changing.\n\t * This includes its fields.\n\t * @param upPath - the path corresponding to the location of the node being changed, upward.\n\t */\n\tchanging(upPath: UpPath): void;\n\n\t/**\n\t * Raised when something in the tree is changing, including this node and its descendants.\n\t * The event can optionally return a {@link PathVisitor} to traverse the subtree\n\t * This event is called on every parent (transitively) when a change is occurring.\n\t * Includes changes to this node itself.\n\t * @param upPath - the path corresponding to the location of the node being changed, upward.\n\t * @returns a visitor to traverse the subtree or `void`.\n\t */\n\tsubtreeChanging(upPath: UpPath): PathVisitor | void;\n\n\t/**\n\t * Raised on a node right before a change is applied to one of its fields or the fields of a descendant node.\n\t *\n\t * @param event - The event object. See {@link TreeEvent} for details.\n\t *\n\t * @remarks\n\t * What exactly qualifies as a change that triggers this event (or {@link EditableTreeEvents.afterChange}) is dependent\n\t * on the implementation of SharedTree. In general, these events will fire once for every atomic editing operation\n\t * supported by SharedTree; {@link EditableTreeEvents.beforeChange} before the change is applied, and\n\t * {@link EditableTreeEvents.afterChange} after it is.\n\t *\n\t * {@link FieldKinds.sequence} fields present two exceptions:\n\t *\n\t * The first one is that events will fire separately for each node involved in the operation (when inserting, removing,\n\t * or moving more than one node at a time). This means that, for example, when inserting two nodes into a {@link FieldKinds.sequence}\n\t * field the following will happen:\n\t * - {@link EditableTreeEvents.beforeChange} will fire once before either new node is present in the tree.\n\t * - {@link EditableTreeEvents.afterChange} will fire once after the first node is present in the tree, but the second one isn't.\n\t * - {@link EditableTreeEvents.beforeChange} will fire once before the second node is present in the tree, but the first one already is.\n\t * - {@link EditableTreeEvents.afterChange} will fire once after the second node is present in the tree (so at this point both nodes are).\n\t * Something similar applies to removing nodes from a sequence, and moving them to another sequence.\n\t *\n\t * The second one is that for an operation to move nodes, events will fire *twice* for each node being moved; once\n\t * while they are being detached from their source location, and once when they are being attached at the target location.\n\t */\n\tbeforeChange(event: TreeEvent): void;\n\n\t/**\n\t * Raised on a node right after a change is applied to one of its fields or the fields of a descendant node.\n\t *\n\t * @param event - The event object. See {@link TreeEvent} for details.\n\t *\n\t * @remarks\n\t * What exactly qualifies as a change that triggers this event (or {@link EditableTreeEvents.beforeChange}) is dependent\n\t * on the implementation of SharedTree. In general, these events will fire once for every atomic editing operation supported\n\t * by SharedTree; {@link EditableTreeEvents.beforeChange} before the change is applied, and\n\t * {@link EditableTreeEvents.afterChange} after it is.\n\t *\n\t * {@link FieldKinds.sequence} present two exceptions:\n\t *\n\t * The first one is that events will fire separately for each node involved in the operation (when inserting, removing,\n\t * or moving more than one node at a time). This means that, for example, when inserting two nodes into a {@link FieldKinds.sequence}\n\t * field the following will happen:\n\t * - {@link EditableTreeEvents.beforeChange} will fire once before either new node is present in the tree.\n\t * - {@link EditableTreeEvents.afterChange} will fire once after the first node is present in the tree, but the second one isn't.\n\t * - {@link EditableTreeEvents.beforeChange} will fire once before the second node is present in the tree, but the first one already is.\n\t * - {@link EditableTreeEvents.afterChange} will fire once after the second node is present in the tree (so at this point both nodes are).\n\t * Something similar applies to removing nodes from a sequence, and moving them to another sequence.\n\t *\n\t * The second one is that for an operation to move nodes, events will fire *twice* for each node being moved; once\n\t * while they are being detached from their source location, and once when they are being attached at the target location.\n\t */\n\tafterChange(event: TreeEvent): void;\n}\n"]}

package/dist/feature-libraries/flex-tree/unboxed.d.ts

@@ -0,0 +1,24 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { ITreeSubscriptionCursor } from "../../core";
+import { FieldKind } from "../modular-schema";
+import { AllowedTypes, TreeFieldSchema, TreeNodeSchema } from "../typed-schema";
+import { Context } from "./context";
+import { FlexTreeUnboxField, FlexTreeUnboxNode, FlexTreeUnboxNodeUnion } from "./flexTreeTypes";
+/**
+ * See {@link FlexTreeUnboxNode} for documentation on what unwrapping this performs.
+ */
+export declare function unboxedTree<TSchema extends TreeNodeSchema>(context: Context, schema: TSchema, cursor: ITreeSubscriptionCursor): FlexTreeUnboxNode<TSchema>;
+/**
+ * See {@link FlexTreeUnboxNodeUnion} for documentation on what unwrapping this performs.
+ */
+export declare function unboxedUnion<TTypes extends AllowedTypes>(context: Context, schema: TreeFieldSchema<FieldKind, TTypes>, cursor: ITreeSubscriptionCursor): FlexTreeUnboxNodeUnion<TTypes>;
+/**
+ * @param context - the common context of the field.
+ * @param schema - the TreeFieldStoredSchema of the field.
+ * @param cursor - the cursor, which must point to the field being proxified.
+ */
+export declare function unboxedField<TSchema extends TreeFieldSchema>(context: Context, schema: TSchema, cursor: ITreeSubscriptionCursor): FlexTreeUnboxField<TSchema>;
+//# sourceMappingURL=unboxed.d.ts.map

package/dist/feature-libraries/flex-tree/unboxed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unboxed.d.ts","sourceRoot":"","sources":["../../../src/feature-libraries/flex-tree/unboxed.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,uBAAuB,EAAgB,MAAM,YAAY,CAAC;AACnE,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAE9C,OAAO,EAAE,YAAY,EAAE,eAAe,EAAE,cAAc,EAAgB,MAAM,iBAAiB,CAAC;AAC9F,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAEN,kBAAkB,EAClB,iBAAiB,EACjB,sBAAsB,EACtB,MAAM,iBAAiB,CAAC;AAIzB;;GAEG;AACH,wBAAgB,WAAW,CAAC,OAAO,SAAS,cAAc,EACzD,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,OAAO,EACf,MAAM,EAAE,uBAAuB,GAC7B,iBAAiB,CAAC,OAAO,CAAC,CAM5B;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,MAAM,SAAS,YAAY,EACvD,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,eAAe,CAAC,SAAS,EAAE,MAAM,CAAC,EAC1C,MAAM,EAAE,uBAAuB,GAC7B,sBAAsB,CAAC,MAAM,CAAC,CAMhC;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,OAAO,SAAS,eAAe,EAC3D,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,OAAO,EACf,MAAM,EAAE,uBAAuB,GAC7B,kBAAkB,CAAC,OAAO,CAAC,CAkB7B"}

package/dist/feature-libraries/flex-tree/unboxed.js

@@ -0,0 +1,54 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unboxedField = exports.unboxedUnion = exports.unboxedTree = void 0;
+const core_1 = require("../../core");
+const default_schema_1 = require("../default-schema");
+const typed_schema_1 = require("../typed-schema");
+const lazyNode_1 = require("./lazyNode");
+const lazyField_1 = require("./lazyField");
+/**
+ * See {@link FlexTreeUnboxNode} for documentation on what unwrapping this performs.
+ */
+function unboxedTree(context, schema, cursor) {
+    if ((0, typed_schema_1.schemaIsLeaf)(schema)) {
+        return cursor.value;
+    }
+    return (0, lazyNode_1.makeTree)(context, cursor);
+}
+exports.unboxedTree = unboxedTree;
+/**
+ * See {@link FlexTreeUnboxNodeUnion} for documentation on what unwrapping this performs.
+ */
+function unboxedUnion(context, schema, cursor) {
+    const type = schema.monomorphicChildType;
+    if (type !== undefined) {
+        return unboxedTree(context, type, cursor);
+    }
+    return (0, lazyNode_1.makeTree)(context, cursor);
+}
+exports.unboxedUnion = unboxedUnion;
+/**
+ * @param context - the common context of the field.
+ * @param schema - the TreeFieldStoredSchema of the field.
+ * @param cursor - the cursor, which must point to the field being proxified.
+ */
+function unboxedField(context, schema, cursor) {
+    const kind = schema.kind;
+    if (kind === default_schema_1.FieldKinds.required) {
+        return (0, core_1.inCursorNode)(cursor, 0, (innerCursor) => unboxedUnion(context, schema, innerCursor));
+    }
+    if (kind === default_schema_1.FieldKinds.optional) {
+        if (cursor.getFieldLength() === 0) {
+            return undefined;
+        }
+        return (0, core_1.inCursorNode)(cursor, 0, (innerCursor) => unboxedUnion(context, schema, innerCursor));
+    }
+    // TODO: forbidden and nodeKey
+    return (0, lazyField_1.makeField)(context, schema, cursor);
+}
+exports.unboxedField = unboxedField;
+//# sourceMappingURL=unboxed.js.map

package/dist/feature-libraries/flex-tree/unboxed.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unboxed.js","sourceRoot":"","sources":["../../../src/feature-libraries/flex-tree/unboxed.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,qCAAmE;AAEnE,sDAA+C;AAC/C,kDAA8F;AAQ9F,yCAAsC;AACtC,2CAAwC;AAExC;;GAEG;AACH,SAAgB,WAAW,CAC1B,OAAgB,EAChB,MAAe,EACf,MAA+B;IAE/B,IAAI,IAAA,2BAAY,EAAC,MAAM,CAAC,EAAE;QACzB,OAAO,MAAM,CAAC,KAAmC,CAAC;KAClD;IAED,OAAO,IAAA,mBAAQ,EAAC,OAAO,EAAE,MAAM,CAA+C,CAAC;AAChF,CAAC;AAVD,kCAUC;AAED;;GAEG;AACH,SAAgB,YAAY,CAC3B,OAAgB,EAChB,MAA0C,EAC1C,MAA+B;IAE/B,MAAM,IAAI,GAAG,MAAM,CAAC,oBAAoB,CAAC;IACzC,IAAI,IAAI,KAAK,SAAS,EAAE;QACvB,OAAO,WAAW,CAAC,OAAO,EAAE,IAAI,EAAE,MAAM,CAAmC,CAAC;KAC5E;IACD,OAAO,IAAA,mBAAQ,EAAC,OAAO,EAAE,MAAM,CAAmC,CAAC;AACpE,CAAC;AAVD,oCAUC;AAED;;;;GAIG;AACH,SAAgB,YAAY,CAC3B,OAAgB,EAChB,MAAe,EACf,MAA+B;IAE/B,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC;IACzB,IAAI,IAAI,KAAK,2BAAU,CAAC,QAAQ,EAAE;QACjC,OAAO,IAAA,mBAAY,EAAC,MAAM,EAAE,CAAC,EAAE,CAAC,WAAW,EAAE,EAAE,CAC9C,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,CAAC,CACX,CAAC;KACjC;IACD,IAAI,IAAI,KAAK,2BAAU,CAAC,QAAQ,EAAE;QACjC,IAAI,MAAM,CAAC,cAAc,EAAE,KAAK,CAAC,EAAE;YAClC,OAAO,SAAwC,CAAC;SAChD;QACD,OAAO,IAAA,mBAAY,EAAC,MAAM,EAAE,CAAC,EAAE,CAAC,WAAW,EAAE,EAAE,CAC9C,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,CAAC,CACX,CAAC;KACjC;IAED,8BAA8B;IAC9B,OAAO,IAAA,qBAAS,EAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAgC,CAAC;AAC1E,CAAC;AAtBD,oCAsBC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { ITreeSubscriptionCursor, inCursorNode } from \"../../core\";\nimport { FieldKind } from \"../modular-schema\";\nimport { FieldKinds } from \"../default-schema\";\nimport { AllowedTypes, TreeFieldSchema, TreeNodeSchema, schemaIsLeaf } from \"../typed-schema\";\nimport { Context } from \"./context\";\nimport {\n\tFlexTreeNode,\n\tFlexTreeUnboxField,\n\tFlexTreeUnboxNode,\n\tFlexTreeUnboxNodeUnion,\n} from \"./flexTreeTypes\";\nimport { makeTree } from \"./lazyNode\";\nimport { makeField } from \"./lazyField\";\n\n/**\n * See {@link FlexTreeUnboxNode} for documentation on what unwrapping this performs.\n */\nexport function unboxedTree<TSchema extends TreeNodeSchema>(\n\tcontext: Context,\n\tschema: TSchema,\n\tcursor: ITreeSubscriptionCursor,\n): FlexTreeUnboxNode<TSchema> {\n\tif (schemaIsLeaf(schema)) {\n\t\treturn cursor.value as FlexTreeUnboxNode<TSchema>;\n\t}\n\n\treturn makeTree(context, cursor) as FlexTreeNode as FlexTreeUnboxNode<TSchema>;\n}\n\n/**\n * See {@link FlexTreeUnboxNodeUnion} for documentation on what unwrapping this performs.\n */\nexport function unboxedUnion<TTypes extends AllowedTypes>(\n\tcontext: Context,\n\tschema: TreeFieldSchema<FieldKind, TTypes>,\n\tcursor: ITreeSubscriptionCursor,\n): FlexTreeUnboxNodeUnion<TTypes> {\n\tconst type = schema.monomorphicChildType;\n\tif (type !== undefined) {\n\t\treturn unboxedTree(context, type, cursor) as FlexTreeUnboxNodeUnion<TTypes>;\n\t}\n\treturn makeTree(context, cursor) as FlexTreeUnboxNodeUnion<TTypes>;\n}\n\n/**\n * @param context - the common context of the field.\n * @param schema - the TreeFieldStoredSchema of the field.\n * @param cursor - the cursor, which must point to the field being proxified.\n */\nexport function unboxedField<TSchema extends TreeFieldSchema>(\n\tcontext: Context,\n\tschema: TSchema,\n\tcursor: ITreeSubscriptionCursor,\n): FlexTreeUnboxField<TSchema> {\n\tconst kind = schema.kind;\n\tif (kind === FieldKinds.required) {\n\t\treturn inCursorNode(cursor, 0, (innerCursor) =>\n\t\t\tunboxedUnion(context, schema, innerCursor),\n\t\t) as FlexTreeUnboxField<TSchema>;\n\t}\n\tif (kind === FieldKinds.optional) {\n\t\tif (cursor.getFieldLength() === 0) {\n\t\t\treturn undefined as FlexTreeUnboxField<TSchema>;\n\t\t}\n\t\treturn inCursorNode(cursor, 0, (innerCursor) =>\n\t\t\tunboxedUnion(context, schema, innerCursor),\n\t\t) as FlexTreeUnboxField<TSchema>;\n\t}\n\n\t// TODO: forbidden and nodeKey\n\treturn makeField(context, schema, cursor) as FlexTreeUnboxField<TSchema>;\n}\n"]}

package/dist/feature-libraries/flex-tree/utilities.d.ts

@@ -0,0 +1,29 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { AnchorNode, AnchorSet, DetachedField } from "../../core";
+import { TreeStatus } from "./flexTreeTypes";
+/**
+ * Checks the detached field and returns the TreeStatus based on whether or not the detached field is a root field.
+ * @param detachedField - the detached field you want to check.
+ * @returns the {@link TreeStatus} from the detached field provided.
+ */
+export declare function treeStatusFromDetachedField(detachedField: DetachedField): TreeStatus;
+/**
+ * Determines the tree status based on the anchor cache.
+ *
+ * Checks the anchorNode's cache to get the tree status.
+ * If the cache is undefined or stale, it is updated and the treeStatus based on its detachedField is returned.
+ *
+ * @param anchors - the {@link AnchorSet} to compare your anchorNode cache to.
+ * @param anchorNode - the {@link AnchorNode} to get the {@link TreeStatus} of.
+ * @returns - the {@link TreeStatus} of the anchorNode provided.
+ */
+export declare function treeStatusFromAnchorCache(anchors: AnchorSet, anchorNode: AnchorNode): TreeStatus;
+export declare const detachedFieldSlot: import("../../core").AnchorSlot<DetachedFieldCache>;
+export interface DetachedFieldCache {
+    generationNumber: number;
+    detachedField: DetachedField;
+}
+//# sourceMappingURL=utilities.d.ts.map

package/dist/feature-libraries/flex-tree/utilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utilities.d.ts","sourceRoot":"","sources":["../../../src/feature-libraries/flex-tree/utilities.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACN,UAAU,EACV,SAAS,EACT,aAAa,EAIb,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C;;;;GAIG;AACH,wBAAgB,2BAA2B,CAAC,aAAa,EAAE,aAAa,GAAG,UAAU,CAEpF;AAED;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,UAAU,GAAG,UAAU,CAkBhG;AAiBD,eAAO,MAAM,iBAAiB,qDAAmC,CAAC;AAElE,MAAM,WAAW,kBAAkB;IAClC,gBAAgB,EAAE,MAAM,CAAC;IACzB,aAAa,EAAE,aAAa,CAAC;CAC7B"}

package/dist/feature-libraries/flex-tree/utilities.js

@@ -0,0 +1,58 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detachedFieldSlot = exports.treeStatusFromAnchorCache = exports.treeStatusFromDetachedField = void 0;
+const core_1 = require("../../core");
+const flexTreeTypes_1 = require("./flexTreeTypes");
+/**
+ * Checks the detached field and returns the TreeStatus based on whether or not the detached field is a root field.
+ * @param detachedField - the detached field you want to check.
+ * @returns the {@link TreeStatus} from the detached field provided.
+ */
+function treeStatusFromDetachedField(detachedField) {
+    return detachedField === core_1.rootField ? flexTreeTypes_1.TreeStatus.InDocument : flexTreeTypes_1.TreeStatus.Removed;
+}
+exports.treeStatusFromDetachedField = treeStatusFromDetachedField;
+/**
+ * Determines the tree status based on the anchor cache.
+ *
+ * Checks the anchorNode's cache to get the tree status.
+ * If the cache is undefined or stale, it is updated and the treeStatus based on its detachedField is returned.
+ *
+ * @param anchors - the {@link AnchorSet} to compare your anchorNode cache to.
+ * @param anchorNode - the {@link AnchorNode} to get the {@link TreeStatus} of.
+ * @returns - the {@link TreeStatus} of the anchorNode provided.
+ */
+function treeStatusFromAnchorCache(anchors, anchorNode) {
+    const cache = anchorNode.slots.get(exports.detachedFieldSlot);
+    if (cache === undefined) {
+        // If the cache is undefined, set the cache and return the treeStatus based on the detached field.
+        return treeStatusFromDetachedField(getCachedUpdatedDetachedField(anchorNode, anchors.generationNumber));
+    }
+    else {
+        // If the cache is up to date, return the treeStatus based on the cached detached field.
+        const currentGenerationNumber = anchors.generationNumber;
+        if (cache.generationNumber === currentGenerationNumber) {
+            return treeStatusFromDetachedField(cache.detachedField);
+        }
+        // If the cache is not up to date, update the cache and return the treeStatus based on the updated detached field.
+        return treeStatusFromDetachedField(getCachedUpdatedDetachedField(anchorNode, currentGenerationNumber));
+    }
+}
+exports.treeStatusFromAnchorCache = treeStatusFromAnchorCache;
+/**
+ * Updates the anchorNode cache with the provided generation number, and returns its detachedField.
+ */
+function getCachedUpdatedDetachedField(anchorNode, generationNumber) {
+    const detachedField = (0, core_1.getDetachedFieldContainingPath)(anchorNode);
+    anchorNode.slots.set(exports.detachedFieldSlot, {
+        generationNumber,
+        detachedField,
+    });
+    return detachedField;
+}
+exports.detachedFieldSlot = (0, core_1.anchorSlot)();
+//# sourceMappingURL=utilities.js.map

package/dist/feature-libraries/flex-tree/utilities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utilities.js","sourceRoot":"","sources":["../../../src/feature-libraries/flex-tree/utilities.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,qCAOoB;AACpB,mDAA6C;AAC7C;;;;GAIG;AACH,SAAgB,2BAA2B,CAAC,aAA4B;IACvE,OAAO,aAAa,KAAK,gBAAS,CAAC,CAAC,CAAC,0BAAU,CAAC,UAAU,CAAC,CAAC,CAAC,0BAAU,CAAC,OAAO,CAAC;AACjF,CAAC;AAFD,kEAEC;AAED;;;;;;;;;GASG;AACH,SAAgB,yBAAyB,CAAC,OAAkB,EAAE,UAAsB;IACnF,MAAM,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC,GAAG,CAAC,yBAAiB,CAAC,CAAC;IACtD,IAAI,KAAK,KAAK,SAAS,EAAE;QACxB,kGAAkG;QAClG,OAAO,2BAA2B,CACjC,6BAA6B,CAAC,UAAU,EAAE,OAAO,CAAC,gBAAgB,CAAC,CACnE,CAAC;KACF;SAAM;QACN,wFAAwF;QACxF,MAAM,uBAAuB,GAAG,OAAO,CAAC,gBAAgB,CAAC;QACzD,IAAI,KAAK,CAAC,gBAAgB,KAAK,uBAAuB,EAAE;YACvD,OAAO,2BAA2B,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC;SACxD;QACD,kHAAkH;QAClH,OAAO,2BAA2B,CACjC,6BAA6B,CAAC,UAAU,EAAE,uBAAuB,CAAC,CAClE,CAAC;KACF;AACF,CAAC;AAlBD,8DAkBC;AAED;;GAEG;AACH,SAAS,6BAA6B,CACrC,UAAsB,EACtB,gBAAwB;IAExB,MAAM,aAAa,GAAG,IAAA,qCAA8B,EAAC,UAAU,CAAC,CAAC;IACjE,UAAU,CAAC,KAAK,CAAC,GAAG,CAAC,yBAAiB,EAAE;QACvC,gBAAgB;QAChB,aAAa;KACb,CAAC,CAAC;IACH,OAAO,aAAa,CAAC;AACtB,CAAC;AAEY,QAAA,iBAAiB,GAAG,IAAA,iBAAU,GAAsB,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport {\n\tAnchorNode,\n\tAnchorSet,\n\tDetachedField,\n\tanchorSlot,\n\tgetDetachedFieldContainingPath,\n\trootField,\n} from \"../../core\";\nimport { TreeStatus } from \"./flexTreeTypes\";\n/**\n * Checks the detached field and returns the TreeStatus based on whether or not the detached field is a root field.\n * @param detachedField - the detached field you want to check.\n * @returns the {@link TreeStatus} from the detached field provided.\n */\nexport function treeStatusFromDetachedField(detachedField: DetachedField): TreeStatus {\n\treturn detachedField === rootField ? TreeStatus.InDocument : TreeStatus.Removed;\n}\n\n/**\n * Determines the tree status based on the anchor cache.\n *\n * Checks the anchorNode's cache to get the tree status.\n * If the cache is undefined or stale, it is updated and the treeStatus based on its detachedField is returned.\n *\n * @param anchors - the {@link AnchorSet} to compare your anchorNode cache to.\n * @param anchorNode - the {@link AnchorNode} to get the {@link TreeStatus} of.\n * @returns - the {@link TreeStatus} of the anchorNode provided.\n */\nexport function treeStatusFromAnchorCache(anchors: AnchorSet, anchorNode: AnchorNode): TreeStatus {\n\tconst cache = anchorNode.slots.get(detachedFieldSlot);\n\tif (cache === undefined) {\n\t\t// If the cache is undefined, set the cache and return the treeStatus based on the detached field.\n\t\treturn treeStatusFromDetachedField(\n\t\t\tgetCachedUpdatedDetachedField(anchorNode, anchors.generationNumber),\n\t\t);\n\t} else {\n\t\t// If the cache is up to date, return the treeStatus based on the cached detached field.\n\t\tconst currentGenerationNumber = anchors.generationNumber;\n\t\tif (cache.generationNumber === currentGenerationNumber) {\n\t\t\treturn treeStatusFromDetachedField(cache.detachedField);\n\t\t}\n\t\t// If the cache is not up to date, update the cache and return the treeStatus based on the updated detached field.\n\t\treturn treeStatusFromDetachedField(\n\t\t\tgetCachedUpdatedDetachedField(anchorNode, currentGenerationNumber),\n\t\t);\n\t}\n}\n\n/**\n * Updates the anchorNode cache with the provided generation number, and returns its detachedField.\n */\nfunction getCachedUpdatedDetachedField(\n\tanchorNode: AnchorNode,\n\tgenerationNumber: number,\n): DetachedField {\n\tconst detachedField = getDetachedFieldContainingPath(anchorNode);\n\tanchorNode.slots.set(detachedFieldSlot, {\n\t\tgenerationNumber,\n\t\tdetachedField,\n\t});\n\treturn detachedField;\n}\n\nexport const detachedFieldSlot = anchorSlot<DetachedFieldCache>();\n\nexport interface DetachedFieldCache {\n\tgenerationNumber: number;\n\tdetachedField: DetachedField;\n}\n"]}

package/dist/feature-libraries/forest-summary/codec.d.ts

@@ -0,0 +1,16 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { ICodecOptions, IJsonCodecWithContext } from "../../codec";
+import { FieldKey, ITreeCursorSynchronous } from "../../core";
+import { FieldBatchCodec } from "../chunked-forest";
+import { Context } from "../chunked-forest/codec/codecs";
+import { Format } from "./format";
+/**
+ * Uses field cursors
+ */
+export type FieldSet = ReadonlyMap<FieldKey, ITreeCursorSynchronous>;
+export type ForestCodec = IJsonCodecWithContext<FieldSet, Format, Format, Context>;
+export declare function makeForestSummarizerCodec(options: ICodecOptions, fieldBatchCodec: FieldBatchCodec): ForestCodec;
+//# sourceMappingURL=codec.d.ts.map

package/dist/feature-libraries/forest-summary/codec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec.d.ts","sourceRoot":"","sources":["../../../src/feature-libraries/forest-summary/codec.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AACnE,OAAO,EAAE,QAAQ,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAC9D,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEpD,OAAO,EAAE,OAAO,EAAE,MAAM,gCAAgC,CAAC;AAEzD,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAElC;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG,WAAW,CAAC,QAAQ,EAAE,sBAAsB,CAAC,CAAC;AACrE,MAAM,MAAM,WAAW,GAAG,qBAAqB,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;AAEnF,wBAAgB,yBAAyB,CACxC,OAAO,EAAE,aAAa,EACtB,eAAe,EAAE,eAAe,GAC9B,WAAW,CA0Bb"}

package/dist/feature-libraries/forest-summary/codec.js

@@ -0,0 +1,39 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeForestSummarizerCodec = void 0;
+const core_utils_1 = require("@fluidframework/core-utils");
+const versioned_1 = require("../versioned");
+const format_1 = require("./format");
+function makeForestSummarizerCodec(options, fieldBatchCodec) {
+    // TODO: every time context changes, withSchemaValidation and makeVersionedCodec recompile their json validators.
+    // Those should be reused. Making more code context aware could fix that.
+    return (context) => {
+        const inner = fieldBatchCodec(context);
+        return (0, versioned_1.makeVersionedValidatedCodec)(options, new Set([1]), format_1.Format, {
+            encode: (data) => {
+                const keys = [];
+                const fields = [];
+                for (const [key, value] of data) {
+                    keys.push(key);
+                    fields.push(value);
+                }
+                return { keys, fields: inner.encode(fields), version: 1 };
+            },
+            decode: (data) => {
+                const out = new Map();
+                const fields = inner.decode(data.fields);
+                (0, core_utils_1.assert)(data.keys.length === fields.length, "mismatched lengths");
+                for (let index = 0; index < fields.length; index++) {
+                    out.set(data.keys[index], fields[index]);
+                }
+                return out;
+            },
+        });
+    };
+}
+exports.makeForestSummarizerCodec = makeForestSummarizerCodec;
+//# sourceMappingURL=codec.js.map

package/dist/feature-libraries/forest-summary/codec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec.js","sourceRoot":"","sources":["../../../src/feature-libraries/forest-summary/codec.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,2DAAoD;AAMpD,4CAA2D;AAC3D,qCAAkC;AAQlC,SAAgB,yBAAyB,CACxC,OAAsB,EACtB,eAAgC;IAEhC,iHAAiH;IACjH,yEAAyE;IACzE,OAAO,CAAC,OAAgB,EAAE,EAAE;QAC3B,MAAM,KAAK,GAAG,eAAe,CAAC,OAAO,CAAC,CAAC;QACvC,OAAO,IAAA,uCAA2B,EAAC,OAAO,EAAE,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,eAAM,EAAE;YACjE,MAAM,EAAE,CAAC,IAAc,EAAU,EAAE;gBAClC,MAAM,IAAI,GAAe,EAAE,CAAC;gBAC5B,MAAM,MAAM,GAA6B,EAAE,CAAC;gBAC5C,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,IAAI,EAAE;oBAChC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;oBACf,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;iBACnB;gBACD,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC;YAC3D,CAAC;YACD,MAAM,EAAE,CAAC,IAAY,EAAY,EAAE;gBAClC,MAAM,GAAG,GAA0C,IAAI,GAAG,EAAE,CAAC;gBAC7D,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;gBACzC,IAAA,mBAAM,EAAC,IAAI,CAAC,IAAI,CAAC,MAAM,KAAK,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;gBACjE,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE;oBACnD,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;iBACzC;gBACD,OAAO,GAAG,CAAC;YACZ,CAAC;SACD,CAAC,CAAC;IACJ,CAAC,CAAC;AACH,CAAC;AA7BD,8DA6BC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { assert } from \"@fluidframework/core-utils\";\nimport { ICodecOptions, IJsonCodecWithContext } from \"../../codec\";\nimport { FieldKey, ITreeCursorSynchronous } from \"../../core\";\nimport { FieldBatchCodec } from \"../chunked-forest\";\n// eslint-disable-next-line import/no-internal-modules\nimport { Context } from \"../chunked-forest/codec/codecs\";\nimport { makeVersionedValidatedCodec } from \"../versioned\";\nimport { Format } from \"./format\";\n\n/**\n * Uses field cursors\n */\nexport type FieldSet = ReadonlyMap<FieldKey, ITreeCursorSynchronous>;\nexport type ForestCodec = IJsonCodecWithContext<FieldSet, Format, Format, Context>;\n\nexport function makeForestSummarizerCodec(\n\toptions: ICodecOptions,\n\tfieldBatchCodec: FieldBatchCodec,\n): ForestCodec {\n\t// TODO: every time context changes, withSchemaValidation and makeVersionedCodec recompile their json validators.\n\t// Those should be reused. Making more code context aware could fix that.\n\treturn (context: Context) => {\n\t\tconst inner = fieldBatchCodec(context);\n\t\treturn makeVersionedValidatedCodec(options, new Set([1]), Format, {\n\t\t\tencode: (data: FieldSet): Format => {\n\t\t\t\tconst keys: FieldKey[] = [];\n\t\t\t\tconst fields: ITreeCursorSynchronous[] = [];\n\t\t\t\tfor (const [key, value] of data) {\n\t\t\t\t\tkeys.push(key);\n\t\t\t\t\tfields.push(value);\n\t\t\t\t}\n\t\t\t\treturn { keys, fields: inner.encode(fields), version: 1 };\n\t\t\t},\n\t\t\tdecode: (data: Format): FieldSet => {\n\t\t\t\tconst out: Map<FieldKey, ITreeCursorSynchronous> = new Map();\n\t\t\t\tconst fields = inner.decode(data.fields);\n\t\t\t\tassert(data.keys.length === fields.length, \"mismatched lengths\");\n\t\t\t\tfor (let index = 0; index < fields.length; index++) {\n\t\t\t\t\tout.set(data.keys[index], fields[index]);\n\t\t\t\t}\n\t\t\t\treturn out;\n\t\t\t},\n\t\t});\n\t};\n}\n"]}