@fluidframework/tree 2.117.0 → 3.0.0

package/dist/simple-tree/core/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/simple-tree/core/types.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAGH,kEAA6D;AAE7D,+DAAqF;AA6BrF,SAAgB,cAAc,CAAC,IAAsB;IACpD,IAAA,iBAAM,EAAC,IAAA,yBAAc,EAAC,IAAI,CAAC,EAAE,KAAK,CAAC,8BAA8B,CAAC,CAAC;IACnE,OAAO,IAAI,CAAC;AACb,CAAC;AAHD,wCAGC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport type { ErasedType } from \"@fluidframework/core-interfaces\";\nimport { assert } from \"@fluidframework/core-utils/internal\";\n\nimport { isFlexTreeNode, type FlexTreeNode } from \"../../feature-libraries/index.js\";\n\n/**\n * Type alias to document which values are un-hydrated.\n *\n * Un-hydrated values are nodes produced from schema's create functions that haven't been inserted into a tree yet.\n *\n * Since un-hydrated nodes become hydrated when inserted, strong typing can't be used to distinguish them.\n * This no-op wrapper is used instead.\n * @remarks\n * Nodes which are Unhydrated report {@link TreeStatus}.new from `Tree.status(node)`.\n * @privateRemarks\n * TODO: Linking tree status is failing in intellisense and linking directly to its .new item is failing in API extractor as well.\n * WOuld be nice to have a working link here.\n * @public\n */\nexport type Unhydrated<T> = T;\n\n/**\n * A node type internal to `@fluidframework/tree`.\n * @remarks\n * This type is used in the construction of {@link TreeNode} as an implementation detail, but leaks into the public API due to how schema are implemented.\n * @privateRemarks\n * A {@link FlexTreeNode}. Includes {@link RawTreeNode}s.\n * @sealed @public\n */\nexport interface InternalTreeNode\n\textends ErasedType<\"@fluidframework/tree.InternalTreeNode\"> {}\n\nexport function toFlexTreeNode(node: InternalTreeNode): FlexTreeNode {\n\tassert(isFlexTreeNode(node), 0x963 /* Invalid InternalTreeNode */);\n\treturn node;\n}\n"]}
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/simple-tree/core/types.ts"],"names":[],"mappings":";AAAA;;;GAGG;;AAkCH,wCAGC;AAlCD,kEAA6D;AAE7D,+DAAqF;AA6BrF,SAAgB,cAAc,CAAC,IAAsB;IACpD,IAAA,iBAAM,EAAC,IAAA,yBAAc,EAAC,IAAI,CAAC,EAAE,KAAK,CAAC,8BAA8B,CAAC,CAAC;IACnE,OAAO,IAAI,CAAC;AACb,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport type { ErasedType } from \"@fluidframework/core-interfaces\";\nimport { assert } from \"@fluidframework/core-utils/internal\";\n\nimport { isFlexTreeNode, type FlexTreeNode } from \"../../feature-libraries/index.js\";\n\n/**\n * Type alias to document which values are un-hydrated.\n *\n * Un-hydrated values are nodes produced from schema's create functions that haven't been inserted into a tree yet.\n *\n * Since un-hydrated nodes become hydrated when inserted, strong typing can't be used to distinguish them.\n * This no-op wrapper is used instead.\n * @remarks\n * Nodes which are Unhydrated report {@link TreeStatus}.new from `Tree.status(node)`.\n * @privateRemarks\n * TODO: Linking tree status is failing in intellisense and linking directly to its .new item is failing in API extractor as well.\n * WOuld be nice to have a working link here.\n * @public\n */\nexport type Unhydrated<T> = T;\n\n/**\n * A node type internal to `@fluidframework/tree`.\n * @remarks\n * This type is used in the construction of {@link TreeNode} as an implementation detail, but leaks into the public API due to how schema are implemented.\n * @privateRemarks\n * A {@link FlexTreeNode}. Includes {@link RawTreeNode}s.\n * @sealed @public\n */\nexport interface InternalTreeNode\n\textends ErasedType<\"@fluidframework/tree.InternalTreeNode\"> {}\n\nexport function toFlexTreeNode(node: InternalTreeNode): FlexTreeNode {\n\tassert(isFlexTreeNode(node), 0x963 /* Invalid InternalTreeNode */);\n\treturn node;\n}\n"]}

package/dist/simple-tree/core/unhydratedFlexTree.js

@@ -3,10 +3,11 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-var _UnhydratedFlexTreeNode_instances, _a, _UnhydratedFlexTreeNode_emitDeepChangesToAncestorArrays, _UnhydratedFlexTreeNode_emitSubtreeChangedEvents, _b, _c;
+var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.unsupportedUsageError = exports.createField = exports.UnhydratedSequenceField = exports.UnhydratedOptionalField = exports.UnhydratedFlexTreeField = exports.UnhydratedContext = exports.UnhydratedFlexTreeNode = void 0;
-const tslib_1 = require("tslib");
+exports.UnhydratedSequenceField = exports.UnhydratedOptionalField = exports.UnhydratedFlexTreeField = exports.UnhydratedContext = exports.UnhydratedFlexTreeNode = void 0;
+exports.createField = createField;
+exports.unsupportedUsageError = unsupportedUsageError;
 const client_utils_1 = require("@fluid-internal/client-utils");
 const internal_1 = require("@fluidframework/core-utils/internal");
 const internal_2 = require("@fluidframework/telemetry-utils/internal");
@@ -23,12 +24,27 @@ const syntheticDetachedNodeId = { minor: 0 };
  * The {@link Unhydrated} implementation of {@link FlexTreeNode}.
  */
 class UnhydratedFlexTreeNode {
+    data;
+    fieldsAll;
+    simpleContext;
     isHydrated() {
         return false;
     }
+    location = unparentedLocation;
     get storedSchema() {
         return (this.context.schema.nodeSchema.get(this.data.type) ?? (0, internal_1.fail)(0xb46 /* missing schema */));
     }
+    /**
+     * Cache storing the {@link TreeNode} for this inner node.
+     * @remarks
+     * When creating a `TreeNode` for this `UnhydratedFlexTreeNode`, cache the `TreeNode` in this property.
+     * Currently this is done by {@link TreeNodeKernel}.
+     *
+     * See {@link getOrCreateNodeFromInnerNode} how to get the `TreeNode`, even if not already created, regardless of hydration status.
+     */
+    treeNode;
+    [index_js_2.flexTreeMarker] = index_js_2.FlexTreeEntityKind.Node;
+    _events = (0, client_utils_1.createEmitter)();
     get events() {
         return this._events;
     }
@@ -56,32 +72,28 @@ class UnhydratedFlexTreeNode {
      * See {@link getUnhydratedContext}.
      */
     simpleContext) {
-        _UnhydratedFlexTreeNode_instances.add(this);
         this.data = data;
         this.fieldsAll = fieldsAll;
         this.simpleContext = simpleContext;
-        this.location = unparentedLocation;
-        this[_b] = index_js_2.FlexTreeEntityKind.Node;
-        this._events = (0, client_utils_1.createEmitter)();
-        /**
-         * The non-empty fields on this node.
-         * @remarks
-         * This is needed to implement {@link MapTreeNodeViewGeneric.fields}, which must omit empty fields.
-         * Due to having to detect if a field is empty, this forces the evaluation of any pending defaults in the fields.
-         * Use {@link allFieldsLazy} to avoid evaluating pending defaults.
-         */
-        this.fields = {
-            get: (key) => this.tryGetField(key),
-            [Symbol.iterator]: () => {
-                index_js_2.currentObserver?.observeNodeFields(this);
-                return (0, index_js_3.filterIterable)(this.fieldsAll, ([, field]) => field.length > 0);
-            },
-        };
         for (const [_key, field] of this.fieldsAll) {
             field.parent = this;
         }
     }
-    [(_UnhydratedFlexTreeNode_instances = new WeakSet(), _b = index_js_2.flexTreeMarker, Symbol.iterator)]() {
+    /**
+     * The non-empty fields on this node.
+     * @remarks
+     * This is needed to implement {@link MapTreeNodeViewGeneric.fields}, which must omit empty fields.
+     * Due to having to detect if a field is empty, this forces the evaluation of any pending defaults in the fields.
+     * Use {@link allFieldsLazy} to avoid evaluating pending defaults.
+     */
+    fields = {
+        get: (key) => this.tryGetField(key),
+        [Symbol.iterator]: () => {
+            index_js_2.currentObserver?.observeNodeFields(this);
+            return (0, index_js_3.filterIterable)(this.fieldsAll, ([, field]) => field.length > 0);
+        },
+    };
+    [Symbol.iterator]() {
         return (0, index_js_3.mapIterable)(this.fields, ([, field]) => field)[Symbol.iterator]();
     }
     /**
@@ -173,57 +185,76 @@ class UnhydratedFlexTreeNode {
         // Array ancestors and the nodes above them are handled by
         // #emitDeepChangesToAncestorArrays, which propagates subtree events above
         // each array boundary in the correct order.
-        tslib_1.__classPrivateFieldGet(this, _UnhydratedFlexTreeNode_instances, "m", _UnhydratedFlexTreeNode_emitSubtreeChangedEvents).call(this);
+        this.#emitSubtreeChangedEvents();
         // Mirrors the onlyDeepChanges block in anchorSet.ts for unhydrated nodes.
-        tslib_1.__classPrivateFieldGet(this, _UnhydratedFlexTreeNode_instances, "m", _UnhydratedFlexTreeNode_emitDeepChangesToAncestorArrays).call(this);
+        this.#emitDeepChangesToAncestorArrays();
     }
-}
-exports.UnhydratedFlexTreeNode = UnhydratedFlexTreeNode;
-_a = UnhydratedFlexTreeNode, _UnhydratedFlexTreeNode_emitDeepChangesToAncestorArrays = function _UnhydratedFlexTreeNode_emitDeepChangesToAncestorArrays() {
-    const location = this.parentField;
-    const parentField = location.parent;
-    const parentNode = parentField.parent;
-    if (parentNode === undefined || !(parentNode instanceof _a)) {
-        return;
-    }
-    // Only emit on array ancestors (EmptyKey); object/map ancestors don't carry delta payloads.
-    if (parentField.key === index_js_1.EmptyKey) {
-        const index = location.index;
-        const syntheticMarks = [];
-        if (index > 0) {
-            syntheticMarks.push({ count: index });
+    /**
+     * Emit `childrenChangedAfterBatch` on each ancestor array node with synthetic
+     * marks indicating a deep change at this node's position within the array.
+     * After emitting on each array ancestor, propagates subtree-changed events
+     * upward from that array so that ancestor nodes above the array receive their
+     * `treeChanged` events after the array's own event.
+     */
+    #emitDeepChangesToAncestorArrays() {
+        const location = this.parentField;
+        const parentField = location.parent;
+        const parentNode = parentField.parent;
+        if (parentNode === undefined || !(parentNode instanceof _a)) {
+            return;
         }
-        // `fields` presence (not content) signals a deep change to deltaMarksToArrayOps.
-        syntheticMarks.push({ count: 1, fields: new Map([[index_js_1.EmptyKey, { marks: [] }]]) });
-        parentNode._events.emit("childrenChangedAfterBatch", {
-            changedFields: new Set([index_js_1.EmptyKey]),
-            fieldMarks: new Map([[index_js_1.EmptyKey, syntheticMarks]]),
-        });
-        // Propagate subtree-changed events from the array upward so that
-        // ancestors above this array receive treeChanged after the array itself.
-        tslib_1.__classPrivateFieldGet(parentNode, _UnhydratedFlexTreeNode_instances, "m", _UnhydratedFlexTreeNode_emitSubtreeChangedEvents).call(parentNode);
-    }
-    tslib_1.__classPrivateFieldGet(parentNode, _UnhydratedFlexTreeNode_instances, "m", _UnhydratedFlexTreeNode_emitDeepChangesToAncestorArrays).call(parentNode);
-}, _UnhydratedFlexTreeNode_emitSubtreeChangedEvents = function _UnhydratedFlexTreeNode_emitSubtreeChangedEvents() {
-    this._events.emit("subtreeChangedAfterBatch");
-    const parentField = this.parentField.parent;
-    if (parentField.key === index_js_1.EmptyKey) {
-        // This node is an array element; stop here so that array ancestor
-        // events fire in the correct order relative to this node's treeChanged.
-        return;
-    }
-    const parent = parentField.parent;
-    (0, internal_1.assert)(parent === undefined || parent instanceof _a, 0xb76 /* Unhydrated node's parent should be an unhydrated node */);
-    if (parent !== undefined) {
-        tslib_1.__classPrivateFieldGet(parent, _UnhydratedFlexTreeNode_instances, "m", _UnhydratedFlexTreeNode_emitSubtreeChangedEvents).call(parent);
+        // Only emit on array ancestors (EmptyKey); object/map ancestors don't carry delta payloads.
+        if (parentField.key === index_js_1.EmptyKey) {
+            const index = location.index;
+            const syntheticMarks = [];
+            if (index > 0) {
+                syntheticMarks.push({ count: index });
+            }
+            // `fields` presence (not content) signals a deep change to deltaMarksToArrayOps.
+            syntheticMarks.push({ count: 1, fields: new Map([[index_js_1.EmptyKey, { marks: [] }]]) });
+            parentNode._events.emit("childrenChangedAfterBatch", {
+                changedFields: new Set([index_js_1.EmptyKey]),
+                fieldMarks: new Map([[index_js_1.EmptyKey, syntheticMarks]]),
+            });
+            // Propagate subtree-changed events from the array upward so that
+            // ancestors above this array receive treeChanged after the array itself.
+            parentNode.#emitSubtreeChangedEvents();
+        }
+        parentNode.#emitDeepChangesToAncestorArrays();
     }
-};
+    /**
+     * Emit `subtreeChangedAfterBatch` on this node and propagate upward to
+     * ancestors, stopping before the first ancestor array node.
+     * Propagation stops at an array boundary because
+     * {@link UnhydratedFlexTreeNode.#emitDeepChangesToAncestorArrays} is
+     * responsible for emitting on array ancestors and the nodes above them
+     * in the correct order.
+     */
+    #emitSubtreeChangedEvents() {
+        this._events.emit("subtreeChangedAfterBatch");
+        const parentField = this.parentField.parent;
+        if (parentField.key === index_js_1.EmptyKey) {
+            // This node is an array element; stop here so that array ancestor
+            // events fire in the correct order relative to this node's treeChanged.
+            return;
+        }
+        const parent = parentField.parent;
+        (0, internal_1.assert)(parent === undefined || parent instanceof _a, 0xb76 /* Unhydrated node's parent should be an unhydrated node */);
+        if (parent !== undefined) {
+            parent.#emitSubtreeChangedEvents();
+        }
+    }
+}
+exports.UnhydratedFlexTreeNode = UnhydratedFlexTreeNode;
+_a = UnhydratedFlexTreeNode;
 /**
  * Implementation of `FlexTreeContext`.
  *
  * @remarks An editor is required to edit the FlexTree.
  */
 class UnhydratedContext {
+    schemaPolicy;
+    schema;
     /**
      * @param flexSchema - Schema to use when working with the tree.
      */
@@ -262,6 +293,12 @@ const unparentedLocation = {
  * The {@link Unhydrated} implementation of {@link FlexTreeField}.
  */
 class UnhydratedFlexTreeField {
+    context;
+    schema;
+    key;
+    lazyChildren;
+    [index_js_2.flexTreeMarker] = index_js_2.FlexTreeEntityKind.Field;
+    parent = undefined;
     constructor(context, schema, key, 
     /**
      * The children of this field.
@@ -275,8 +312,6 @@ class UnhydratedFlexTreeField {
         this.schema = schema;
         this.key = key;
         this.lazyChildren = lazyChildren;
-        this[_c] = index_js_2.FlexTreeEntityKind.Field;
-        this.parent = undefined;
         // When this field is created (which only happens one time, because it is cached), all the children become parented for the first time.
         // "Adopt" each child by updating its parent information to point to this field.
         if (Array.isArray(lazyChildren)) {
@@ -332,7 +367,7 @@ class UnhydratedFlexTreeField {
         const m = this.children[i];
         return m;
     }
-    [(_c = index_js_2.flexTreeMarker, Symbol.iterator)]() {
+    [Symbol.iterator]() {
         return this.children[Symbol.iterator]();
     }
     /**
@@ -379,24 +414,21 @@ exports.UnhydratedFlexTreeField = UnhydratedFlexTreeField;
  * The {@link Unhydrated} implementation of {@link FlexTreeOptionalField}.
  */
 class UnhydratedOptionalField extends UnhydratedFlexTreeField {
-    constructor() {
-        super(...arguments);
-        this.editor = {
-            set: (newContent) => {
-                if (newContent !== undefined) {
-                    (0, internal_1.assert)(newContent instanceof UnhydratedFlexTreeNode, 0xbb7 /* Expected unhydrated node */);
+    editor = {
+        set: (newContent) => {
+            if (newContent !== undefined) {
+                (0, internal_1.assert)(newContent instanceof UnhydratedFlexTreeNode, 0xbb7 /* Expected unhydrated node */);
+            }
+            this.edit((mapTrees) => {
+                if (newContent === undefined) {
+                    mapTrees.length = 0;
                 }
-                this.edit((mapTrees) => {
-                    if (newContent === undefined) {
-                        mapTrees.length = 0;
-                    }
-                    else {
-                        mapTrees[0] = newContent;
-                    }
-                });
-            },
-        };
-    }
+                else {
+                    mapTrees[0] = newContent;
+                }
+            });
+        },
+    };
     get content() {
         const value = this.children[0];
         if (value !== undefined) {
@@ -417,78 +449,75 @@ class UnhydratedRequiredField extends UnhydratedOptionalField {
  * The {@link Unhydrated} implementation of {@link FlexTreeSequenceField}.
  */
 class UnhydratedSequenceField extends UnhydratedFlexTreeField {
-    constructor() {
-        super(...arguments);
-        this.editor = {
-            insert: (index, newContent) => {
-                for (const c of newContent) {
-                    (0, internal_1.assert)(c !== undefined, 0xa0a /* Unexpected sparse array content */);
-                    (0, internal_1.assert)(c instanceof UnhydratedFlexTreeNode, 0xbb8 /* Expected unhydrated node */);
+    editor = {
+        insert: (index, newContent) => {
+            for (const c of newContent) {
+                (0, internal_1.assert)(c !== undefined, 0xa0a /* Unexpected sparse array content */);
+                (0, internal_1.assert)(c instanceof UnhydratedFlexTreeNode, 0xbb8 /* Expected unhydrated node */);
+            }
+            const newContentChecked = newContent;
+            const insertCount = newContentChecked.length;
+            const marks = [];
+            if (index > 0)
+                marks.push({ count: index });
+            marks.push({ count: insertCount, attach: syntheticDetachedNodeId });
+            this.edit((mapTrees) => {
+                if (newContent.length < 1000) {
+                    // For "smallish arrays" (`1000` is not empirically derived), the `splice` function is appropriate...
+                    mapTrees.splice(index, 0, ...newContentChecked);
                 }
-                const newContentChecked = newContent;
-                const insertCount = newContentChecked.length;
-                const marks = [];
-                if (index > 0)
-                    marks.push({ count: index });
-                marks.push({ count: insertCount, attach: syntheticDetachedNodeId });
+                else {
+                    // ...but we avoid using `splice` + spread for very large input arrays since there is a limit on how many elements can be spread (too many will overflow the stack).
+                    return [...mapTrees.slice(0, index), ...newContentChecked, ...mapTrees.slice(index)];
+                }
+            }, marks);
+        },
+        remove: (index, count) => {
+            for (let i = index; i < index + count; i++) {
+                const c = this.children[i];
+                (0, internal_1.assert)(c !== undefined, 0xa0b /* Unexpected sparse array */);
+            }
+            const marks = [];
+            if (index > 0)
+                marks.push({ count: index });
+            marks.push({ count, detach: syntheticDetachedNodeId });
+            let removed;
+            this.edit((mapTrees) => {
+                removed = mapTrees.splice(index, count);
+            }, marks);
+            return removed ?? (0, internal_1.fail)(0xb4a /* Expected removed to be set by edit */);
+        },
+        move: (sourceIndex, count, destIndex, source) => {
+            const sourceField = source ?? this;
+            if (sourceField === this) {
+                // Within-field move: do both operations in a single edit to emit only one event
+                const marks = buildUnhydratedMoveMarks(sourceIndex, count, destIndex);
                 this.edit((mapTrees) => {
-                    if (newContent.length < 1000) {
+                    const removed = mapTrees.splice(sourceIndex, count);
+                    // Adjust destination index if it comes after the source
+                    const adjustedDest = destIndex > sourceIndex ? destIndex - count : destIndex;
+                    if (removed.length < 1000) {
                         // For "smallish arrays" (`1000` is not empirically derived), the `splice` function is appropriate...
-                        mapTrees.splice(index, 0, ...newContentChecked);
+                        mapTrees.splice(adjustedDest, 0, ...removed);
                     }
                     else {
-                        // ...but we avoid using `splice` + spread for very large input arrays since there is a limit on how many elements can be spread (too many will overflow the stack).
-                        return [...mapTrees.slice(0, index), ...newContentChecked, ...mapTrees.slice(index)];
+                        // ...but we avoid using `splice` + spread for very large arrays since there is a limit on how many elements can be spread (too many will overflow the stack).
+                        return [
+                            ...mapTrees.slice(0, adjustedDest),
+                            ...removed,
+                            ...mapTrees.slice(adjustedDest),
+                        ];
                     }
                 }, marks);
-            },
-            remove: (index, count) => {
-                for (let i = index; i < index + count; i++) {
-                    const c = this.children[i];
-                    (0, internal_1.assert)(c !== undefined, 0xa0b /* Unexpected sparse array */);
-                }
-                const marks = [];
-                if (index > 0)
-                    marks.push({ count: index });
-                marks.push({ count, detach: syntheticDetachedNodeId });
-                let removed;
-                this.edit((mapTrees) => {
-                    removed = mapTrees.splice(index, count);
-                }, marks);
-                return removed ?? (0, internal_1.fail)(0xb4a /* Expected removed to be set by edit */);
-            },
-            move: (sourceIndex, count, destIndex, source) => {
-                const sourceField = source ?? this;
-                if (sourceField === this) {
-                    // Within-field move: do both operations in a single edit to emit only one event
-                    const marks = buildUnhydratedMoveMarks(sourceIndex, count, destIndex);
-                    this.edit((mapTrees) => {
-                        const removed = mapTrees.splice(sourceIndex, count);
-                        // Adjust destination index if it comes after the source
-                        const adjustedDest = destIndex > sourceIndex ? destIndex - count : destIndex;
-                        if (removed.length < 1000) {
-                            // For "smallish arrays" (`1000` is not empirically derived), the `splice` function is appropriate...
-                            mapTrees.splice(adjustedDest, 0, ...removed);
-                        }
-                        else {
-                            // ...but we avoid using `splice` + spread for very large arrays since there is a limit on how many elements can be spread (too many will overflow the stack).
-                            return [
-                                ...mapTrees.slice(0, adjustedDest),
-                                ...removed,
-                                ...mapTrees.slice(adjustedDest),
-                            ];
-                        }
-                    }, marks);
-                }
-                else {
-                    // Cross-field move: remove from source, insert into destination
-                    // Each field emits one event (correct behavior for different fields)
-                    const removed = sourceField.editor.remove(sourceIndex, count);
-                    this.editor.insert(destIndex, removed);
-                }
-            },
-        };
-    }
+            }
+            else {
+                // Cross-field move: remove from source, insert into destination
+                // Each field emits one event (correct behavior for different fields)
+                const removed = sourceField.editor.remove(sourceIndex, count);
+                this.editor.insert(destIndex, removed);
+            }
+        },
+    };
     at(index) {
         const i = (0, index_js_2.indexForAt)(index, this.length);
         if (i === undefined) {
@@ -560,9 +589,7 @@ function createField(...args) {
         }
     }
 }
-exports.createField = createField;
 function unsupportedUsageError(message) {
     return new internal_2.UsageError(`${message ?? "Operation"} is not supported for content that has not yet been inserted into the tree`);
 }
-exports.unsupportedUsageError = unsupportedUsageError;
 //# sourceMappingURL=unhydratedFlexTree.js.map