@fluidframework/tree 2.80.0 → 2.81.0

package/dist/simple-tree/node-kinds/array/arrayNode.js

@@ -15,12 +15,12 @@ const internal_1 = require("@fluidframework/core-utils/internal");
 const internal_2 = require("@fluidframework/telemetry-utils/internal");
 const index_js_1 = require("../../../core/index.js");
 const index_js_2 = require("../../../feature-libraries/index.js");
-const index_js_3 = require("../../core/index.js");
-const unhydratedFlexTreeFromInsertable_js_1 = require("../../unhydratedFlexTreeFromInsertable.js");
-const prepareForInsertion_js_1 = require("../../prepareForInsertion.js");
+const index_js_3 = require("../../../util/index.js");
+const index_js_4 = require("../../core/index.js");
 const createContext_js_1 = require("../../createContext.js");
-const index_js_4 = require("../../../util/index.js");
 const leafNodeSchema_js_1 = require("../../leafNodeSchema.js");
+const prepareForInsertion_js_1 = require("../../prepareForInsertion.js");
+const unhydratedFlexTreeFromInsertable_js_1 = require("../../unhydratedFlexTreeFromInsertable.js");
 /**
  * A {@link TreeNode} which implements 'readonly T[]' and the array mutation APIs.
  * @public
@@ -67,7 +67,7 @@ exports.IterableTreeArrayContent = IterableTreeArrayContent;
  * Given a array node proxy, returns its underlying LazySequence field.
  */
 function getSequenceField(arrayNode) {
-    return (0, index_js_3.getInnerNode)(arrayNode).getBoxed(index_js_1.EmptyKey);
+    return (0, index_js_4.getInnerNode)(arrayNode).getBoxed(index_js_1.EmptyKey);
 }
 // For compatibility, we are initially implement 'readonly T[]' by applying the Array.prototype methods
 // to the array node proxy.  Over time, we should replace these with efficient implementations on LazySequence
@@ -119,14 +119,14 @@ const TreeNodeWithArrayFeatures = (() => {
     /**
      * {@link TreeNodeValid}, but modified to add members from Array.prototype named in {@link arrayPrototypeKeys}.
      */
-    class TreeNodeWithArrayFeaturesUntyped extends index_js_3.TreeNodeValid {
+    class TreeNodeWithArrayFeaturesUntyped extends index_js_4.TreeNodeValid {
     }
     // Modify TreeNodeWithArrayFeaturesUntyped to add the members from Array.prototype
-    arrayPrototypeKeys.forEach((key) => {
+    for (const key of arrayPrototypeKeys) {
         Object.defineProperty(TreeNodeWithArrayFeaturesUntyped.prototype, key, {
             value: Array.prototype[key],
         });
-    });
+    }
     return TreeNodeWithArrayFeaturesUntyped;
 })();
 /* eslint-enable @typescript-eslint/explicit-member-accessibility, @typescript-eslint/no-explicit-any */
@@ -190,7 +190,7 @@ function createArrayNodeProxy(allowAdditionalProperties, proxyTarget, dispatchTa
             const maybeContent = field.at(maybeIndex);
             return maybeContent === undefined
                 ? undefined
-                : (0, index_js_3.getOrCreateNodeFromInnerUnboxedNode)(maybeContent);
+                : (0, index_js_4.getOrCreateNodeFromInnerUnboxedNode)(maybeContent);
         },
         set: (target, key, newValue, receiver) => {
             if (key === "length") {
@@ -241,7 +241,7 @@ function createArrayNodeProxy(allowAdditionalProperties, proxyTarget, dispatchTa
                 // To satisfy 'deepEquals' level scrutiny, the property descriptor for indexed properties must
                 // be a simple value property (as opposed to using getter) and declared writable/enumerable/configurable.
                 return {
-                    value: val === undefined ? undefined : (0, index_js_3.getOrCreateNodeFromInnerUnboxedNode)(val),
+                    value: val === undefined ? undefined : (0, index_js_4.getOrCreateNodeFromInnerUnboxedNode)(val),
                     writable: true, // For MVP, setting indexed properties is reported as allowed here (for deep equals compatibility noted above), but not actually supported.
                     enumerable: true,
                     configurable: true,
@@ -289,10 +289,10 @@ class CustomArrayNodeBase extends TreeNodeWithArrayFeatures {
         const sequenceField = getSequenceField(this);
         const content = value;
         const contentArray = content.flatMap((c) => c instanceof IterableTreeArrayContent ? [...c] : [c]);
-        const kernel = (0, index_js_3.getKernel)(this);
+        const kernel = (0, index_js_4.getKernel)(this);
         const flexContext = kernel.getInnerNode().context;
         (0, internal_1.assert)(flexContext === kernel.context.flexContext, 0xc14 /* Expected flexContext to match */);
-        const innerSchema = kernel.context.flexContext.schema.nodeSchema.get((0, index_js_4.brand)(kernel.schema.identifier));
+        const innerSchema = kernel.context.flexContext.schema.nodeSchema.get((0, index_js_3.brand)(kernel.schema.identifier));
         (0, internal_1.assert)(innerSchema instanceof index_js_1.ObjectNodeStoredSchema, 0xc15 /* Expected ObjectNodeStoredSchema */);
         const fieldSchema = innerSchema.getFieldSchema(index_js_1.EmptyKey);
         const mapTrees = (0, prepareForInsertion_js_1.prepareArrayContentForInsertion)(contentArray, this.childSchema, sequenceField.context, fieldSchema.types);
@@ -312,11 +312,11 @@ class CustomArrayNodeBase extends TreeNodeWithArrayFeatures {
         if (val === undefined) {
             return val;
         }
-        return (0, index_js_3.getOrCreateNodeFromInnerNode)(val);
+        return (0, index_js_4.getOrCreateNodeFromInnerNode)(val);
     }
     insertAt(index, ...value) {
         const field = getSequenceField(this);
-        (0, index_js_4.validateIndex)(index, field, "TreeArrayNode.insertAt", true);
+        (0, index_js_3.validateIndex)(index, field, "TreeArrayNode.insertAt", true);
         const content = __classPrivateFieldGet(this, _CustomArrayNodeBase_instances, "m", _CustomArrayNodeBase_mapTreesFromFieldData).call(this, value);
         field.editor.insert(index, content);
     }
@@ -328,60 +328,60 @@ class CustomArrayNodeBase extends TreeNodeWithArrayFeatures {
     }
     removeAt(index) {
         const field = getSequenceField(this);
-        (0, index_js_4.validateIndex)(index, field, "TreeArrayNode.removeAt");
+        (0, index_js_3.validateIndex)(index, field, "TreeArrayNode.removeAt");
         field.editor.remove(index, 1);
     }
     removeRange(start, end) {
         const field = getSequenceField(this);
         const { length, editor } = field;
         const removeStart = start ?? 0;
-        (0, index_js_4.validateIndex)(removeStart, field, "TreeArrayNode.removeRange", true);
+        (0, index_js_3.validateIndex)(removeStart, field, "TreeArrayNode.removeRange", true);
         const removeEnd = Math.min(length, end ?? length);
-        (0, index_js_4.validateIndexRange)(removeStart, removeEnd, field, "TreeArrayNode.removeRange");
+        (0, index_js_3.validateIndexRange)(removeStart, removeEnd, field, "TreeArrayNode.removeRange");
         editor.remove(removeStart, removeEnd - removeStart);
     }
     moveToStart(sourceIndex, source) {
         const sourceArray = source ?? this;
         const sourceField = getSequenceField(sourceArray);
-        (0, index_js_4.validateIndex)(sourceIndex, sourceField, "TreeArrayNode.moveToStart");
+        (0, index_js_3.validateIndex)(sourceIndex, sourceField, "TreeArrayNode.moveToStart");
         this.moveRangeToIndex(0, sourceIndex, sourceIndex + 1, source);
     }
     moveToEnd(sourceIndex, source) {
         const sourceArray = source ?? this;
         const sourceField = getSequenceField(sourceArray);
-        (0, index_js_4.validateIndex)(sourceIndex, sourceField, "TreeArrayNode.moveToEnd");
+        (0, index_js_3.validateIndex)(sourceIndex, sourceField, "TreeArrayNode.moveToEnd");
         this.moveRangeToIndex(this.length, sourceIndex, sourceIndex + 1, source);
     }
     moveToIndex(destinationGap, sourceIndex, source) {
         const sourceArray = source ?? this;
         const sourceField = getSequenceField(sourceArray);
         const destinationField = getSequenceField(this);
-        (0, index_js_4.validateIndex)(destinationGap, destinationField, "TreeArrayNode.moveToIndex", true);
-        (0, index_js_4.validateIndex)(sourceIndex, sourceField, "TreeArrayNode.moveToIndex");
+        (0, index_js_3.validateIndex)(destinationGap, destinationField, "TreeArrayNode.moveToIndex", true);
+        (0, index_js_3.validateIndex)(sourceIndex, sourceField, "TreeArrayNode.moveToIndex");
         this.moveRangeToIndex(destinationGap, sourceIndex, sourceIndex + 1, source);
     }
     moveRangeToStart(sourceStart, sourceEnd, source) {
-        (0, index_js_4.validateIndexRange)(sourceStart, sourceEnd, source ?? getSequenceField(this), "TreeArrayNode.moveRangeToStart");
+        (0, index_js_3.validateIndexRange)(sourceStart, sourceEnd, source ?? getSequenceField(this), "TreeArrayNode.moveRangeToStart");
         this.moveRangeToIndex(0, sourceStart, sourceEnd, source);
     }
     moveRangeToEnd(sourceStart, sourceEnd, source) {
-        (0, index_js_4.validateIndexRange)(sourceStart, sourceEnd, source ?? getSequenceField(this), "TreeArrayNode.moveRangeToEnd");
+        (0, index_js_3.validateIndexRange)(sourceStart, sourceEnd, source ?? getSequenceField(this), "TreeArrayNode.moveRangeToEnd");
         this.moveRangeToIndex(this.length, sourceStart, sourceEnd, source);
     }
     moveRangeToIndex(destinationGap, sourceStart, sourceEnd, source) {
         const destinationField = getSequenceField(this);
         const destinationSchema = this.allowedTypes;
-        const kernel = (0, index_js_3.getKernel)(this);
-        const destinationStored = (kernel.context.flexContext.schema.nodeSchema.get((0, index_js_4.brand)(kernel.schema.identifier)) ??
+        const kernel = (0, index_js_4.getKernel)(this);
+        const destinationStored = (kernel.context.flexContext.schema.nodeSchema.get((0, index_js_3.brand)(kernel.schema.identifier)) ??
             (0, internal_1.fail)(0xc16 /* missing schema for array node */)).getFieldSchema(index_js_1.EmptyKey).types;
         const sourceField = source === undefined ? destinationField : getSequenceField(source);
-        (0, index_js_4.validateIndex)(destinationGap, destinationField, "TreeArrayNode.moveRangeToIndex", true);
-        (0, index_js_4.validateIndexRange)(sourceStart, sourceEnd, source ?? destinationField, "TreeArrayNode.moveRangeToIndex");
+        (0, index_js_3.validateIndex)(destinationGap, destinationField, "TreeArrayNode.moveRangeToIndex", true);
+        (0, index_js_3.validateIndexRange)(sourceStart, sourceEnd, source ?? destinationField, "TreeArrayNode.moveRangeToIndex");
         // TODO: determine support for move across different sequence types
         if (sourceField !== destinationField) {
             for (let i = sourceStart; i < sourceEnd; i++) {
                 const sourceNode = sourceField.boxedAt(i) ?? (0, internal_1.oob)();
-                const sourceSchema = (0, index_js_3.getSimpleNodeSchemaFromInnerNode)(sourceNode);
+                const sourceSchema = (0, index_js_4.getSimpleNodeSchemaFromInnerNode)(sourceNode);
                 if (!destinationSchema.has(sourceSchema)) {
                     throw new internal_2.UsageError(`Type ${sourceNode.type} in source sequence is not allowed in destination.`);
                 }
@@ -402,7 +402,7 @@ class CustomArrayNodeBase extends TreeNodeWithArrayFeatures {
             destinationField.context.checkout.editor.move(sourceField.getFieldPath(), sourceStart, movedCount, destinationField.getFieldPath(), destinationGap);
         }
         else {
-            if (!(sourceField instanceof index_js_3.UnhydratedSequenceField)) {
+            if (!(sourceField instanceof index_js_4.UnhydratedSequenceField)) {
                 throw new internal_2.UsageError("Cannot move elements from a hydrated array to an unhydrated array.");
             }
             if (sourceField.context.isHydrated()) {
@@ -413,7 +413,7 @@ class CustomArrayNodeBase extends TreeNodeWithArrayFeatures {
             // TODO:AB#47457: Implement proper move support for unhydrated trees.
             // As a temporary mitigation, we will pause tree events until both edits have been completed.
             // That way, users will only see a single change event for the array instead of 2.
-            (0, index_js_3.withBufferedTreeEvents)(() => {
+            (0, index_js_4.withBufferedTreeEvents)(() => {
                 if (sourceField !== destinationField || destinationGap < sourceStart) {
                     destinationField.editor.insert(destinationGap, sourceField.editor.remove(sourceStart, movedCount));
                 }
@@ -424,10 +424,10 @@ class CustomArrayNodeBase extends TreeNodeWithArrayFeatures {
         }
     }
     values() {
-        return this.generateValues((0, index_js_3.getKernel)(this).generationNumber);
+        return this.generateValues((0, index_js_4.getKernel)(this).generationNumber);
     }
     *generateValues(initialLastUpdatedStamp) {
-        const kernel = (0, index_js_3.getKernel)(this);
+        const kernel = (0, index_js_4.getKernel)(this);
         if (initialLastUpdatedStamp !== kernel.generationNumber) {
             throw new internal_2.UsageError(`Concurrent editing and iteration is not allowed.`);
         }
@@ -439,7 +439,7 @@ class CustomArrayNodeBase extends TreeNodeWithArrayFeatures {
         }
     }
 }
-CustomArrayNodeBase.kind = index_js_3.NodeKind.Array;
+CustomArrayNodeBase.kind = index_js_4.NodeKind.Array;
 /**
  * Define a {@link TreeNodeSchema} for a {@link (TreeArrayNode:interface)}.
  *
@@ -449,10 +449,10 @@ CustomArrayNodeBase.kind = index_js_3.NodeKind.Array;
 // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 function arraySchema(identifier, info, implicitlyConstructable, customizable, nodeOptions) {
     const persistedMetadata = nodeOptions?.persistedMetadata;
-    const normalizedTypes = (0, index_js_3.normalizeAllowedTypes)(info);
+    const normalizedTypes = (0, index_js_4.normalizeAllowedTypes)(info);
     const lazyAllowedTypesIdentifiers = new internal_1.Lazy(() => new Set(normalizedTypes.evaluate().map((type) => type.identifier)));
     const lazySimpleAllowedTypes = new internal_1.Lazy(() => {
-        return index_js_3.AnnotatedAllowedTypesInternal.evaluateSimpleAllowedTypes(normalizedTypes);
+        return index_js_4.AnnotatedAllowedTypesInternal.evaluateSimpleAllowedTypes(normalizedTypes);
     });
     let privateData;
     // This class returns a proxy from its constructor to handle numeric indexing.
@@ -513,10 +513,10 @@ function arraySchema(identifier, info, implicitlyConstructable, customizable, no
             return normalizedTypes.evaluateSet();
         }
         // eslint-disable-next-line import-x/no-deprecated
-        get [index_js_3.typeNameSymbol]() {
+        get [index_js_4.typeNameSymbol]() {
             return identifier;
         }
-        get [index_js_3.typeSchemaSymbol]() {
+        get [index_js_4.typeSchemaSymbol]() {
             return Schema.constructorCached?.constructor;
         }
         get childSchema() {
@@ -525,8 +525,8 @@ function arraySchema(identifier, info, implicitlyConstructable, customizable, no
         get allowedTypes() {
             return normalizedTypes.evaluateSet();
         }
-        static get [index_js_3.privateDataSymbol]() {
-            return (privateData ??= (0, index_js_3.createTreeNodeSchemaPrivateData)(this, [normalizedTypes]));
+        static get [index_js_4.privateDataSymbol]() {
+            return (privateData ??= (0, index_js_4.createTreeNodeSchemaPrivateData)(this, [normalizedTypes]));
         }
     }
     Schema.constructorCached = undefined;
@@ -569,7 +569,7 @@ function arrayToFlexContent(data, schema) {
         // eslint-disable-next-line @typescript-eslint/no-base-to-string
         throw new internal_2.UsageError(`Input data is incompatible with Array schema: ${data}`);
     }
-    const allowedChildTypes = (0, index_js_3.normalizeAllowedTypes)(schema.info);
+    const allowedChildTypes = (0, index_js_4.normalizeAllowedTypes)(schema.info);
     const mappedData = Array.from(data, (child) => arrayChildToFlexTree(child, allowedChildTypes.evaluateSet()));
     const context = (0, createContext_js_1.getUnhydratedContext)(schema).flexContext;
     // Array nodes have a single `EmptyKey` field:
@@ -578,12 +578,12 @@ function arrayToFlexContent(data, schema) {
         : [
             [
                 index_js_1.EmptyKey,
-                new index_js_3.UnhydratedSequenceField(context, index_js_2.FieldKinds.sequence.identifier, index_js_1.EmptyKey, mappedData),
+                new index_js_4.UnhydratedSequenceField(context, index_js_2.FieldKinds.sequence.identifier, index_js_1.EmptyKey, mappedData),
             ],
         ];
     return [
         {
-            type: (0, index_js_4.brand)(schema.identifier),
+            type: (0, index_js_3.brand)(schema.identifier),
         },
         new Map(fieldsEntries),
     ];
@@ -593,15 +593,15 @@ function arrayToFlexContent(data, schema) {
  */
 function shallowCompatibilityTest(data, schema) {
     if ((0, index_js_2.isTreeValue)(data)) {
-        return index_js_3.CompatibilityLevel.None;
+        return index_js_4.CompatibilityLevel.None;
     }
     if (data instanceof Map) {
         // Maps are iterable, so type checking does allow constructing an ArrayNode from a map if the ArrayNode's type is an array that includes the key and value types of the map.
-        return index_js_3.CompatibilityLevel.Low;
+        return index_js_4.CompatibilityLevel.Low;
     }
     if (Symbol.iterator in data) {
-        return index_js_3.CompatibilityLevel.Normal;
+        return index_js_4.CompatibilityLevel.Normal;
     }
-    return index_js_3.CompatibilityLevel.None;
+    return index_js_4.CompatibilityLevel.None;
 }
 //# sourceMappingURL=arrayNode.js.map