@fluidframework/tree 2.80.0 → 2.81.0

package/dist/shared-tree/treeAlpha.js

@@ -7,32 +7,32 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TreeAlpha = void 0;
 const internal_1 = require("@fluidframework/core-utils/internal");
 const internal_2 = require("@fluidframework/id-compressor/internal");
+const runtime_utils_1 = require("@fluidframework/runtime-utils");
 const internal_3 = require("@fluidframework/telemetry-utils/internal");
-const index_js_1 = require("../simple-tree/index.js");
-const index_js_2 = require("../util/index.js");
-const index_js_3 = require("../codec/index.js");
-const index_js_4 = require("../core/index.js");
-const index_js_5 = require("../feature-libraries/index.js");
+const index_js_1 = require("../codec/index.js");
+const index_js_2 = require("../core/index.js");
+const index_js_3 = require("../feature-libraries/index.js");
+const index_js_4 = require("../simple-tree/index.js");
+const index_js_5 = require("../util/index.js");
 const independentView_js_1 = require("./independentView.js");
 const schematizingTreeView_js_1 = require("./schematizingTreeView.js");
-const runtime_utils_1 = require("@fluidframework/runtime-utils");
 const identifier = (node) => {
-    return (0, index_js_1.getIdentifierFromNode)(node, "uncompressed");
+    return (0, index_js_4.getIdentifierFromNode)(node, "uncompressed");
 };
 identifier.shorten = (branch, nodeIdentifier) => {
     (0, internal_1.assert)(branch instanceof schematizingTreeView_js_1.SchematizingSimpleTreeView, 0xcac /* Unexpected branch implementation */);
     const { nodeKeyManager } = branch;
     const localNodeKey = nodeKeyManager.tryLocalizeNodeIdentifier(nodeIdentifier);
-    return localNodeKey === undefined ? undefined : (0, index_js_2.extractFromOpaque)(localNodeKey);
+    return localNodeKey === undefined ? undefined : (0, index_js_5.extractFromOpaque)(localNodeKey);
 };
 identifier.lengthen = (branch, nodeIdentifier) => {
     (0, internal_1.assert)(branch instanceof schematizingTreeView_js_1.SchematizingSimpleTreeView, 0xcad /* Unexpected branch implementation */);
     const { nodeKeyManager } = branch;
-    const local = (0, index_js_2.brand)(nodeIdentifier);
+    const local = (0, index_js_5.brand)(nodeIdentifier);
     return nodeKeyManager.stabilizeNodeIdentifier(local);
 };
 identifier.getShort = (node) => {
-    const shortIdentifier = (0, index_js_1.getIdentifierFromNode)(node, "compressed");
+    const shortIdentifier = (0, index_js_4.getIdentifierFromNode)(node, "compressed");
     return typeof shortIdentifier === "number" ? shortIdentifier : undefined;
 };
 identifier.create = (branch) => {
@@ -50,16 +50,16 @@ class NodeSubscription {
     constructor(onInvalidation, flexNode) {
         this.onInvalidation = onInvalidation;
         // TODO:Performance: It is possible to optimize this to not use the public TreeNode API.
-        const node = (0, index_js_1.getOrCreateNodeFromInnerNode)(flexNode);
-        (0, internal_1.assert)(node instanceof index_js_1.TreeNode, 0xc54 /* Unexpected leaf value */);
+        const node = (0, index_js_4.getOrCreateNodeFromInnerNode)(flexNode);
+        (0, internal_1.assert)(node instanceof index_js_4.TreeNode, 0xc54 /* Unexpected leaf value */);
         const handler = (data) => {
             if (this.keys === undefined || data.changedProperties === undefined) {
                 this.onInvalidation();
             }
             else {
                 let keyMap;
-                const schema = index_js_1.treeNodeApi.schema(node);
-                if ((0, index_js_1.isObjectNodeSchema)(schema)) {
+                const schema = index_js_4.treeNodeApi.schema(node);
+                if ((0, index_js_4.isObjectNodeSchema)(schema)) {
                     keyMap = schema.storedKeyToPropertyKey;
                 }
                 // TODO:Performance: Ideally this would use Set.prototype.isDisjointFrom when available.
@@ -73,7 +73,7 @@ class NodeSubscription {
                 }
             }
         };
-        this.unsubscribe = index_js_1.TreeBeta.on(node, "nodeChanged", handler);
+        this.unsubscribe = index_js_4.TreeBeta.on(node, "nodeChanged", handler);
     }
     /**
      * Create an {@link Observer} which subscribes to what was observed in {@link NodeSubscription}s.
@@ -126,7 +126,7 @@ class NodeSubscription {
                     // TODO: better APIS should be provided which make handling this case practical.
                     throw new internal_3.UsageError("Observation tracking for parents is currently not supported.");
                 }
-                const parent = (0, index_js_5.withObservation)(undefined, () => node.parentField.parent);
+                const parent = (0, index_js_3.withObservation)(undefined, () => node.parentField.parent);
                 if (parent.parent === undefined) {
                     // TODO: better APIS should be provided which make handling this case practical.
                     throw new internal_3.UsageError("Observation tracking for parents is currently not supported when parent is undefined.");
@@ -161,7 +161,7 @@ function trackObservations(onInvalidation, trackDuring, onlyOnce = false) {
         onInvalidation();
     };
     const { observer, unsubscribe } = NodeSubscription.createObserver(invalidate, onlyOnce);
-    const result = (0, index_js_5.withObservation)(observer, trackDuring);
+    const result = (0, index_js_3.withObservation)(observer, trackDuring);
     observing = false;
     return {
         result,
@@ -187,7 +187,7 @@ exports.TreeAlpha = {
         return result;
     },
     branch(node) {
-        const kernel = (0, index_js_1.getKernel)(node);
+        const kernel = (0, index_js_4.getKernel)(node);
         if (!kernel.isHydrated()) {
             return undefined;
         }
@@ -196,41 +196,41 @@ exports.TreeAlpha = {
         return view;
     },
     create(schema, data) {
-        const mapTree = (0, index_js_1.unhydratedFlexTreeFromInsertable)(data, schema);
-        const result = mapTree === undefined ? undefined : (0, index_js_1.getOrCreateNodeFromInnerNode)(mapTree);
+        const mapTree = (0, index_js_4.unhydratedFlexTreeFromInsertable)(data, schema);
+        const result = mapTree === undefined ? undefined : (0, index_js_4.getOrCreateNodeFromInnerNode)(mapTree);
         return result;
     },
     importConcise(schema, data) {
-        return (0, index_js_1.importConcise)(schema, data);
+        return (0, index_js_4.importConcise)(schema, data);
     },
-    exportConcise: index_js_1.exportConcise,
+    exportConcise: index_js_4.exportConcise,
     importVerbose(schema, data, options) {
         const config = { ...options };
         // Create a config which is standalone, and thus can be used without having to refer back to the schema.
-        const schemalessConfig = (0, index_js_1.applySchemaToParserOptions)(schema, config);
+        const schemalessConfig = (0, index_js_4.applySchemaToParserOptions)(schema, config);
         if (data === undefined) {
-            const field = (0, index_js_1.normalizeFieldSchema)(schema);
-            if (field.kind !== index_js_1.FieldKind.Optional) {
+            const field = (0, index_js_4.normalizeFieldSchema)(schema);
+            if (field.kind !== index_js_4.FieldKind.Optional) {
                 throw new internal_3.UsageError("undefined provided for non-optional field.");
             }
             return undefined;
         }
-        const cursor = (0, index_js_1.cursorFromVerbose)(data, schemalessConfig);
-        return (0, index_js_1.createFromCursor)(schema, cursor, (0, index_js_1.getUnhydratedContext)(schema).flexContext.schema.rootFieldSchema);
+        const cursor = (0, index_js_4.cursorFromVerbose)(data, schemalessConfig);
+        return (0, index_js_4.createFromCursor)(schema, cursor, (0, index_js_4.getUnhydratedContext)(schema).flexContext.schema.rootFieldSchema);
     },
     exportVerbose(node, options) {
-        if ((0, index_js_5.isTreeValue)(node)) {
+        if ((0, index_js_3.isTreeValue)(node)) {
             return node;
         }
         const config = { ...options };
-        const cursor = (0, index_js_1.borrowCursorFromTreeNodeOrValue)(node);
-        const kernel = (0, index_js_1.getKernel)(node);
-        return (0, index_js_1.verboseFromCursor)(cursor, kernel.context, config);
+        const cursor = (0, index_js_4.borrowCursorFromTreeNodeOrValue)(node);
+        const kernel = (0, index_js_4.getKernel)(node);
+        return (0, index_js_4.verboseFromCursor)(cursor, kernel.context, config);
     },
     exportCompressed(node, options) {
-        const schema = (0, index_js_1.tryGetSchema)(node) ?? (0, internal_1.fail)(0xacf /* invalid input */);
-        const codec = (0, index_js_5.makeFieldBatchCodec)({
-            jsonValidator: index_js_3.FormatValidatorNoOp,
+        const schema = (0, index_js_4.tryGetSchema)(node) ?? (0, internal_1.fail)(0xacf /* invalid input */);
+        const codec = (0, index_js_3.makeFieldBatchCodec)({
+            jsonValidator: index_js_1.FormatValidatorNoOp,
             minVersionForCollab: options.minVersionForCollab,
         });
         const cursor = borrowFieldCursorFromTreeNodeOrValue(node);
@@ -239,58 +239,58 @@ exports.TreeAlpha = {
         const idCompressor = options.idCompressor ?? (0, internal_2.createIdCompressor)();
         // Grabbing an existing stored schema from the node is important to ensure that unknown optional fields can be preserved.
         // Note that if the node is unhydrated, this can result in all staged allowed types being included in the schema, which might be undesired.
-        const storedSchema = (0, index_js_1.isTreeNode)(node)
-            ? (0, index_js_1.getKernel)(node).context.flexContext.schema
-            : (0, index_js_1.toInitialSchema)(schema);
+        const storedSchema = (0, index_js_4.isTreeNode)(node)
+            ? (0, index_js_4.getKernel)(node).context.flexContext.schema
+            : (0, index_js_4.toInitialSchema)(schema);
         const context = {
-            encodeType: index_js_5.TreeCompressionStrategy.Compressed,
+            encodeType: index_js_3.TreeCompressionStrategy.Compressed,
             idCompressor,
             originatorId: idCompressor.localSessionId, // TODO: Why is this needed?
-            schema: { schema: storedSchema, policy: index_js_5.defaultSchemaPolicy },
+            schema: { schema: storedSchema, policy: index_js_3.defaultSchemaPolicy },
         };
         const result = codec.encode(batch, context);
         return result;
     },
     importCompressed(schema, compressedData, options) {
-        const config = new index_js_1.TreeViewConfigurationAlpha({ schema });
+        const config = new index_js_4.TreeViewConfigurationAlpha({ schema });
         const content = {
             // Always use a v1 schema codec for consistency.
             // TODO: reevaluate how staged schema should behave in schema import/export APIs before stabilizing this.
-            schema: (0, index_js_1.extractPersistedSchema)(config.schema, index_js_3.FluidClientVersion.v2_0, () => true),
+            schema: (0, index_js_4.extractPersistedSchema)(config.schema, index_js_1.FluidClientVersion.v2_0, () => true),
             tree: compressedData,
             idCompressor: options.idCompressor ?? (0, internal_2.createIdCompressor)(),
         };
         const view = (0, independentView_js_1.independentInitializedView)(config, options, content);
-        return index_js_1.TreeBeta.clone(view.root);
+        return index_js_4.TreeBeta.clone(view.root);
     },
     identifier,
     key2(node) {
         // If the parent is undefined, then this node is under the root field,
-        const parent = index_js_1.treeNodeApi.parent(node);
+        const parent = index_js_4.treeNodeApi.parent(node);
         if (parent === undefined) {
             return undefined;
         }
         // The flex-domain strictly operates in terms of "stored keys".
         // To find the associated developer-facing "property key", we need to look up the field associated with
         // the stored key from the flex-domain, and get property key its simple-domain counterpart was created with.
-        const storedKey = (0, index_js_1.getStoredKey)(node);
-        const parentSchema = index_js_1.treeNodeApi.schema(parent);
-        return (0, index_js_1.getPropertyKeyFromStoredKey)(parentSchema, storedKey);
+        const storedKey = (0, index_js_4.getStoredKey)(node);
+        const parentSchema = index_js_4.treeNodeApi.schema(parent);
+        return (0, index_js_4.getPropertyKeyFromStoredKey)(parentSchema, storedKey);
     },
     child: (node, propertyKey) => {
-        const flexNode = (0, index_js_1.getInnerNode)(node);
+        const flexNode = (0, index_js_4.getInnerNode)(node);
         (0, internal_1.debugAssert)(() => !flexNode.context.isDisposed() || "The provided tree node has been disposed.");
-        const schema = index_js_1.treeNodeApi.schema(node);
+        const schema = index_js_4.treeNodeApi.schema(node);
         switch (schema.kind) {
-            case index_js_1.NodeKind.Array: {
-                const sequence = flexNode.tryGetField(index_js_4.EmptyKey);
+            case index_js_4.NodeKind.Array: {
+                const sequence = flexNode.tryGetField(index_js_2.EmptyKey);
                 // Empty sequence - cannot have children.
                 if (sequence === undefined) {
                     return undefined;
                 }
                 const index = typeof propertyKey === "number"
                     ? propertyKey
-                    : (0, index_js_1.asIndex)(propertyKey, Number.POSITIVE_INFINITY);
+                    : (0, index_js_4.asIndex)(propertyKey, Number.POSITIVE_INFINITY);
                 // If the key is not a valid index, then there is no corresponding child.
                 if (index === undefined) {
                     return undefined;
@@ -300,32 +300,32 @@ exports.TreeAlpha = {
                 if (childFlexTree === undefined) {
                     return undefined;
                 }
-                return (0, index_js_1.getOrCreateNodeFromInnerUnboxedNode)(childFlexTree);
+                return (0, index_js_4.getOrCreateNodeFromInnerUnboxedNode)(childFlexTree);
             }
-            case index_js_1.NodeKind.Map: {
+            case index_js_4.NodeKind.Map: {
                 if (typeof propertyKey !== "string") {
                     // Map nodes only support string keys.
                     return undefined;
                 }
             }
             // Fall through
-            case index_js_1.NodeKind.Record:
-            case index_js_1.NodeKind.Object: {
+            case index_js_4.NodeKind.Record:
+            case index_js_4.NodeKind.Object: {
                 let storedKey = propertyKey;
-                if ((0, index_js_1.isObjectNodeSchema)(schema)) {
+                if ((0, index_js_4.isObjectNodeSchema)(schema)) {
                     const fieldSchema = schema.fields.get(String(propertyKey));
                     if (fieldSchema === undefined) {
                         return undefined;
                     }
                     storedKey = fieldSchema.storedKey;
                 }
-                const field = flexNode.tryGetField((0, index_js_2.brand)(String(storedKey)));
+                const field = flexNode.tryGetField((0, index_js_5.brand)(String(storedKey)));
                 if (field !== undefined) {
-                    return (0, index_js_1.tryGetTreeNodeForField)(field);
+                    return (0, index_js_4.tryGetTreeNodeForField)(field);
                 }
                 return undefined;
             }
-            case index_js_1.NodeKind.Leaf: {
+            case index_js_4.NodeKind.Leaf: {
                 (0, internal_1.fail)(0xbc3 /* Leaf schema associated with non-leaf tree node. */);
             }
             default: {
@@ -334,48 +334,48 @@ exports.TreeAlpha = {
         }
     },
     children(node) {
-        const flexNode = (0, index_js_1.getInnerNode)(node);
+        const flexNode = (0, index_js_4.getInnerNode)(node);
         (0, internal_1.debugAssert)(() => !flexNode.context.isDisposed() || "The provided tree node has been disposed.");
-        const schema = index_js_1.treeNodeApi.schema(node);
+        const schema = index_js_4.treeNodeApi.schema(node);
         const result = [];
         switch (schema.kind) {
-            case index_js_1.NodeKind.Array: {
-                const sequence = flexNode.tryGetField(index_js_4.EmptyKey);
+            case index_js_4.NodeKind.Array: {
+                const sequence = flexNode.tryGetField(index_js_2.EmptyKey);
                 if (sequence === undefined) {
                     break;
                 }
                 for (let index = 0; index < sequence.length; index++) {
                     const childFlexTree = sequence.at(index);
                     (0, internal_1.assert)(childFlexTree !== undefined, 0xbc4 /* Sequence child was undefined. */);
-                    const childTree = (0, index_js_1.getOrCreateNodeFromInnerUnboxedNode)(childFlexTree);
+                    const childTree = (0, index_js_4.getOrCreateNodeFromInnerUnboxedNode)(childFlexTree);
                     result.push([index, childTree]);
                 }
                 break;
             }
-            case index_js_1.NodeKind.Map:
-            case index_js_1.NodeKind.Record: {
+            case index_js_4.NodeKind.Map:
+            case index_js_4.NodeKind.Record: {
                 for (const [key, flexField] of flexNode.fields) {
-                    const childTreeNode = (0, index_js_1.tryGetTreeNodeForField)(flexField);
+                    const childTreeNode = (0, index_js_4.tryGetTreeNodeForField)(flexField);
                     if (childTreeNode !== undefined) {
                         result.push([key, childTreeNode]);
                     }
                 }
                 break;
             }
-            case index_js_1.NodeKind.Object: {
-                (0, internal_1.assert)((0, index_js_1.isObjectNodeSchema)(schema), 0xbc5 /* Expected object schema. */);
+            case index_js_4.NodeKind.Object: {
+                (0, internal_1.assert)((0, index_js_4.isObjectNodeSchema)(schema), 0xbc5 /* Expected object schema. */);
                 for (const [propertyKey, fieldSchema] of schema.fields) {
                     const storedKey = fieldSchema.storedKey;
-                    const flexField = flexNode.tryGetField((0, index_js_2.brand)(String(storedKey)));
+                    const flexField = flexNode.tryGetField((0, index_js_5.brand)(String(storedKey)));
                     if (flexField !== undefined) {
-                        const childTreeNode = (0, index_js_1.tryGetTreeNodeForField)(flexField);
+                        const childTreeNode = (0, index_js_4.tryGetTreeNodeForField)(flexField);
                         (0, internal_1.assert)(childTreeNode !== undefined, 0xbc6 /* Expected child tree node for field. */);
                         result.push([propertyKey, childTreeNode]);
                     }
                 }
                 break;
             }
-            case index_js_1.NodeKind.Leaf: {
+            case index_js_4.NodeKind.Leaf: {
                 (0, internal_1.fail)(0xbc7 /* Leaf schema associated with non-leaf tree node. */);
             }
             default: {
@@ -386,7 +386,7 @@ exports.TreeAlpha = {
     },
     tagContentSchema(schema, node) {
         if (typeof node === "object" && node !== null && !(0, runtime_utils_1.isFluidHandle)(node)) {
-            Reflect.defineProperty(node, index_js_1.contentSchemaSymbol, {
+            Reflect.defineProperty(node, index_js_4.contentSchemaSymbol, {
                 configurable: false,
                 enumerable: false,
                 writable: true,
@@ -403,11 +403,11 @@ exports.TreeAlpha = {
  */
 function borrowFieldCursorFromTreeNodeOrValue(node) {
     if (node === undefined) {
-        return (0, index_js_5.cursorForMapTreeField)([]);
+        return (0, index_js_3.cursorForMapTreeField)([]);
     }
-    const cursor = (0, index_js_1.borrowCursorFromTreeNodeOrValue)(node);
+    const cursor = (0, index_js_4.borrowCursorFromTreeNodeOrValue)(node);
     // TODO: avoid copy: borrow cursor from field instead.
-    const mapTree = (0, index_js_5.mapTreeFromCursor)(cursor);
-    return (0, index_js_5.cursorForMapTreeField)([mapTree]);
+    const mapTree = (0, index_js_3.mapTreeFromCursor)(cursor);
+    return (0, index_js_3.cursorForMapTreeField)([mapTree]);
 }
 //# sourceMappingURL=treeAlpha.js.map