@fluidframework/tree 2.0.0-dev-rc.1.0.0.224419

package/dist/feature-libraries/multiplicity.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Multiplicity = void 0;
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+/**
+ * Describes how a particular field functions.
+ *
+ * This determine its reading and editing APIs, multiplicity, and what merge resolution policies it will use.
+ * @internal
+ */
+var Multiplicity;
+(function (Multiplicity) {
+    /**
+     * Exactly one item.
+     */
+    Multiplicity[Multiplicity["Single"] = 0] = "Single";
+    /**
+     * 0 or 1 items.
+     */
+    Multiplicity[Multiplicity["Optional"] = 1] = "Optional";
+    /**
+     * 0 or more items.
+     */
+    Multiplicity[Multiplicity["Sequence"] = 2] = "Sequence";
+    /**
+     * Exactly 0 items.
+     *
+     * Using Forbidden makes what types are listed for allowed in a field irrelevant
+     * since the field will never have values in it.
+     *
+     * Using Forbidden is equivalent to picking a kind that permits empty (like sequence or optional)
+     * and having no allowed types (or only never types).
+     * Because of this, its possible to express everything constraint wise without Forbidden,
+     * but using Forbidden can be more semantically clear than optional with no allowed types.
+     *
+     * For view schema, this can be useful if you need to:
+     * - run a specific out of schema handler when a field is present,
+     * but otherwise are ignoring or tolerating (ex: via extra fields) unmentioned fields.
+     * - prevent a specific field from being used as an extra field
+     * (perhaps for some past of future compatibility reason)
+     * - keep a field in a schema for metadata purposes
+     * (ex: for improved error messaging, error handling or documentation)
+     * that is not used in this specific version of the schema (ex: to document what it was or will be used for).
+     *
+     * For stored schema, this can be useful if you need to:
+     * - have a field which can have its schema updated to Optional or Sequence of any type.
+     * - to exclude a field from extra fields
+     * - for the schema system to use as a default for fields which aren't declared
+     * (ex: when updating a field that did not exist into one that does)
+     *
+     * @privateRemarks
+     * See storedEmptyFieldSchema for a constant, reusable field using Forbidden.
+     */
+    Multiplicity[Multiplicity["Forbidden"] = 3] = "Forbidden";
+})(Multiplicity || (exports.Multiplicity = Multiplicity = {}));
+//# sourceMappingURL=multiplicity.js.map

package/dist/feature-libraries/multiplicity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"multiplicity.js","sourceRoot":"","sources":["../../src/feature-libraries/multiplicity.ts"],"names":[],"mappings":";;;AAAA;;;GAGG;AACH;;;;;GAKG;AACH,IAAY,YA2CX;AA3CD,WAAY,YAAY;IACvB;;OAEG;IACH,mDAAM,CAAA;IACN;;OAEG;IACH,uDAAQ,CAAA;IACR;;OAEG;IACH,uDAAQ,CAAA;IACR;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,yDAAS,CAAA;AACV,CAAC,EA3CW,YAAY,4BAAZ,YAAY,QA2CvB","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n/**\n * Describes how a particular field functions.\n *\n * This determine its reading and editing APIs, multiplicity, and what merge resolution policies it will use.\n * @internal\n */\nexport enum Multiplicity {\n\t/**\n\t * Exactly one item.\n\t */\n\tSingle,\n\t/**\n\t * 0 or 1 items.\n\t */\n\tOptional,\n\t/**\n\t * 0 or more items.\n\t */\n\tSequence,\n\t/**\n\t * Exactly 0 items.\n\t *\n\t * Using Forbidden makes what types are listed for allowed in a field irrelevant\n\t * since the field will never have values in it.\n\t *\n\t * Using Forbidden is equivalent to picking a kind that permits empty (like sequence or optional)\n\t * and having no allowed types (or only never types).\n\t * Because of this, its possible to express everything constraint wise without Forbidden,\n\t * but using Forbidden can be more semantically clear than optional with no allowed types.\n\t *\n\t * For view schema, this can be useful if you need to:\n\t * - run a specific out of schema handler when a field is present,\n\t * but otherwise are ignoring or tolerating (ex: via extra fields) unmentioned fields.\n\t * - prevent a specific field from being used as an extra field\n\t * (perhaps for some past of future compatibility reason)\n\t * - keep a field in a schema for metadata purposes\n\t * (ex: for improved error messaging, error handling or documentation)\n\t * that is not used in this specific version of the schema (ex: to document what it was or will be used for).\n\t *\n\t * For stored schema, this can be useful if you need to:\n\t * - have a field which can have its schema updated to Optional or Sequence of any type.\n\t * - to exclude a field from extra fields\n\t * - for the schema system to use as a default for fields which aren't declared\n\t * (ex: when updating a field that did not exist into one that does)\n\t *\n\t * @privateRemarks\n\t * See storedEmptyFieldSchema for a constant, reusable field using Forbidden.\n\t */\n\tForbidden,\n}\n"]}

package/dist/feature-libraries/node-key/index.d.ts

@@ -0,0 +1,8 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+export { compareLocalNodeKeys, LocalNodeKey, StableNodeKey, nodeKeyFieldKey, nodeKeyTreeIdentifier, } from "./nodeKey";
+export { NodeKeyIndex } from "./nodeKeyIndex";
+export { createNodeKeyManager, createMockNodeKeyManager, NodeKeyManager } from "./nodeKeyManager";
+//# sourceMappingURL=index.d.ts.map

package/dist/feature-libraries/node-key/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/feature-libraries/node-key/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACN,oBAAoB,EACpB,YAAY,EACZ,aAAa,EACb,eAAe,EACf,qBAAqB,GACrB,MAAM,WAAW,CAAC;AAEnB,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C,OAAO,EAAE,oBAAoB,EAAE,wBAAwB,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/feature-libraries/node-key/index.js

@@ -0,0 +1,17 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMockNodeKeyManager = exports.createNodeKeyManager = exports.NodeKeyIndex = exports.nodeKeyTreeIdentifier = exports.nodeKeyFieldKey = exports.compareLocalNodeKeys = void 0;
+var nodeKey_1 = require("./nodeKey");
+Object.defineProperty(exports, "compareLocalNodeKeys", { enumerable: true, get: function () { return nodeKey_1.compareLocalNodeKeys; } });
+Object.defineProperty(exports, "nodeKeyFieldKey", { enumerable: true, get: function () { return nodeKey_1.nodeKeyFieldKey; } });
+Object.defineProperty(exports, "nodeKeyTreeIdentifier", { enumerable: true, get: function () { return nodeKey_1.nodeKeyTreeIdentifier; } });
+var nodeKeyIndex_1 = require("./nodeKeyIndex");
+Object.defineProperty(exports, "NodeKeyIndex", { enumerable: true, get: function () { return nodeKeyIndex_1.NodeKeyIndex; } });
+var nodeKeyManager_1 = require("./nodeKeyManager");
+Object.defineProperty(exports, "createNodeKeyManager", { enumerable: true, get: function () { return nodeKeyManager_1.createNodeKeyManager; } });
+Object.defineProperty(exports, "createMockNodeKeyManager", { enumerable: true, get: function () { return nodeKeyManager_1.createMockNodeKeyManager; } });
+//# sourceMappingURL=index.js.map

package/dist/feature-libraries/node-key/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/feature-libraries/node-key/index.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,qCAMmB;AALlB,+GAAA,oBAAoB,OAAA;AAGpB,0GAAA,eAAe,OAAA;AACf,gHAAA,qBAAqB,OAAA;AAGtB,+CAA8C;AAArC,4GAAA,YAAY,OAAA;AAErB,mDAAkG;AAAzF,sHAAA,oBAAoB,OAAA;AAAE,0HAAA,wBAAwB,OAAA","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nexport {\n\tcompareLocalNodeKeys,\n\tLocalNodeKey,\n\tStableNodeKey,\n\tnodeKeyFieldKey,\n\tnodeKeyTreeIdentifier,\n} from \"./nodeKey\";\n\nexport { NodeKeyIndex } from \"./nodeKeyIndex\";\n\nexport { createNodeKeyManager, createMockNodeKeyManager, NodeKeyManager } from \"./nodeKeyManager\";\n"]}

package/dist/feature-libraries/node-key/nodeKey.d.ts

@@ -0,0 +1,50 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { SessionSpaceCompressedId, StableId } from "@fluidframework/runtime-definitions";
+import { Brand, Opaque } from "../../util";
+import { TreeNodeSchemaIdentifier } from "../../core";
+/**
+ * A key which uniquely identifies a node in the tree within this session.
+ * @remarks {@link LocalNodeKey}s must not be serialized and stored as data without first being converted into a {@link StableNodeKey}.
+ * They are local to the current session and equivalent nodes in another session will not necessarily have the same {@link LocalNodeKey}.
+ * However, they are otherwise preferential to use over {@link StableNodeKey}s as they are much smaller.
+ * For example, they are more efficient than {@link StableNodeKey}s when used as keys in a map.
+ * {@link LocalNodeKey}s may be compared or equated via {@link compareLocalNodeKeys}.
+ * @internal
+ */
+export interface LocalNodeKey extends Opaque<Brand<SessionSpaceCompressedId, "Local Node Key">> {
+}
+/**
+ * A UUID which identifies a node in the tree.
+ * This key is universally unique and stable forever; therefore it is safe to persist as data in a SharedTree or other DDS/database.
+ * When not persisted or serialized, it is preferable to use a {@link LocalNodeKey} instead for better performance.
+ * @internal
+ */
+export type StableNodeKey = Brand<StableId, "Stable Node Key">;
+/**
+ * Compares two {@link LocalNodeKey}s.
+ * All {@link LocalNodeKey}s retrieved from a single SharedTree client can be totally ordered using this comparator.
+ * @param a - the first key to compare
+ * @param b - the second key to compare
+ * @returns `0` if `a` and `b` are the same key, otherwise `-1` if `a` is ordered before `b` or `1` if `a` is ordered after `b`.
+ * @internal
+ */
+export declare function compareLocalNodeKeys(a: LocalNodeKey, b: LocalNodeKey): -1 | 0 | 1;
+/**
+ * The key for the special field for {@link LocalNodeKey}s,
+ * which allows nodes to be given keys that can be used to find the nodes via the node key index.
+ * @internal
+ * @privateRemarks TODO: Come up with a unified and collision-resistant naming schema for fields defined by the system.
+ * For now, we'll use `__` to reduce the change of collision, since this is what other internal properties use in Fluid.
+ */
+export declare const nodeKeyFieldKey = "__n_id__";
+/**
+ * The TreeNodeSchemaIdentifier for node keys.
+ * @internal
+ * @privateRemarks TODO: Come up with a unified and collision-resistant naming schema for types defined by the system.
+ * For now, we'll use `__` to reduce the change of collision, since this is what other internal properties use in Fluid.
+ */
+export declare const nodeKeyTreeIdentifier: TreeNodeSchemaIdentifier;
+//# sourceMappingURL=nodeKey.d.ts.map

package/dist/feature-libraries/node-key/nodeKey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodeKey.d.ts","sourceRoot":"","sources":["../../../src/feature-libraries/node-key/nodeKey.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,wBAAwB,EAAE,QAAQ,EAAE,MAAM,qCAAqC,CAAC;AACzF,OAAO,EAAE,KAAK,EAAE,MAAM,EAAS,MAAM,YAAY,CAAC;AAClD,OAAO,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAEtD;;;;;;;;GAQG;AACH,MAAM,WAAW,YAAa,SAAQ,MAAM,CAAC,KAAK,CAAC,wBAAwB,EAAE,gBAAgB,CAAC,CAAC;CAAG;AAElG;;;;;GAKG;AACH,MAAM,MAAM,aAAa,GAAG,KAAK,CAAC,QAAQ,EAAE,iBAAiB,CAAC,CAAC;AAE/D;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,YAAY,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAEjF;AAED;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,aAAa,CAAC;AAE1C;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,EAAE,wBAEnC,CAAC"}

package/dist/feature-libraries/node-key/nodeKey.js

@@ -0,0 +1,36 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeKeyTreeIdentifier = exports.nodeKeyFieldKey = exports.compareLocalNodeKeys = void 0;
+const util_1 = require("../../util");
+/**
+ * Compares two {@link LocalNodeKey}s.
+ * All {@link LocalNodeKey}s retrieved from a single SharedTree client can be totally ordered using this comparator.
+ * @param a - the first key to compare
+ * @param b - the second key to compare
+ * @returns `0` if `a` and `b` are the same key, otherwise `-1` if `a` is ordered before `b` or `1` if `a` is ordered after `b`.
+ * @internal
+ */
+function compareLocalNodeKeys(a, b) {
+    return a === b ? 0 : a > b ? 1 : -1;
+}
+exports.compareLocalNodeKeys = compareLocalNodeKeys;
+/**
+ * The key for the special field for {@link LocalNodeKey}s,
+ * which allows nodes to be given keys that can be used to find the nodes via the node key index.
+ * @internal
+ * @privateRemarks TODO: Come up with a unified and collision-resistant naming schema for fields defined by the system.
+ * For now, we'll use `__` to reduce the change of collision, since this is what other internal properties use in Fluid.
+ */
+exports.nodeKeyFieldKey = "__n_id__";
+/**
+ * The TreeNodeSchemaIdentifier for node keys.
+ * @internal
+ * @privateRemarks TODO: Come up with a unified and collision-resistant naming schema for types defined by the system.
+ * For now, we'll use `__` to reduce the change of collision, since this is what other internal properties use in Fluid.
+ */
+exports.nodeKeyTreeIdentifier = (0, util_1.brand)("com.fluidframework.nodeKey.NodeKey");
+//# sourceMappingURL=nodeKey.js.map

package/dist/feature-libraries/node-key/nodeKey.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodeKey.js","sourceRoot":"","sources":["../../../src/feature-libraries/node-key/nodeKey.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAGH,qCAAkD;AAsBlD;;;;;;;GAOG;AACH,SAAgB,oBAAoB,CAAC,CAAe,EAAE,CAAe;IACpE,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACrC,CAAC;AAFD,oDAEC;AAED;;;;;;GAMG;AACU,QAAA,eAAe,GAAG,UAAU,CAAC;AAE1C;;;;;GAKG;AACU,QAAA,qBAAqB,GAA6B,IAAA,YAAK,EACnE,oCAAoC,CACpC,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { SessionSpaceCompressedId, StableId } from \"@fluidframework/runtime-definitions\";\nimport { Brand, Opaque, brand } from \"../../util\";\nimport { TreeNodeSchemaIdentifier } from \"../../core\";\n\n/**\n * A key which uniquely identifies a node in the tree within this session.\n * @remarks {@link LocalNodeKey}s must not be serialized and stored as data without first being converted into a {@link StableNodeKey}.\n * They are local to the current session and equivalent nodes in another session will not necessarily have the same {@link LocalNodeKey}.\n * However, they are otherwise preferential to use over {@link StableNodeKey}s as they are much smaller.\n * For example, they are more efficient than {@link StableNodeKey}s when used as keys in a map.\n * {@link LocalNodeKey}s may be compared or equated via {@link compareLocalNodeKeys}.\n * @internal\n */\nexport interface LocalNodeKey extends Opaque<Brand<SessionSpaceCompressedId, \"Local Node Key\">> {}\n\n/**\n * A UUID which identifies a node in the tree.\n * This key is universally unique and stable forever; therefore it is safe to persist as data in a SharedTree or other DDS/database.\n * When not persisted or serialized, it is preferable to use a {@link LocalNodeKey} instead for better performance.\n * @internal\n */\nexport type StableNodeKey = Brand<StableId, \"Stable Node Key\">;\n\n/**\n * Compares two {@link LocalNodeKey}s.\n * All {@link LocalNodeKey}s retrieved from a single SharedTree client can be totally ordered using this comparator.\n * @param a - the first key to compare\n * @param b - the second key to compare\n * @returns `0` if `a` and `b` are the same key, otherwise `-1` if `a` is ordered before `b` or `1` if `a` is ordered after `b`.\n * @internal\n */\nexport function compareLocalNodeKeys(a: LocalNodeKey, b: LocalNodeKey): -1 | 0 | 1 {\n\treturn a === b ? 0 : a > b ? 1 : -1;\n}\n\n/**\n * The key for the special field for {@link LocalNodeKey}s,\n * which allows nodes to be given keys that can be used to find the nodes via the node key index.\n * @internal\n * @privateRemarks TODO: Come up with a unified and collision-resistant naming schema for fields defined by the system.\n * For now, we'll use `__` to reduce the change of collision, since this is what other internal properties use in Fluid.\n */\nexport const nodeKeyFieldKey = \"__n_id__\";\n\n/**\n * The TreeNodeSchemaIdentifier for node keys.\n * @internal\n * @privateRemarks TODO: Come up with a unified and collision-resistant naming schema for types defined by the system.\n * For now, we'll use `__` to reduce the change of collision, since this is what other internal properties use in Fluid.\n */\nexport const nodeKeyTreeIdentifier: TreeNodeSchemaIdentifier = brand(\n\t\"com.fluidframework.nodeKey.NodeKey\",\n);\n"]}

package/dist/feature-libraries/node-key/nodeKeyIndex.d.ts

@@ -0,0 +1,41 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { FieldKey } from "../../core";
+import { FlexTreeObjectNode, FlexTreeContext } from "../flex-tree";
+import { FlexTreeSchema } from "../typed-schema";
+import { LocalNodeKey } from "./nodeKey";
+/**
+ * The node key index records nodes with {@link LocalNodeKey}s and allows them to be looked up by key.
+ */
+export declare class NodeKeyIndex implements ReadonlyMap<LocalNodeKey, FlexTreeObjectNode> {
+    readonly fieldKey: FieldKey;
+    private readonly nodes;
+    constructor(fieldKey: FieldKey, keys?: Iterable<[LocalNodeKey, FlexTreeObjectNode]>);
+    /**
+     * Returns true if the given schema contains the node key type, otherwise false
+     */
+    static hasNodeKeyTreeSchema(schema: FlexTreeSchema): boolean;
+    /**
+     * Search the tree for all nodes with keys, and record them in this index for lookup.
+     * This should be called each time the tree changes; each call to scan forgets all existing keys.
+     * @param context - the editable tree context in which to search for node keys
+     */
+    scanKeys(context: FlexTreeContext): void;
+    /**
+     * Create a copy of this index which can be mutated without affecting this one.
+     */
+    clone(context: FlexTreeContext): NodeKeyIndex;
+    forEach(callbackfn: (value: FlexTreeObjectNode, key: LocalNodeKey, map: ReadonlyMap<LocalNodeKey, FlexTreeObjectNode>) => void, thisArg?: any): void;
+    get(key: LocalNodeKey): FlexTreeObjectNode | undefined;
+    has(key: LocalNodeKey): boolean;
+    get size(): number;
+    entries(): IterableIterator<[LocalNodeKey, FlexTreeObjectNode]>;
+    keys(): IterableIterator<LocalNodeKey>;
+    values(): IterableIterator<FlexTreeObjectNode>;
+    [Symbol.iterator](): IterableIterator<[LocalNodeKey, FlexTreeObjectNode]>;
+    private findKeys;
+    private findKeysInField;
+}
+//# sourceMappingURL=nodeKeyIndex.d.ts.map

package/dist/feature-libraries/node-key/nodeKeyIndex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodeKeyIndex.d.ts","sourceRoot":"","sources":["../../../src/feature-libraries/node-key/nodeKeyIndex.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAE,QAAQ,EAAe,MAAM,YAAY,CAAC;AACnD,OAAO,EACN,kBAAkB,EAClB,eAAe,EAIf,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,cAAc,EAAsC,MAAM,iBAAiB,CAAC;AACrF,OAAO,EAAE,YAAY,EAAyB,MAAM,WAAW,CAAC;AAEhE;;GAEG;AACH,qBAAa,YAAa,YAAW,WAAW,CAAC,YAAY,EAAE,kBAAkB,CAAC;aAKhE,QAAQ,EAAE,QAAQ;IAHnC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAwC;gBAG7C,QAAQ,EAAE,QAAQ,EAClC,IAAI,GAAE,QAAQ,CAAC,CAAC,YAAY,EAAE,kBAAkB,CAAC,CAAM;IAKxD;;OAEG;WACW,oBAAoB,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO;IASnE;;;;OAIG;IAEI,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,IAAI;IAa/C;;OAEG;IACI,KAAK,CAAC,OAAO,EAAE,eAAe,GAAG,YAAY;IAO7C,OAAO,CACb,UAAU,EAAE,CACX,KAAK,EAAE,kBAAkB,EACzB,GAAG,EAAE,YAAY,EACjB,GAAG,EAAE,WAAW,CAAC,YAAY,EAAE,kBAAkB,CAAC,KAC9C,IAAI,EACT,OAAO,CAAC,EAAE,GAAG,GACX,IAAI;IAGA,GAAG,CAAC,GAAG,EAAE,YAAY,GAAG,kBAAkB,GAAG,SAAS;IAGtD,GAAG,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO;IAGtC,IAAW,IAAI,IAAI,MAAM,CAExB;IACM,OAAO,IAAI,gBAAgB,CAAC,CAAC,YAAY,EAAE,kBAAkB,CAAC,CAAC;IAG/D,IAAI,IAAI,gBAAgB,CAAC,YAAY,CAAC;IAGtC,MAAM,IAAI,gBAAgB,CAAC,kBAAkB,CAAC;IAG9C,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,gBAAgB,CAAC,CAAC,YAAY,EAAE,kBAAkB,CAAC,CAAC;IAKhF,OAAO,CAAE,QAAQ;IAYjB,OAAO,CAAE,eAAe;CAOxB"}

package/dist/feature-libraries/node-key/nodeKeyIndex.js

@@ -0,0 +1,102 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeKeyIndex = void 0;
+const core_utils_1 = require("@fluidframework/core-utils");
+const core_1 = require("../../core");
+const flex_tree_1 = require("../flex-tree");
+const typed_schema_1 = require("../typed-schema");
+const nodeKey_1 = require("./nodeKey");
+/**
+ * The node key index records nodes with {@link LocalNodeKey}s and allows them to be looked up by key.
+ */
+class NodeKeyIndex {
+    constructor(fieldKey, keys = []) {
+        this.fieldKey = fieldKey;
+        this.nodes = new Map(keys);
+    }
+    /**
+     * Returns true if the given schema contains the node key type, otherwise false
+     */
+    static hasNodeKeyTreeSchema(schema) {
+        // TODO: make TreeStoredSchema contain ViewSchema and compare by reference to nodeKeyTreeSchema.
+        const treeSchema = schema.nodeSchema.get(nodeKey_1.nodeKeyTreeIdentifier);
+        if (!(treeSchema instanceof typed_schema_1.LeafNodeSchema)) {
+            return false;
+        }
+        return treeSchema.leafValue === core_1.ValueSchema.String;
+    }
+    /**
+     * Search the tree for all nodes with keys, and record them in this index for lookup.
+     * This should be called each time the tree changes; each call to scan forgets all existing keys.
+     * @param context - the editable tree context in which to search for node keys
+     */
+    // TODO: This can be optimized by responding to deltas/changes to the tree, rather than rescanning the whole tree every time
+    scanKeys(context) {
+        this.nodes.clear();
+        if (NodeKeyIndex.hasNodeKeyTreeSchema(context.schema)) {
+            for (const [id, node] of this.findKeysInField(context.root)) {
+                // TODO:
+                // This invariant (that there is only one node with a given key) is not enforced by tree, so it should not assert.
+                // Multiple nodes (including deleted ones), might occur with the same key.
+                (0, core_utils_1.assert)(!this.nodes.has(id), 0x6e1 /* Encountered duplicate node key */);
+                this.nodes.set(id, node);
+            }
+        }
+    }
+    /**
+     * Create a copy of this index which can be mutated without affecting this one.
+     */
+    clone(context) {
+        const indexClone = new NodeKeyIndex(this.fieldKey);
+        indexClone.scanKeys(context);
+        return indexClone;
+    }
+    // #region ReadonlyMap interface
+    forEach(callbackfn, thisArg) {
+        return this.nodes.forEach(callbackfn, thisArg);
+    }
+    get(key) {
+        return this.nodes.get(key);
+    }
+    has(key) {
+        return this.nodes.has(key);
+    }
+    get size() {
+        return this.nodes.size;
+    }
+    entries() {
+        return this.nodes.entries();
+    }
+    keys() {
+        return this.nodes.keys();
+    }
+    values() {
+        return this.nodes.values();
+    }
+    [Symbol.iterator]() {
+        return this.nodes[Symbol.iterator]();
+    }
+    // #endregion ReadonlyMap interface
+    *findKeys(node) {
+        if ((0, typed_schema_1.schemaIsObjectNode)(node.schema)) {
+            const key = node.localNodeKey;
+            if (key !== undefined) {
+                yield [key, node];
+            }
+        }
+        for (const f of node[flex_tree_1.boxedIterator]()) {
+            yield* this.findKeysInField(f);
+        }
+    }
+    *findKeysInField(f) {
+        for (const child of f[flex_tree_1.boxedIterator]()) {
+            yield* this.findKeys(child);
+        }
+    }
+}
+exports.NodeKeyIndex = NodeKeyIndex;
+//# sourceMappingURL=nodeKeyIndex.js.map

package/dist/feature-libraries/node-key/nodeKeyIndex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodeKeyIndex.js","sourceRoot":"","sources":["../../../src/feature-libraries/node-key/nodeKeyIndex.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 { assert } from \"@fluidframework/core-utils\";\nimport { FieldKey, ValueSchema } from \"../../core\";\nimport {\n\tFlexTreeObjectNode,\n\tFlexTreeContext,\n\tFlexTreeField,\n\tFlexTreeNode,\n\tboxedIterator,\n} from \"../flex-tree\";\nimport { FlexTreeSchema, LeafNodeSchema, schemaIsObjectNode } from \"../typed-schema\";\nimport { LocalNodeKey, nodeKeyTreeIdentifier } from \"./nodeKey\";\n\n/**\n * The node key index records nodes with {@link LocalNodeKey}s and allows them to be looked up by key.\n */\nexport class NodeKeyIndex implements ReadonlyMap<LocalNodeKey, FlexTreeObjectNode> {\n\t// TODO: The data structure that holds the nodes can likely be optimized to better support cloning\n\tprivate readonly nodes: Map<LocalNodeKey, FlexTreeObjectNode>;\n\n\tpublic constructor(\n\t\tpublic readonly fieldKey: FieldKey,\n\t\tkeys: Iterable<[LocalNodeKey, FlexTreeObjectNode]> = [],\n\t) {\n\t\tthis.nodes = new Map(keys);\n\t}\n\n\t/**\n\t * Returns true if the given schema contains the node key type, otherwise false\n\t */\n\tpublic static hasNodeKeyTreeSchema(schema: FlexTreeSchema): boolean {\n\t\t// TODO: make TreeStoredSchema contain ViewSchema and compare by reference to nodeKeyTreeSchema.\n\t\tconst treeSchema = schema.nodeSchema.get(nodeKeyTreeIdentifier);\n\t\tif (!(treeSchema instanceof LeafNodeSchema)) {\n\t\t\treturn false;\n\t\t}\n\t\treturn treeSchema.leafValue === ValueSchema.String;\n\t}\n\n\t/**\n\t * Search the tree for all nodes with keys, and record them in this index for lookup.\n\t * This should be called each time the tree changes; each call to scan forgets all existing keys.\n\t * @param context - the editable tree context in which to search for node keys\n\t */\n\t// TODO: This can be optimized by responding to deltas/changes to the tree, rather than rescanning the whole tree every time\n\tpublic scanKeys(context: FlexTreeContext): void {\n\t\tthis.nodes.clear();\n\t\tif (NodeKeyIndex.hasNodeKeyTreeSchema(context.schema)) {\n\t\t\tfor (const [id, node] of this.findKeysInField(context.root)) {\n\t\t\t\t// TODO:\n\t\t\t\t// This invariant (that there is only one node with a given key) is not enforced by tree, so it should not assert.\n\t\t\t\t// Multiple nodes (including deleted ones), might occur with the same key.\n\t\t\t\tassert(!this.nodes.has(id), 0x6e1 /* Encountered duplicate node key */);\n\t\t\t\tthis.nodes.set(id, node);\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * Create a copy of this index which can be mutated without affecting this one.\n\t */\n\tpublic clone(context: FlexTreeContext): NodeKeyIndex {\n\t\tconst indexClone = new NodeKeyIndex(this.fieldKey);\n\t\tindexClone.scanKeys(context);\n\t\treturn indexClone;\n\t}\n\n\t// #region ReadonlyMap interface\n\tpublic forEach(\n\t\tcallbackfn: (\n\t\t\tvalue: FlexTreeObjectNode,\n\t\t\tkey: LocalNodeKey,\n\t\t\tmap: ReadonlyMap<LocalNodeKey, FlexTreeObjectNode>,\n\t\t) => void,\n\t\tthisArg?: any,\n\t): void {\n\t\treturn this.nodes.forEach(callbackfn, thisArg);\n\t}\n\tpublic get(key: LocalNodeKey): FlexTreeObjectNode | undefined {\n\t\treturn this.nodes.get(key);\n\t}\n\tpublic has(key: LocalNodeKey): boolean {\n\t\treturn this.nodes.has(key);\n\t}\n\tpublic get size(): number {\n\t\treturn this.nodes.size;\n\t}\n\tpublic entries(): IterableIterator<[LocalNodeKey, FlexTreeObjectNode]> {\n\t\treturn this.nodes.entries();\n\t}\n\tpublic keys(): IterableIterator<LocalNodeKey> {\n\t\treturn this.nodes.keys();\n\t}\n\tpublic values(): IterableIterator<FlexTreeObjectNode> {\n\t\treturn this.nodes.values();\n\t}\n\tpublic [Symbol.iterator](): IterableIterator<[LocalNodeKey, FlexTreeObjectNode]> {\n\t\treturn this.nodes[Symbol.iterator]();\n\t}\n\t// #endregion ReadonlyMap interface\n\n\tprivate *findKeys(node: FlexTreeNode): Iterable<[key: LocalNodeKey, node: FlexTreeObjectNode]> {\n\t\tif (schemaIsObjectNode(node.schema)) {\n\t\t\tconst key = (node as FlexTreeObjectNode).localNodeKey;\n\t\t\tif (key !== undefined) {\n\t\t\t\tyield [key, node as FlexTreeObjectNode];\n\t\t\t}\n\t\t}\n\t\tfor (const f of node[boxedIterator]()) {\n\t\t\tyield* this.findKeysInField(f);\n\t\t}\n\t}\n\n\tprivate *findKeysInField(\n\t\tf: FlexTreeField,\n\t): Iterable<[key: LocalNodeKey, node: FlexTreeObjectNode]> {\n\t\tfor (const child of f[boxedIterator]()) {\n\t\t\tyield* this.findKeys(child);\n\t\t}\n\t}\n}\n"]}

package/dist/feature-libraries/node-key/nodeKeyManager.d.ts

@@ -0,0 +1,36 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { IIdCompressor } from "@fluidframework/id-compressor";
+import { StableNodeKey, LocalNodeKey } from "./nodeKey";
+/**
+ * An object which handles the generation of node keys as well as conversion between their two types ({@link StableNodeKey} and {@link LocalNodeKey}).
+ */
+export interface NodeKeyManager {
+    /**
+     * Generate a {@link StableNodeKey}.
+     */
+    generateLocalNodeKey(): LocalNodeKey;
+    /**
+     * Convert the given {@link StableNodeKey} into its {@link LocalNodeKey} form.
+     */
+    localizeNodeKey(key: StableNodeKey): LocalNodeKey;
+    /**
+     * Convert the given {@link LocalNodeKey} into its {@link StableNodeKey} form.
+     */
+    stabilizeNodeKey(key: LocalNodeKey): StableNodeKey;
+}
+/**
+ * Creates a {@link NodeKeyManager} from the given {@link IIdCompressor}.
+ * @param idCompressor - the compressor to use for key generation, compression, and decompression.
+ * If undefined, then attempts to generate or convert keys will throw an error.
+ */
+export declare function createNodeKeyManager(idCompressor?: IIdCompressor | undefined): NodeKeyManager;
+/**
+ * Create a {@link NodeKeyManager} that generates deterministic {@link StableNodeKey}s and {@link LocalNodeKey}s.
+ * @remarks This is useful for test environments because it will always yield the same keys in the same order.
+ * It should not be used for production environments for the same reason; the {@link StableNodeKey}s are not universally unique.
+ */
+export declare function createMockNodeKeyManager(): NodeKeyManager;
+//# sourceMappingURL=nodeKeyManager.d.ts.map

package/dist/feature-libraries/node-key/nodeKeyManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodeKeyManager.d.ts","sourceRoot":"","sources":["../../../src/feature-libraries/node-key/nodeKeyManager.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAEN,aAAa,EAGb,MAAM,+BAA+B,CAAC;AAEvC,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAExD;;GAEG;AACH,MAAM,WAAW,cAAc;IAC9B;;OAEG;IACH,oBAAoB,IAAI,YAAY,CAAC;IAErC;;OAEG;IACH,eAAe,CAAC,GAAG,EAAE,aAAa,GAAG,YAAY,CAAC;IAElD;;OAEG;IACH,gBAAgB,CAAC,GAAG,EAAE,YAAY,GAAG,aAAa,CAAC;CACnD;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,YAAY,CAAC,EAAE,aAAa,GAAG,SAAS,GAAG,cAAc,CA6B7F;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,IAAI,cAAc,CAEzD"}

package/dist/feature-libraries/node-key/nodeKeyManager.js

@@ -0,0 +1,66 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMockNodeKeyManager = exports.createNodeKeyManager = void 0;
+const core_utils_1 = require("@fluidframework/core-utils");
+const id_compressor_1 = require("@fluidframework/id-compressor");
+const util_1 = require("../../util");
+/**
+ * Creates a {@link NodeKeyManager} from the given {@link IIdCompressor}.
+ * @param idCompressor - the compressor to use for key generation, compression, and decompression.
+ * If undefined, then attempts to generate or convert keys will throw an error.
+ */
+function createNodeKeyManager(idCompressor) {
+    return {
+        generateLocalNodeKey: () => {
+            (0, core_utils_1.assert)(idCompressor !== undefined, 0x6e4 /* Runtime IdCompressor must be available to generate local node keys */);
+            return (0, util_1.brand)(idCompressor.generateCompressedId());
+        },
+        localizeNodeKey: (key) => {
+            (0, core_utils_1.assert)(idCompressor !== undefined, 0x6e5 /* Runtime IdCompressor must be available to convert node keys */);
+            return (0, util_1.brand)(idCompressor.recompress(key));
+        },
+        stabilizeNodeKey: (key) => {
+            (0, core_utils_1.assert)(idCompressor !== undefined, 0x6e6 /* Runtime IdCompressor must be available to convert node keys */);
+            return (0, util_1.brand)(
+            // TODO: The assert below is required for type safety but is maybe slow
+            (0, id_compressor_1.assertIsStableId)(idCompressor.decompress((0, util_1.extractFromOpaque)(key))));
+        },
+    };
+}
+exports.createNodeKeyManager = createNodeKeyManager;
+/**
+ * Create a {@link NodeKeyManager} that generates deterministic {@link StableNodeKey}s and {@link LocalNodeKey}s.
+ * @remarks This is useful for test environments because it will always yield the same keys in the same order.
+ * It should not be used for production environments for the same reason; the {@link StableNodeKey}s are not universally unique.
+ */
+function createMockNodeKeyManager() {
+    return new MockNodeKeyManager();
+}
+exports.createMockNodeKeyManager = createMockNodeKeyManager;
+class MockNodeKeyManager {
+    constructor() {
+        this.count = 0;
+    }
+    generateStableNodeKey() {
+        return (0, util_1.brand)(this.createMockStableId(this.count++));
+    }
+    generateLocalNodeKey() {
+        return this.localizeNodeKey(this.generateStableNodeKey());
+    }
+    localizeNodeKey(key) {
+        return (0, util_1.brand)(Number.parseInt(key.substring(30), 16));
+    }
+    stabilizeNodeKey(key) {
+        return (0, util_1.brand)(this.createMockStableId((0, util_1.extractFromOpaque)(key)));
+    }
+    createMockStableId(offset) {
+        (0, core_utils_1.assert)(offset >= 0, 0x6e7 /* UUID offset may not be negative */);
+        (0, core_utils_1.assert)(offset < 281474976710656, 0x6e8 /* UUID offset must be at most 16^12 */);
+        return (0, id_compressor_1.assertIsStableId)(`a110ca7e-add1-4000-8000-${Math.round(offset).toString(16).padStart(12, "0")}`);
+    }
+}
+//# sourceMappingURL=nodeKeyManager.js.map

package/dist/feature-libraries/node-key/nodeKeyManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodeKeyManager.js","sourceRoot":"","sources":["../../../src/feature-libraries/node-key/nodeKeyManager.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,2DAAoD;AACpD,iEAKuC;AACvC,qCAAsD;AAuBtD;;;;GAIG;AACH,SAAgB,oBAAoB,CAAC,YAAwC;IAC5E,OAAO;QACN,oBAAoB,EAAE,GAAG,EAAE;YAC1B,IAAA,mBAAM,EACL,YAAY,KAAK,SAAS,EAC1B,KAAK,CAAC,wEAAwE,CAC9E,CAAC;YACF,OAAO,IAAA,YAAK,EAAC,YAAY,CAAC,oBAAoB,EAAE,CAAC,CAAC;QACnD,CAAC;QAED,eAAe,EAAE,CAAC,GAAkB,EAAE,EAAE;YACvC,IAAA,mBAAM,EACL,YAAY,KAAK,SAAS,EAC1B,KAAK,CAAC,iEAAiE,CACvE,CAAC;YACF,OAAO,IAAA,YAAK,EAAC,YAAY,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC;QAC5C,CAAC;QAED,gBAAgB,EAAE,CAAC,GAAiB,EAAE,EAAE;YACvC,IAAA,mBAAM,EACL,YAAY,KAAK,SAAS,EAC1B,KAAK,CAAC,iEAAiE,CACvE,CAAC;YACF,OAAO,IAAA,YAAK;YACX,uEAAuE;YACvE,IAAA,gCAAgB,EAAC,YAAY,CAAC,UAAU,CAAC,IAAA,wBAAiB,EAAC,GAAG,CAAC,CAAC,CAAC,CACjE,CAAC;QACH,CAAC;KACD,CAAC;AACH,CAAC;AA7BD,oDA6BC;AAED;;;;GAIG;AACH,SAAgB,wBAAwB;IACvC,OAAO,IAAI,kBAAkB,EAAE,CAAC;AACjC,CAAC;AAFD,4DAEC;AAED,MAAM,kBAAkB;IAAxB;QACS,UAAK,GAAG,CAAC,CAAC;IAyBnB,CAAC;IAvBO,qBAAqB;QAC3B,OAAO,IAAA,YAAK,EAAC,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;IACrD,CAAC;IAEM,oBAAoB;QAC1B,OAAO,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,qBAAqB,EAAE,CAAC,CAAC;IAC3D,CAAC;IAEM,eAAe,CAAC,GAAkB;QACxC,OAAO,IAAA,YAAK,EAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC,EAAE,EAAE,CAA6B,CAAC,CAAC;IAClF,CAAC;IAEM,gBAAgB,CAAC,GAAiB;QACxC,OAAO,IAAA,YAAK,EAAC,IAAI,CAAC,kBAAkB,CAAC,IAAA,wBAAiB,EAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IAC/D,CAAC;IAEO,kBAAkB,CAAC,MAAc;QACxC,IAAA,mBAAM,EAAC,MAAM,IAAI,CAAC,EAAE,KAAK,CAAC,qCAAqC,CAAC,CAAC;QACjE,IAAA,mBAAM,EAAC,MAAM,GAAG,eAAmB,EAAE,KAAK,CAAC,uCAAuC,CAAC,CAAC;QACpF,OAAO,IAAA,gCAAgB,EACtB,2BAA2B,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,EAAE,EAAE,GAAG,CAAC,EAAE,CAC9E,CAAC;IACH,CAAC;CACD","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 {\n\tassertIsStableId,\n\tIIdCompressor,\n\tSessionSpaceCompressedId,\n\tStableId,\n} from \"@fluidframework/id-compressor\";\nimport { brand, extractFromOpaque } from \"../../util\";\nimport { StableNodeKey, LocalNodeKey } from \"./nodeKey\";\n\n/**\n * An object which handles the generation of node keys as well as conversion between their two types ({@link StableNodeKey} and {@link LocalNodeKey}).\n */\nexport interface NodeKeyManager {\n\t/**\n\t * Generate a {@link StableNodeKey}.\n\t */\n\tgenerateLocalNodeKey(): LocalNodeKey;\n\n\t/**\n\t * Convert the given {@link StableNodeKey} into its {@link LocalNodeKey} form.\n\t */\n\tlocalizeNodeKey(key: StableNodeKey): LocalNodeKey;\n\n\t/**\n\t * Convert the given {@link LocalNodeKey} into its {@link StableNodeKey} form.\n\t */\n\tstabilizeNodeKey(key: LocalNodeKey): StableNodeKey;\n}\n\n/**\n * Creates a {@link NodeKeyManager} from the given {@link IIdCompressor}.\n * @param idCompressor - the compressor to use for key generation, compression, and decompression.\n * If undefined, then attempts to generate or convert keys will throw an error.\n */\nexport function createNodeKeyManager(idCompressor?: IIdCompressor | undefined): NodeKeyManager {\n\treturn {\n\t\tgenerateLocalNodeKey: () => {\n\t\t\tassert(\n\t\t\t\tidCompressor !== undefined,\n\t\t\t\t0x6e4 /* Runtime IdCompressor must be available to generate local node keys */,\n\t\t\t);\n\t\t\treturn brand(idCompressor.generateCompressedId());\n\t\t},\n\n\t\tlocalizeNodeKey: (key: StableNodeKey) => {\n\t\t\tassert(\n\t\t\t\tidCompressor !== undefined,\n\t\t\t\t0x6e5 /* Runtime IdCompressor must be available to convert node keys */,\n\t\t\t);\n\t\t\treturn brand(idCompressor.recompress(key));\n\t\t},\n\n\t\tstabilizeNodeKey: (key: LocalNodeKey) => {\n\t\t\tassert(\n\t\t\t\tidCompressor !== undefined,\n\t\t\t\t0x6e6 /* Runtime IdCompressor must be available to convert node keys */,\n\t\t\t);\n\t\t\treturn brand(\n\t\t\t\t// TODO: The assert below is required for type safety but is maybe slow\n\t\t\t\tassertIsStableId(idCompressor.decompress(extractFromOpaque(key))),\n\t\t\t);\n\t\t},\n\t};\n}\n\n/**\n * Create a {@link NodeKeyManager} that generates deterministic {@link StableNodeKey}s and {@link LocalNodeKey}s.\n * @remarks This is useful for test environments because it will always yield the same keys in the same order.\n * It should not be used for production environments for the same reason; the {@link StableNodeKey}s are not universally unique.\n */\nexport function createMockNodeKeyManager(): NodeKeyManager {\n\treturn new MockNodeKeyManager();\n}\n\nclass MockNodeKeyManager implements NodeKeyManager {\n\tprivate count = 0;\n\n\tpublic generateStableNodeKey(): StableNodeKey {\n\t\treturn brand(this.createMockStableId(this.count++));\n\t}\n\n\tpublic generateLocalNodeKey(): LocalNodeKey {\n\t\treturn this.localizeNodeKey(this.generateStableNodeKey());\n\t}\n\n\tpublic localizeNodeKey(key: StableNodeKey): LocalNodeKey {\n\t\treturn brand(Number.parseInt(key.substring(30), 16) as SessionSpaceCompressedId);\n\t}\n\n\tpublic stabilizeNodeKey(key: LocalNodeKey): StableNodeKey {\n\t\treturn brand(this.createMockStableId(extractFromOpaque(key)));\n\t}\n\n\tprivate createMockStableId(offset: number): StableId {\n\t\tassert(offset >= 0, 0x6e7 /* UUID offset may not be negative */);\n\t\tassert(offset < 281_474_976_710_656, 0x6e8 /* UUID offset must be at most 16^12 */);\n\t\treturn assertIsStableId(\n\t\t\t`a110ca7e-add1-4000-8000-${Math.round(offset).toString(16).padStart(12, \"0\")}`,\n\t\t);\n\t}\n}\n"]}

package/dist/feature-libraries/object-forest/index.d.ts

@@ -0,0 +1,6 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+export { buildForest } from "./objectForest";
+//# sourceMappingURL=index.d.ts.map

package/dist/feature-libraries/object-forest/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/feature-libraries/object-forest/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/feature-libraries/object-forest/index.js

@@ -0,0 +1,10 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildForest = void 0;
+var objectForest_1 = require("./objectForest");
+Object.defineProperty(exports, "buildForest", { enumerable: true, get: function () { return objectForest_1.buildForest; } });
+//# sourceMappingURL=index.js.map

package/dist/feature-libraries/object-forest/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/feature-libraries/object-forest/index.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,+CAA6C;AAApC,2GAAA,WAAW,OAAA","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nexport { buildForest } from \"./objectForest\";\n"]}

package/dist/feature-libraries/object-forest/objectForest.d.ts

@@ -0,0 +1,86 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { ITreeSubscriptionCursor, IEditableForest, ITreeSubscriptionCursorState, TreeNavigationResult, TreeStoredSchemaSubscription, FieldKey, DetachedField, AnchorSet, UpPath, Anchor, CursorLocationType, TreeNodeSchemaIdentifier, MapTree, FieldAnchor, FieldUpPath, ForestEvents, PathRootPrefix, DeltaVisitor, Value, ITreeCursorSynchronous } from "../../core";
+import { CursorWithNode, SynchronousCursor } from "../treeCursorUtils";
+/**
+ * Reference implementation of IEditableForest.
+ *
+ * This implementation focuses on correctness and simplicity, not performance.
+ * It does not use compressed chunks: instead nodes are implemented using objects.
+ */
+export declare class ObjectForest implements IEditableForest {
+    readonly anchors: AnchorSet;
+    private activeVisitor?;
+    readonly roots: MapTree;
+    readonly currentCursors: Set<Cursor>;
+    private readonly events;
+    constructor(anchors?: AnchorSet);
+    get isEmpty(): boolean;
+    on<K extends keyof ForestEvents>(eventName: K, listener: ForestEvents[K]): () => void;
+    clone(_: TreeStoredSchemaSubscription, anchors: AnchorSet): ObjectForest;
+    forgetAnchor(anchor: Anchor): void;
+    acquireVisitor(): DeltaVisitor;
+    private nextRange;
+    newDetachedField(): DetachedField;
+    private add;
+    private addFieldAsDetached;
+    private delete;
+    allocateCursor(): Cursor;
+    tryMoveCursorToNode(destination: Anchor, cursorToMove: ITreeSubscriptionCursor): TreeNavigationResult;
+    tryMoveCursorToField(destination: FieldAnchor, cursorToMove: ITreeSubscriptionCursor): TreeNavigationResult;
+    moveCursorToPath(destination: UpPath | undefined, cursorToMove: ITreeSubscriptionCursor): void;
+    getCursorAboveDetachedFields(): ITreeCursorSynchronous;
+}
+/**
+ * Cursor implementation for ObjectForest.
+ */
+declare class Cursor extends SynchronousCursor implements ITreeSubscriptionCursor {
+    readonly forest: ObjectForest;
+    private innerCursor?;
+    state: ITreeSubscriptionCursorState;
+    /**
+     * @param forest - forest this cursor navigates
+     * @param innerCursor - underlying cursor implementation this wraps. `undefined` when state is not `Current`
+     */
+    constructor(forest: ObjectForest, innerCursor?: CursorWithNode<MapTree> | undefined);
+    buildFieldAnchor(): FieldAnchor;
+    getFieldPath(prefix?: PathRootPrefix): FieldUpPath;
+    get mode(): CursorLocationType;
+    nextField(): boolean;
+    exitField(): void;
+    skipPendingFields(): boolean;
+    getFieldKey(): FieldKey;
+    getFieldLength(): number;
+    firstNode(): boolean;
+    enterNode(childIndex: number): void;
+    getPath(prefix?: PathRootPrefix): UpPath;
+    get fieldIndex(): number;
+    get chunkStart(): number;
+    get chunkLength(): number;
+    seekNodes(offset: number): boolean;
+    nextNode(): boolean;
+    exitNode(): void;
+    firstField(): boolean;
+    enterField(key: FieldKey): void;
+    get type(): TreeNodeSchemaIdentifier;
+    get value(): Value;
+    clear(): void;
+    /**
+     * Move this cursor to the special dummy node above the detached sequences.
+     * Can be used when cleared (but not freed).
+     */
+    setToAboveDetachedSequences(): void;
+    getNode(): MapTree;
+    getParent(): [MapTree, FieldKey];
+    fork(): ITreeSubscriptionCursor;
+    free(): void;
+    buildAnchor(): Anchor;
+}
+/**
+ * @returns an implementation of {@link IEditableForest} with no data or schema.
+ */
+export declare function buildForest(anchors?: AnchorSet): ObjectForest;
+export {};
+//# sourceMappingURL=objectForest.d.ts.map

package/dist/feature-libraries/object-forest/objectForest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"objectForest.d.ts","sourceRoot":"","sources":["../../../src/feature-libraries/object-forest/objectForest.ts"],"names":[],"mappings":"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"}