@fluidframework/tree 2.1.0 → 2.3.0-288113

package/dist/simple-tree/arrayNode.js

@@ -8,26 +8,21 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var _CustomArrayNodeBase_instances, _CustomArrayNodeBase_generationNumber, _CustomArrayNodeBase_cursorFromFieldData;
+var _CustomArrayNodeBase_instances, _CustomArrayNodeBase_mapTreesFromFieldData;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.arraySchema = exports.asIndex = exports.IterableTreeArrayContent = exports.TreeArrayNode = void 0;
+const internal_1 = require("@fluidframework/core-utils/internal");
 const index_js_1 = require("../core/index.js");
 const index_js_2 = require("../feature-libraries/index.js");
 const proxies_js_1 = require("./proxies.js");
 const proxyBinding_js_1 = require("./proxyBinding.js");
-const schemaTypes_js_1 = require("./schemaTypes.js");
+const index_js_3 = require("./core/index.js");
 const toMapTree_js_1 = require("./toMapTree.js");
-const types_js_1 = require("./types.js");
-const index_js_3 = require("../util/index.js");
+const index_js_4 = require("../util/index.js");
 const toFlexSchema_js_1 = require("./toFlexSchema.js");
-const internal_1 = require("@fluidframework/telemetry-utils/internal");
-const internal_2 = require("@fluidframework/core-utils/internal");
+const internal_2 = require("@fluidframework/telemetry-utils/internal");
+const index_js_5 = require("./core/index.js");
+const treeNodeValid_js_1 = require("./treeNodeValid.js");
 /**
  * A {@link TreeNode} which implements 'readonly T[]' and the array mutation APIs.
  * @public
@@ -74,7 +69,7 @@ exports.IterableTreeArrayContent = IterableTreeArrayContent;
  * Given a array node proxy, returns its underlying LazySequence field.
  */
 function getSequenceField(arrayNode) {
-    return (0, proxyBinding_js_1.getFlexNode)(arrayNode).getBoxed(index_js_1.EmptyKey);
+    return (0, proxyBinding_js_1.getOrCreateInnerNode)(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
@@ -126,7 +121,7 @@ const TreeNodeWithArrayFeatures = (() => {
     /**
      * {@link TreeNodeValid}, but modified to add members from Array.prototype named in {@link arrayPrototypeKeys}.
      */
-    class TreeNodeWithArrayFeaturesUntyped extends types_js_1.TreeNodeValid {
+    class TreeNodeWithArrayFeaturesUntyped extends treeNodeValid_js_1.TreeNodeValid {
     }
     // Modify TreeNodeWithArrayFeaturesUntyped to add the members from Array.prototype
     arrayPrototypeKeys.forEach((key) => {
@@ -189,7 +184,9 @@ function createArrayNodeProxy(allowAdditionalProperties, proxyTarget, dispatchTa
                 return Reflect.get(dispatchTarget, key, receiver);
             }
             const maybeContent = field.at(maybeIndex);
-            return (0, index_js_2.isFlexTreeNode)(maybeContent) ? (0, proxies_js_1.getOrCreateNodeProxy)(maybeContent) : maybeContent;
+            return (0, index_js_2.isFlexTreeNode)(maybeContent)
+                ? (0, proxies_js_1.getOrCreateNodeFromFlexTreeNode)(maybeContent)
+                : maybeContent;
         },
         set: (target, key, newValue, receiver) => {
             if (key === "length") {
@@ -210,7 +207,7 @@ function createArrayNodeProxy(allowAdditionalProperties, proxyTarget, dispatchTa
             if (maybeIndex !== undefined) {
                 // For MVP, we otherwise disallow setting properties (mutation is only available via the array node mutation APIs).
                 // To ensure a clear and actionable error experience, we will throw explicitly here, rather than just returning false.
-                throw new internal_1.UsageError("Cannot set indexed properties on array nodes. Use array node mutation APIs to alter the array.");
+                throw new internal_2.UsageError("Cannot set indexed properties on array nodes. Use array node mutation APIs to alter the array.");
             }
             return allowAdditionalProperties ? Reflect.set(target, key, newValue, receiver) : false;
         },
@@ -236,15 +233,12 @@ function createArrayNodeProxy(allowAdditionalProperties, proxyTarget, dispatchTa
             const field = getSequenceField(proxy);
             const maybeIndex = asIndex(key, field.length);
             if (maybeIndex !== undefined) {
-                const val = field.boxedAt(maybeIndex);
+                const val = field.at(maybeIndex);
                 // 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 {
-                    // TODO: Ideally, we would return leaves without first boxing them.  However, this is not
-                    //       as simple as calling '.at' since this skips the node and returns the FieldNode's
-                    //       inner field.
-                    value: val === undefined ? val : (0, proxies_js_1.getOrCreateNodeProxy)(val),
-                    writable: true, // For MVP, disallow setting indexed properties.
+                    value: (0, index_js_2.isFlexTreeNode)(val) ? (0, proxies_js_1.getOrCreateNodeFromFlexTreeNode)(val) : 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,
                 };
@@ -264,7 +258,7 @@ function createArrayNodeProxy(allowAdditionalProperties, proxyTarget, dispatchTa
         defineProperty(target, key, attributes) {
             const maybeIndex = asIndex(key, Number.POSITIVE_INFINITY);
             if (maybeIndex !== undefined) {
-                throw new internal_1.UsageError("Shadowing of array indices is not permitted.");
+                throw new internal_2.UsageError("Shadowing of array indices is not permitted.");
             }
             return Reflect.defineProperty(dispatchTarget, key, attributes);
         },
@@ -275,14 +269,6 @@ class CustomArrayNodeBase extends TreeNodeWithArrayFeatures {
     constructor(input) {
         super(input);
         _CustomArrayNodeBase_instances.add(this);
-        /**
-         * Generation number which is incremented any time we have an edit on the node.
-         * Used during iteration to make sure there has been no edits that were concurrently made.
-         */
-        _CustomArrayNodeBase_generationNumber.set(this, 0);
-        (0, proxyBinding_js_1.getKernel)(this).on("nodeChanged", () => {
-            __classPrivateFieldSet(this, _CustomArrayNodeBase_generationNumber, __classPrivateFieldGet(this, _CustomArrayNodeBase_generationNumber, "f") + 1, "f");
-        });
     }
     toJSON() {
         // This override causes the class instance to `JSON.stringify` as `[a, b]` rather than `{0: a, 1: b}`.
@@ -293,22 +279,18 @@ class CustomArrayNodeBase extends TreeNodeWithArrayFeatures {
     // Therefore it must include `length`,
     // even though this "length" is never invoked (due to being shadowed by the proxy provided own property).
     get length() {
-        return (0, index_js_3.fail)("Proxy should intercept length");
+        return (0, index_js_4.fail)("Proxy should intercept length");
     }
-    [(_CustomArrayNodeBase_generationNumber = new WeakMap(), _CustomArrayNodeBase_instances = new WeakSet(), _CustomArrayNodeBase_cursorFromFieldData = function _CustomArrayNodeBase_cursorFromFieldData(value) {
-        if ((0, index_js_2.isMapTreeNode)((0, proxyBinding_js_1.getFlexNode)(this))) {
-            throw new internal_1.UsageError(`An array cannot be mutated before being inserted into the tree`);
-        }
+    [(_CustomArrayNodeBase_instances = new WeakSet(), _CustomArrayNodeBase_mapTreesFromFieldData = function _CustomArrayNodeBase_mapTreesFromFieldData(value) {
         const sequenceField = getSequenceField(this);
-        // TODO: this is not valid since this is a value field schema, not a sequence one (which does not exist in the simple tree layer),
-        // but it works since cursorFromFieldData special cases arrays.
-        const simpleFieldSchema = (0, schemaTypes_js_1.normalizeFieldSchema)(this.simpleSchema);
         const content = value;
         const mapTrees = content
             .flatMap((c) => c instanceof IterableTreeArrayContent ? Array.from(c) : [c])
-            .map((c) => (0, toMapTree_js_1.mapTreeFromNodeData)(c, simpleFieldSchema.allowedTypes, sequenceField.context.nodeKeyManager, (0, index_js_2.getSchemaAndPolicy)(sequenceField)));
-        (0, proxies_js_1.prepareContentForHydration)(mapTrees, sequenceField.context.checkout.forest);
-        return (0, index_js_2.cursorForMapTreeField)(mapTrees);
+            .map((c) => (0, toMapTree_js_1.mapTreeFromNodeData)(c, this.simpleSchema, sequenceField.context?.nodeKeyManager, (0, index_js_2.getSchemaAndPolicy)(sequenceField)));
+        if (sequenceField.context !== undefined) {
+            (0, proxies_js_1.prepareContentForHydration)(mapTrees, sequenceField.context.checkout.forest);
+        }
+        return mapTrees;
     }, Symbol.iterator)]() {
         return this.values();
     }
@@ -324,14 +306,13 @@ class CustomArrayNodeBase extends TreeNodeWithArrayFeatures {
         if (val === undefined) {
             return val;
         }
-        return (0, proxies_js_1.getOrCreateNodeProxy)(val);
+        return (0, proxies_js_1.getOrCreateNodeFromFlexTreeNode)(val);
     }
     insertAt(index, ...value) {
         const field = getSequenceField(this);
         validateIndex(index, field, "insertAt", true);
-        const content = prepareFieldCursorForInsert(__classPrivateFieldGet(this, _CustomArrayNodeBase_instances, "m", _CustomArrayNodeBase_cursorFromFieldData).call(this, value));
-        const fieldEditor = field.sequenceEditor();
-        fieldEditor.insert(index, content);
+        const content = __classPrivateFieldGet(this, _CustomArrayNodeBase_instances, "m", _CustomArrayNodeBase_mapTreesFromFieldData).call(this, value);
+        field.editor.insert(index, content);
     }
     insertAtStart(...value) {
         this.insertAt(0, ...value);
@@ -342,11 +323,10 @@ class CustomArrayNodeBase extends TreeNodeWithArrayFeatures {
     removeAt(index) {
         const field = getSequenceField(this);
         validateIndex(index, field, "removeAt");
-        field.sequenceEditor().remove(index, 1);
+        field.editor.remove(index, 1);
     }
     removeRange(start, end) {
         const field = getSequenceField(this);
-        const fieldEditor = field.sequenceEditor();
         const { length } = field;
         const removeStart = start ?? 0;
         const removeEnd = Math.min(length, end ?? length);
@@ -354,9 +334,9 @@ class CustomArrayNodeBase extends TreeNodeWithArrayFeatures {
         validatePositiveIndex(removeEnd);
         if (removeEnd < removeStart) {
             // This catches both the case where start is > array.length and when start is > end.
-            throw new internal_1.UsageError('Too large of "start" value passed to TreeArrayNode.removeRange.');
+            throw new internal_2.UsageError('Too large of "start" value passed to TreeArrayNode.removeRange.');
         }
-        fieldEditor.remove(removeStart, removeEnd - removeStart);
+        field.editor.remove(removeStart, removeEnd - removeStart);
     }
     moveToStart(sourceIndex, source) {
         const sourceArray = source ?? this;
@@ -388,44 +368,59 @@ class CustomArrayNodeBase extends TreeNodeWithArrayFeatures {
     }
     moveRangeToIndex(destinationIndex, sourceStart, sourceEnd, source) {
         const destinationField = getSequenceField(this);
+        const sourceField = source !== undefined ? getSequenceField(source) : destinationField;
         validateIndex(destinationIndex, destinationField, "moveRangeToIndex", true);
         validateIndexRange(sourceStart, sourceEnd, source ?? destinationField, "moveRangeToIndex");
-        const sourceField = source !== undefined ? getSequenceField(source) : destinationField;
         // TODO: determine support for move across different sequence types
         if (destinationField.schema.types !== undefined && sourceField !== destinationField) {
             for (let i = sourceStart; i < sourceEnd; i++) {
-                const sourceNode = sourceField.boxedAt(i) ?? (0, index_js_3.fail)("impossible out of bounds index");
+                const sourceNode = sourceField.boxedAt(i) ?? (0, internal_1.oob)();
                 if (!destinationField.schema.types.has(sourceNode.schema.name)) {
-                    throw new internal_1.UsageError("Type in source sequence is not allowed in destination.");
+                    throw new internal_2.UsageError("Type in source sequence is not allowed in destination.");
                 }
             }
         }
         const movedCount = sourceEnd - sourceStart;
-        const sourceFieldPath = sourceField.getFieldPath();
-        const destinationFieldPath = destinationField.getFieldPath();
-        destinationField.context.checkout.editor.move(sourceFieldPath, sourceStart, movedCount, destinationFieldPath, destinationIndex);
+        if (destinationField.context === undefined) {
+            if (!(0, index_js_2.isMapTreeSequenceField)(sourceField)) {
+                throw new internal_2.UsageError("Cannot move elements from an inserted array to an array that has not yet been inserted");
+            }
+            if (sourceField !== destinationField || destinationIndex < sourceStart) {
+                destinationField.editor.insert(destinationIndex, sourceField.editor.remove(sourceStart, movedCount));
+            }
+            else if (destinationIndex > sourceStart + movedCount) {
+                destinationField.editor.insert(destinationIndex - movedCount, sourceField.editor.remove(sourceStart, movedCount));
+            }
+        }
+        else {
+            if (sourceField.context === undefined) {
+                throw new internal_2.UsageError("Cannot move elements from an array that has not yet been inserted to an inserted array");
+            }
+            destinationField.context.checkout.editor.move(sourceField.getFieldPath(), sourceStart, movedCount, destinationField.getFieldPath(), destinationIndex);
+        }
     }
     values() {
-        return this.generateValues(__classPrivateFieldGet(this, _CustomArrayNodeBase_generationNumber, "f"));
+        return this.generateValues((0, index_js_5.getKernel)(this).generationNumber);
     }
     *generateValues(initialLastUpdatedStamp) {
-        if (initialLastUpdatedStamp !== __classPrivateFieldGet(this, _CustomArrayNodeBase_generationNumber, "f")) {
-            throw new internal_1.UsageError(`Concurrent editing and iteration is not allowed.`);
+        if (initialLastUpdatedStamp !== (0, index_js_5.getKernel)(this).generationNumber) {
+            throw new internal_2.UsageError(`Concurrent editing and iteration is not allowed.`);
         }
         for (let i = 0; i < this.length; i++) {
-            yield this.at(i) ?? (0, index_js_3.fail)("Index is out of bounds");
-            if (initialLastUpdatedStamp !== __classPrivateFieldGet(this, _CustomArrayNodeBase_generationNumber, "f")) {
-                throw new internal_1.UsageError(`Concurrent editing and iteration is not allowed.`);
+            yield this.at(i) ?? (0, index_js_4.fail)("Index is out of bounds");
+            if (initialLastUpdatedStamp !== (0, index_js_5.getKernel)(this).generationNumber) {
+                throw new internal_2.UsageError(`Concurrent editing and iteration is not allowed.`);
             }
         }
     }
 }
-CustomArrayNodeBase.kind = schemaTypes_js_1.NodeKind.Array;
+CustomArrayNodeBase.kind = index_js_3.NodeKind.Array;
 /**
  * Define a {@link TreeNodeSchema} for a {@link (TreeArrayNode:interface)}.
  *
  * @param name - Unique identifier for this schema including the factory's scope.
  */
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 function arraySchema(identifier, info, implicitlyConstructable, customizable) {
     let flexSchema;
     // This class returns a proxy from its constructor to handle numeric indexing.
@@ -446,7 +441,7 @@ function arraySchema(identifier, info, implicitlyConstructable, customizable) {
             return createArrayNodeProxy(customizable, proxyTarget, instance);
         }
         static buildRawNode(instance, input) {
-            return (0, index_js_2.getOrCreateMapTreeNode)(flexSchema, (0, toMapTree_js_1.mapTreeFromNodeData)(copyContent(flexSchema.name, input), this));
+            return (0, index_js_2.getOrCreateMapTreeNode)(flexSchema, (0, toMapTree_js_1.mapTreeFromNodeData)(input, this));
         }
         static oneTimeSetup() {
             flexSchema = (0, toFlexSchema_js_1.getFlexSchema)(this);
@@ -462,7 +457,7 @@ function arraySchema(identifier, info, implicitlyConstructable, customizable) {
                     for (const key of Object.getOwnPropertyNames(prototype)) {
                         const maybeIndex = asIndex(key, Number.POSITIVE_INFINITY);
                         if (maybeIndex !== undefined) {
-                            throw new internal_1.UsageError(`Schema ${identifier} defines an inherited index property "${key.toString()}" which shadows a possible array index. Shadowing of array indices is not permitted.`);
+                            throw new internal_2.UsageError(`Schema ${identifier} defines an inherited index property "${key.toString()}" which shadows a possible array index. Shadowing of array indices is not permitted.`);
                         }
                     }
                     // Since this stops at the array node base schema, it should never see a null prototype, so this case is safe.
@@ -472,9 +467,13 @@ function arraySchema(identifier, info, implicitlyConstructable, customizable) {
                 }
             }
         }
-        get [schemaTypes_js_1.typeNameSymbol]() {
+        // eslint-disable-next-line import/no-deprecated
+        get [index_js_3.typeNameSymbol]() {
             return identifier;
         }
+        get [index_js_3.typeSchemaSymbol]() {
+            return schema.constructorCached?.constructor;
+        }
         get simpleSchema() {
             return info;
         }
@@ -483,35 +482,31 @@ function arraySchema(identifier, info, implicitlyConstructable, customizable) {
     schema.identifier = identifier;
     schema.info = info;
     schema.implicitlyConstructable = implicitlyConstructable;
-    return schema;
+    const output = schema;
+    return output;
 }
 exports.arraySchema = arraySchema;
-function copyContent(typeName, content) {
-    const copy = Array.from(content);
-    (0, proxies_js_1.markContentType)(typeName, copy);
-    return copy;
-}
 function validateSafeInteger(index) {
     if (!Number.isSafeInteger(index)) {
-        throw new internal_1.UsageError(`Expected a safe integer, got ${index}.`);
+        throw new internal_2.UsageError(`Expected a safe integer, got ${index}.`);
     }
 }
 function validatePositiveIndex(index) {
     validateSafeInteger(index);
     if (index < 0) {
-        throw new internal_1.UsageError(`Expected non-negative index, got ${index}.`);
+        throw new internal_2.UsageError(`Expected non-negative index, got ${index}.`);
     }
 }
 function validateIndex(index, array, methodName, allowOnePastEnd = false) {
     validatePositiveIndex(index);
     if (allowOnePastEnd) {
         if (index > array.length) {
-            throw new internal_1.UsageError(`Index value passed to TreeArrayNode.${methodName} is out of bounds.`);
+            throw new internal_2.UsageError(`Index value passed to TreeArrayNode.${methodName} is out of bounds.`);
         }
     }
     else {
         if (index >= array.length) {
-            throw new internal_1.UsageError(`Index value passed to TreeArrayNode.${methodName} is out of bounds.`);
+            throw new internal_2.UsageError(`Index value passed to TreeArrayNode.${methodName} is out of bounds.`);
         }
     }
 }
@@ -519,15 +514,7 @@ function validateIndexRange(startIndex, endIndex, array, methodName) {
     validateIndex(startIndex, array, methodName, true);
     validateIndex(endIndex, array, methodName, true);
     if (startIndex > endIndex || array.length < endIndex) {
-        throw new internal_1.UsageError(`Index value passed to TreeArrayNode.${methodName} is out of bounds.`);
+        throw new internal_2.UsageError(`Index value passed to TreeArrayNode.${methodName} is out of bounds.`);
     }
 }
-/**
- * Prepare a fields cursor (holding a sequence of nodes) for inserting.
- */
-function prepareFieldCursorForInsert(cursor) {
-    // TODO: optionally validate content against schema.
-    (0, internal_2.assert)(cursor.mode === 1 /* CursorLocationType.Fields */, 0x9a8 /* should be in fields mode */);
-    return cursor;
-}
 //# sourceMappingURL=arrayNode.js.map