@fluidframework/tree 2.3.1 → 2.4.0-297027

package/dist/simple-tree/arrayNode.d.ts

@@ -2,8 +2,8 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import type { ImplicitAllowedTypes, InsertableTreeNodeFromImplicitAllowedTypes, TreeNodeFromImplicitAllowedTypes } from "./schemaTypes.js";
-import { type WithType, NodeKind, type TreeNode, type TreeNodeSchemaClass } from "./core/index.js";
+import { type ImplicitAllowedTypes, type InsertableTreeNodeFromImplicitAllowedTypes, type TreeNodeFromImplicitAllowedTypes } from "./schemaTypes.js";
+import { type WithType, NodeKind, type TreeNode, type TreeNodeSchemaBoth } from "./core/index.js";
 /**
  * A generic array type, used to defined types like {@link (TreeArrayNode:interface)}.
  *
@@ -79,22 +79,88 @@ export interface TreeArrayNodeBase<out T, in TNew, in TMoveFrom> extends Readonl
     moveToEnd(sourceIndex: number, source: TMoveFrom): void;
     /**
      * Moves the specified item to the desired location in the array.
-     * @param index - The index to move the item to.
-     * This is based on the state of the array before moving the source item.
+     *
+     * WARNING - This API is easily misused.
+     * Please read the documentation for the `destinationGap` parameter carefully.
+     *
+     * @param destinationGap - The location *between* existing items that the moved item should be moved to.
+     *
+     * WARNING - `destinationGap` describes a location between existing items *prior to applying the move operation*.
+     *
+     * For example, if the array contains items `[A, B, C]` before the move, the `destinationGap` must be one of the following:
+     *
+     * - `0` (between the start of the array and `A`'s original position)
+     * - `1` (between `A`'s original position and `B`'s original position)
+     * - `2` (between `B`'s original position and `C`'s original position)
+     * - `3` (between `C`'s original position and the end of the array)
+     *
+     * So moving `A` between `B` and `C` would require `destinationGap` to be `2`.
+     *
+     * This interpretation of `destinationGap` makes it easy to specify the desired destination relative to a sibling item that is not being moved,
+     * or relative to the start or end of the array:
+     *
+     * - Move to the start of the array: `array.moveToIndex(0, ...)` (see also `moveToStart`)
+     * - Move to before some item X: `array.moveToIndex(indexOfX, ...)`
+     * - Move to after some item X: `array.moveToIndex(indexOfX + 1`, ...)
+     * - Move to the end of the array: `array.moveToIndex(array.length, ...)` (see also `moveToEnd`)
+     *
+     * This interpretation of `destinationGap` does however make it less obvious how to move an item relative to its current position:
+     *
+     * - Move item B before its predecessor: `array.moveToIndex(indexOfB - 1, ...)`
+     * - Move item B after its successor: `array.moveToIndex(indexOfB + 2, ...)`
+     *
+     * Notice the asymmetry between `-1` and `+2` in the above examples.
+     * In such scenarios, it can often be easier to approach such edits by swapping adjacent items:
+     * If items A and B are adjacent, such that A precedes B,
+     * then they can be swapped with `array.moveToIndex(indexOfA, indexOfB)`.
+     *
      * @param sourceIndex - The index of the item to move.
      * @throws Throws if any of the input indices are not in the range [0, `array.length`).
      */
-    moveToIndex(index: number, sourceIndex: number): void;
+    moveToIndex(destinationGap: number, sourceIndex: number): void;
     /**
      * Moves the specified item to the desired location in the array.
-     * @param index - The index to move the item to in the range [0, `array.length`].
-     * This is based on the state of the array before moving the source item.
+     *
+     * WARNING - This API is easily misused.
+     * Please read the documentation for the `destinationGap` parameter carefully.
+     *
+     * @param destinationGap - The location *between* existing items that the moved item should be moved to.
+     *
+     * WARNING - `destinationGap` describes a location between existing items *prior to applying the move operation*.
+     *
+     * For example, if the array contains items `[A, B, C]` before the move, the `destinationGap` must be one of the following:
+     *
+     * - `0` (between the start of the array and `A`'s original position)
+     * - `1` (between `A`'s original position and `B`'s original position)
+     * - `2` (between `B`'s original position and `C`'s original position)
+     * - `3` (between `C`'s original position and the end of the array)
+     *
+     * So moving `A` between `B` and `C` would require `destinationGap` to be `2`.
+     *
+     * This interpretation of `destinationGap` makes it easy to specify the desired destination relative to a sibling item that is not being moved,
+     * or relative to the start or end of the array:
+     *
+     * - Move to the start of the array: `array.moveToIndex(0, ...)` (see also `moveToStart`)
+     * - Move to before some item X: `array.moveToIndex(indexOfX, ...)`
+     * - Move to after some item X: `array.moveToIndex(indexOfX + 1`, ...)
+     * - Move to the end of the array: `array.moveToIndex(array.length, ...)` (see also `moveToEnd`)
+     *
+     * This interpretation of `destinationGap` does however make it less obvious how to move an item relative to its current position:
+     *
+     * - Move item B before its predecessor: `array.moveToIndex(indexOfB - 1, ...)`
+     * - Move item B after its successor: `array.moveToIndex(indexOfB + 2, ...)`
+     *
+     * Notice the asymmetry between `-1` and `+2` in the above examples.
+     * In such scenarios, it can often be easier to approach such edits by swapping adjacent items:
+     * If items A and B are adjacent, such that A precedes B,
+     * then they can be swapped with `array.moveToIndex(indexOfA, indexOfB)`.
+     *
      * @param sourceIndex - The index of the item to move.
      * @param source - The source array to move the item out of.
      * @throws Throws if any of the source index is not in the range [0, `array.length`),
      * or if the index is not in the range [0, `array.length`].
      */
-    moveToIndex(index: number, sourceIndex: number, source: TMoveFrom): void;
+    moveToIndex(destinationGap: number, sourceIndex: number, source: TMoveFrom): void;
     /**
      * Moves the specified items to the start of the array.
      * @param sourceStart - The starting index of the range to move (inclusive).
@@ -133,24 +199,91 @@ export interface TreeArrayNodeBase<out T, in TNew, in TMoveFrom> extends Readonl
     moveRangeToEnd(sourceStart: number, sourceEnd: number, source: TMoveFrom): void;
     /**
      * Moves the specified items to the desired location within the array.
-     * @param index - The index to move the items to.
-     * This is based on the state of the array before moving the source items.
+     *
+     * WARNING - This API is easily misused.
+     * Please read the documentation for the `destinationGap` parameter carefully.
+     *
+     * @param destinationGap - The location *between* existing items that the moved item should be moved to.
+     *
+     * WARNING - `destinationGap` describes a location between existing items *prior to applying the move operation*.
+     *
+     * For example, if the array contains items `[A, B, C]` before the move, the `destinationGap` must be one of the following:
+     *
+     * - `0` (between the start of the array and `A`'s original position)
+     * - `1` (between `A`'s original position and `B`'s original position)
+     * - `2` (between `B`'s original position and `C`'s original position)
+     * - `3` (between `C`'s original position and the end of the array)
+     *
+     * So moving `A` between `B` and `C` would require `destinationGap` to be `2`.
+     *
+     * This interpretation of `destinationGap` makes it easy to specify the desired destination relative to a sibling item that is not being moved,
+     * or relative to the start or end of the array:
+     *
+     * - Move to the start of the array: `array.moveToIndex(0, ...)` (see also `moveToStart`)
+     * - Move to before some item X: `array.moveToIndex(indexOfX, ...)`
+     * - Move to after some item X: `array.moveToIndex(indexOfX + 1`, ...)
+     * - Move to the end of the array: `array.moveToIndex(array.length, ...)` (see also `moveToEnd`)
+     *
+     * This interpretation of `destinationGap` does however make it less obvious how to move an item relative to its current position:
+     *
+     * - Move item B before its predecessor: `array.moveToIndex(indexOfB - 1, ...)`
+     * - Move item B after its successor: `array.moveToIndex(indexOfB + 2, ...)`
+     *
+     * Notice the asymmetry between `-1` and `+2` in the above examples.
+     * In such scenarios, it can often be easier to approach such edits by swapping adjacent items:
+     * If items A and B are adjacent, such that A precedes B,
+     * then they can be swapped with `array.moveToIndex(indexOfA, indexOfB)`.
+     *
      * @param sourceStart - The starting index of the range to move (inclusive).
      * @param sourceEnd - The ending index of the range to move (exclusive)
      * @throws Throws if any of the input indices are not in the range [0, `array.length`) or if `sourceStart` is greater than `sourceEnd`.
      * if any of the input indices are not in the range [0, `array.length`], or if `sourceStart` is greater than `sourceEnd`.
      */
-    moveRangeToIndex(index: number, sourceStart: number, sourceEnd: number): void;
+    moveRangeToIndex(destinationGap: number, sourceStart: number, sourceEnd: number): void;
     /**
      * Moves the specified items to the desired location within the array.
-     * @param index - The index to move the items to.
+     *
+     * WARNING - This API is easily misused.
+     * Please read the documentation for the `destinationGap` parameter carefully.
+     *
+     * @param destinationGap - The location *between* existing items that the moved item should be moved to.
+     *
+     * WARNING - `destinationGap` describes a location between existing items *prior to applying the move operation*.
+     *
+     * For example, if the array contains items `[A, B, C]` before the move, the `destinationGap` must be one of the following:
+     *
+     * - `0` (between the start of the array and `A`'s original position)
+     * - `1` (between `A`'s original position and `B`'s original position)
+     * - `2` (between `B`'s original position and `C`'s original position)
+     * - `3` (between `C`'s original position and the end of the array)
+     *
+     * So moving `A` between `B` and `C` would require `destinationGap` to be `2`.
+     *
+     * This interpretation of `destinationGap` makes it easy to specify the desired destination relative to a sibling item that is not being moved,
+     * or relative to the start or end of the array:
+     *
+     * - Move to the start of the array: `array.moveToIndex(0, ...)` (see also `moveToStart`)
+     * - Move to before some item X: `array.moveToIndex(indexOfX, ...)`
+     * - Move to after some item X: `array.moveToIndex(indexOfX + 1`, ...)
+     * - Move to the end of the array: `array.moveToIndex(array.length, ...)` (see also `moveToEnd`)
+     *
+     * This interpretation of `destinationGap` does however make it less obvious how to move an item relative to its current position:
+     *
+     * - Move item B before its predecessor: `array.moveToIndex(indexOfB - 1, ...)`
+     * - Move item B after its successor: `array.moveToIndex(indexOfB + 2, ...)`
+     *
+     * Notice the asymmetry between `-1` and `+2` in the above examples.
+     * In such scenarios, it can often be easier to approach such edits by swapping adjacent items:
+     * If items A and B are adjacent, such that A precedes B,
+     * then they can be swapped with `array.moveToIndex(indexOfA, indexOfB)`.
+     *
      * @param sourceStart - The starting index of the range to move (inclusive).
      * @param sourceEnd - The ending index of the range to move (exclusive)
      * @param source - The source array to move items out of.
      * @throws Throws if the types of any of the items being moved are not allowed in the destination array,
      * if any of the input indices are not in the range [0, `array.length`], or if `sourceStart` is greater than `sourceEnd`.
      */
-    moveRangeToIndex(index: number, sourceStart: number, sourceEnd: number, source: TMoveFrom): void;
+    moveRangeToIndex(destinationGap: number, sourceStart: number, sourceEnd: number, source: TMoveFrom): void;
     /**
      * Returns a custom IterableIterator which throws usage errors if concurrent editing and iteration occurs.
      */
@@ -208,5 +341,5 @@ export declare function asIndex(key: string | symbol, exclusiveMax: number): num
  *
  * @param name - Unique identifier for this schema including the factory's scope.
  */
-export declare function arraySchema<TName extends string, const T extends ImplicitAllowedTypes, const ImplicitlyConstructable extends boolean>(identifier: TName, info: T, implicitlyConstructable: ImplicitlyConstructable, customizable: boolean): TreeNodeSchemaClass<TName, NodeKind.Array, TreeArrayNode<T> & WithType<TName, NodeKind.Array, unknown>, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T>>, ImplicitlyConstructable, T>;
+export declare function arraySchema<TName extends string, const T extends ImplicitAllowedTypes, const ImplicitlyConstructable extends boolean>(identifier: TName, info: T, implicitlyConstructable: ImplicitlyConstructable, customizable: boolean): TreeNodeSchemaBoth<TName, NodeKind.Array, TreeArrayNode<T> & WithType<TName, NodeKind.Array, unknown>, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T>>, ImplicitlyConstructable, T>;
 //# sourceMappingURL=arrayNode.d.ts.map

package/dist/simple-tree/arrayNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"arrayNode.d.ts","sourceRoot":"","sources":["../../src/simple-tree/arrayNode.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"arrayNode.d.ts","sourceRoot":"","sources":["../../src/simple-tree/arrayNode.ts"],"names":[],"mappings":"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"}

package/dist/simple-tree/arrayNode.js

@@ -17,12 +17,13 @@ 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 index_js_4 = require("../util/index.js");
-const toFlexSchema_js_1 = require("./toFlexSchema.js");
 const index_js_5 = require("./core/index.js");
 const treeNodeValid_js_1 = require("./treeNodeValid.js");
+const createContext_js_1 = require("./createContext.js");
 /**
  * A {@link TreeNode} which implements 'readonly T[]' and the array mutation APIs.
  * @public
@@ -185,7 +186,7 @@ function createArrayNodeProxy(allowAdditionalProperties, proxyTarget, dispatchTa
             }
             const maybeContent = field.at(maybeIndex);
             return (0, index_js_2.isFlexTreeNode)(maybeContent)
-                ? (0, proxies_js_1.getOrCreateNodeFromFlexTreeNode)(maybeContent)
+                ? (0, index_js_3.getOrCreateNodeFromInnerNode)(maybeContent)
                 : maybeContent;
         },
         set: (target, key, newValue, receiver) => {
@@ -237,7 +238,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: (0, index_js_2.isFlexTreeNode)(val) ? (0, proxies_js_1.getOrCreateNodeFromFlexTreeNode)(val) : val,
+                    value: (0, index_js_2.isFlexTreeNode)(val) ? (0, index_js_3.getOrCreateNodeFromInnerNode)(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,
@@ -308,7 +309,7 @@ class CustomArrayNodeBase extends TreeNodeWithArrayFeatures {
         if (val === undefined) {
             return val;
         }
-        return (0, proxies_js_1.getOrCreateNodeFromFlexTreeNode)(val);
+        return (0, index_js_3.getOrCreateNodeFromInnerNode)(val);
     }
     insertAt(index, ...value) {
         const field = getSequenceField(this);
@@ -352,13 +353,13 @@ class CustomArrayNodeBase extends TreeNodeWithArrayFeatures {
         validateIndex(sourceIndex, sourceField, "moveToEnd");
         this.moveRangeToIndex(this.length, sourceIndex, sourceIndex + 1, source);
     }
-    moveToIndex(destinationIndex, sourceIndex, source) {
+    moveToIndex(destinationGap, sourceIndex, source) {
         const sourceArray = source ?? this;
         const sourceField = getSequenceField(sourceArray);
         const destinationField = getSequenceField(this);
-        validateIndex(destinationIndex, destinationField, "moveToIndex", true);
+        validateIndex(destinationGap, destinationField, "moveToIndex", true);
         validateIndex(sourceIndex, sourceField, "moveToIndex");
-        this.moveRangeToIndex(destinationIndex, sourceIndex, sourceIndex + 1, source);
+        this.moveRangeToIndex(destinationGap, sourceIndex, sourceIndex + 1, source);
     }
     moveRangeToStart(sourceStart, sourceEnd, source) {
         validateIndexRange(sourceStart, sourceEnd, source ?? getSequenceField(this), "moveRangeToStart");
@@ -368,30 +369,35 @@ class CustomArrayNodeBase extends TreeNodeWithArrayFeatures {
         validateIndexRange(sourceStart, sourceEnd, source ?? getSequenceField(this), "moveRangeToEnd");
         this.moveRangeToIndex(this.length, sourceStart, sourceEnd, source);
     }
-    moveRangeToIndex(destinationIndex, sourceStart, sourceEnd, source) {
+    moveRangeToIndex(destinationGap, sourceStart, sourceEnd, source) {
         const destinationField = getSequenceField(this);
+        const destinationSchema = this.allowedTypes;
         const sourceField = source !== undefined ? getSequenceField(source) : destinationField;
-        validateIndex(destinationIndex, destinationField, "moveRangeToIndex", true);
+        validateIndex(destinationGap, destinationField, "moveRangeToIndex", true);
         validateIndexRange(sourceStart, sourceEnd, source ?? destinationField, "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)();
-                if (!destinationField.schema.types.has(sourceNode.schema)) {
+                const sourceSchema = (0, index_js_3.getSimpleNodeSchemaFromInnerNode)(sourceNode);
+                if (!destinationSchema.has(sourceSchema)) {
                     throw new internal_2.UsageError("Type in source sequence is not allowed in destination.");
                 }
             }
         }
         const movedCount = sourceEnd - sourceStart;
         if (!destinationField.context.isHydrated()) {
-            if (!(0, index_js_2.isMapTreeSequenceField)(sourceField)) {
+            if (!(sourceField instanceof index_js_5.UnhydratedTreeSequenceField)) {
                 throw new internal_2.UsageError("Cannot move elements from an unhydrated array to a hydrated array.");
             }
-            if (sourceField !== destinationField || destinationIndex < sourceStart) {
-                destinationField.editor.insert(destinationIndex, sourceField.editor.remove(sourceStart, movedCount));
+            if (sourceField.context.isHydrated()) {
+                throw new internal_2.UsageError("Cannot move elements from an unhydrated array to a hydrated array.");
+            }
+            if (sourceField !== destinationField || destinationGap < sourceStart) {
+                destinationField.editor.insert(destinationGap, sourceField.editor.remove(sourceStart, movedCount));
             }
-            else if (destinationIndex > sourceStart + movedCount) {
-                destinationField.editor.insert(destinationIndex - movedCount, sourceField.editor.remove(sourceStart, movedCount));
+            else if (destinationGap > sourceStart + movedCount) {
+                destinationField.editor.insert(destinationGap - movedCount, sourceField.editor.remove(sourceStart, movedCount));
             }
         }
         else {
@@ -401,7 +407,7 @@ class CustomArrayNodeBase extends TreeNodeWithArrayFeatures {
             if (sourceField.context !== destinationField.context) {
                 throw new internal_2.UsageError("Cannot move elements between two different TreeViews.");
             }
-            destinationField.context.checkout.editor.move(sourceField.getFieldPath(), sourceStart, movedCount, destinationField.getFieldPath(), destinationIndex);
+            destinationField.context.checkout.editor.move(sourceField.getFieldPath(), sourceStart, movedCount, destinationField.getFieldPath(), destinationGap);
         }
     }
     values() {
@@ -428,7 +434,7 @@ CustomArrayNodeBase.kind = index_js_3.NodeKind.Array;
  */
 // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 function arraySchema(identifier, info, implicitlyConstructable, customizable) {
-    let flexSchema;
+    const lazyChildTypes = new internal_1.Lazy(() => (0, schemaTypes_js_1.normalizeAllowedTypes)(info));
     let unhydratedContext;
     // This class returns a proxy from its constructor to handle numeric indexing.
     // Alternatively it could extend a normal class which gets tons of numeric properties added.
@@ -448,12 +454,11 @@ function arraySchema(identifier, info, implicitlyConstructable, customizable) {
             return createArrayNodeProxy(customizable, proxyTarget, instance);
         }
         static buildRawNode(instance, input) {
-            return (0, index_js_2.getOrCreateMapTreeNode)(unhydratedContext, flexSchema, (0, toMapTree_js_1.mapTreeFromNodeData)(input, this));
+            return index_js_5.UnhydratedFlexTreeNode.getOrCreate(unhydratedContext, (0, toMapTree_js_1.mapTreeFromNodeData)(input, this));
         }
         static oneTimeSetup() {
             const schema = this;
-            flexSchema = (0, toFlexSchema_js_1.getFlexSchema)(schema);
-            unhydratedContext = new index_js_2.UnhydratedContext((0, toFlexSchema_js_1.toFlexSchema)(schema));
+            unhydratedContext = (0, createContext_js_1.getUnhydratedContext)(schema);
             // First run, do extra validation.
             // TODO: provide a way for TreeConfiguration to trigger this same validation to ensure it gets run early.
             // Scan for shadowing inherited members which won't work, but stop scan early to allow shadowing built in (which seems to work ok).
@@ -475,6 +480,10 @@ function arraySchema(identifier, info, implicitlyConstructable, customizable) {
                     prototype = Reflect.getPrototypeOf(prototype);
                 }
             }
+            return unhydratedContext;
+        }
+        static get childTypes() {
+            return lazyChildTypes.value;
         }
         // eslint-disable-next-line import/no-deprecated
         get [index_js_3.typeNameSymbol]() {
@@ -486,6 +495,9 @@ function arraySchema(identifier, info, implicitlyConstructable, customizable) {
         get simpleSchema() {
             return info;
         }
+        get allowedTypes() {
+            return lazyChildTypes.value;
+        }
     }
     Schema.constructorCached = undefined;
     Schema.identifier = identifier;