@fluidframework/tree 2.0.0-rc.2.0.2 → 2.0.0-rc.3.0.0

package/dist/simple-tree/proxies.js

@@ -4,19 +4,15 @@
  * Licensed under the MIT License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractFactoryContent = exports.createRawNodeProxy = exports.mapStaticDispatchMap = exports.arrayNodePrototypeProperties = exports.getSequenceField = exports.createObjectProxy = exports.createNodeProxy = exports.getOrCreateNodeProxy = exports.getClassSchema = exports.simpleSchemaSymbol = exports.getProxyForField = exports.isTreeNode = void 0;
-const core_utils_1 = require("@fluidframework/core-utils");
-const index_js_1 = require("../util/index.js");
+exports.markContentType = exports.extractFactoryContent = exports.prepareContentForInsert = exports.getOrCreateNodeProxy = exports.getProxyForField = exports.isTreeNode = 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 index_js_3 = require("../core/index.js");
-// TODO: decide how to deal with dependencies on flex-tree implementation.
-// eslint-disable-next-line import/no-internal-modules
-const lazyNode_js_1 = require("../feature-libraries/flex-tree/lazyNode.js");
-const schemaTypes_js_1 = require("./schemaTypes.js");
-const treeArrayNode_js_1 = require("./treeArrayNode.js");
-const flexNode_js_1 = require("./flexNode.js");
-const toMapTree_js_1 = require("./toMapTree.js");
+const index_js_3 = require("../util/index.js");
+const proxyBinding_js_1 = require("./proxyBinding.js");
 const rawNode_js_1 = require("./rawNode.js");
+const schemaCaching_js_1 = require("./schemaCaching.js");
+const schemaTypes_js_1 = require("./schemaTypes.js");
 /**
  * Detects if the given 'candidate' is a TreeNode.
  *
@@ -32,7 +28,7 @@ const rawNode_js_1 = require("./rawNode.js");
  * @returns true if the given 'candidate' is a hydrated TreeNode.
  */
 function isTreeNode(candidate) {
-    return (0, flexNode_js_1.tryGetFlexNode)(candidate) !== undefined;
+    return (0, proxyBinding_js_1.tryGetFlexNode)(candidate) !== undefined;
 }
 exports.isTreeNode = isTreeNode;
 /**
@@ -61,609 +57,106 @@ function getProxyForField(field) {
         case index_js_2.FieldKinds.sequence: {
             // 'getProxyForNode' handles FieldNodes by unconditionally creating a array node proxy, making
             // this case unreachable as long as users follow the 'array recipe'.
-            (0, index_js_1.fail)("'sequence' field is unexpected.");
+            (0, index_js_3.fail)("'sequence' field is unexpected.");
+        }
+        case index_js_2.FieldKinds.identifier: {
+            const identifier = field.boxedAt(0);
+            (0, internal_1.assert)(identifier !== undefined, 0x91a /* identifier must exist */);
+            return getOrCreateNodeProxy(identifier);
         }
         default:
-            (0, index_js_1.fail)("invalid field kind");
+            (0, index_js_3.fail)("invalid field kind");
     }
 }
 exports.getProxyForField = getProxyForField;
-/**
- * A symbol for storing TreeNodeSchemaClass on FlexTreeNode's schema.
- */
-exports.simpleSchemaSymbol = Symbol(`simpleSchema`);
-function getClassSchema(schema) {
-    if (exports.simpleSchemaSymbol in schema) {
-        return schema[exports.simpleSchemaSymbol];
-    }
-    return undefined;
-}
-exports.getClassSchema = getClassSchema;
 function getOrCreateNodeProxy(flexNode) {
-    const cachedProxy = (0, flexNode_js_1.tryGetFlexNodeTarget)(flexNode);
+    const cachedProxy = (0, proxyBinding_js_1.tryGetProxy)(flexNode);
     if (cachedProxy !== undefined) {
         return cachedProxy;
     }
     const schema = flexNode.schema;
-    let output;
-    const classSchema = getClassSchema(schema);
-    if (classSchema !== undefined) {
-        if (typeof classSchema === "function") {
-            const simpleSchema = classSchema;
-            output = new simpleSchema(flexNode);
-        }
-        else {
-            output = schema.create(flexNode);
-        }
+    const classSchema = (0, schemaCaching_js_1.tryGetSimpleNodeSchema)(schema);
+    (0, internal_1.assert)(classSchema !== undefined, 0x91b /* node without schema */);
+    if (typeof classSchema === "function") {
+        const simpleSchema = classSchema;
+        return new simpleSchema(flexNode);
     }
     else {
-        // Fallback to createNodeProxy if needed.
-        // TODO: maybe remove this fallback and error once migration to class based schema is done.
-        output = createNodeProxy(flexNode, false);
+        return classSchema.create(flexNode);
     }
-    return output;
 }
 exports.getOrCreateNodeProxy = getOrCreateNodeProxy;
 /**
- * @param flexNode - underlying tree node which this proxy should wrap.
- * @param allowAdditionalProperties - If true, setting of unexpected properties will be forwarded to the target object.
- * Otherwise setting of unexpected properties will error.
- * @param customTargetObject - Target object of the proxy.
- * If not provided an empty collection of the relevant type is used for the target and a separate object created to dispatch methods.
- * If provided, the customTargetObject will be used as both the dispatch object and the proxy target, and therefor must provide needed functionality depending on the schema kind.
+ * Records any proxies in the given content tree and does the necessary bookkeeping to ensure they are synchronized with subsequent reads of the tree.
+ * @remarks If the content tree contains any proxies, this function must be called just prior to inserting the content into the tree.
+ * Specifically, no other content may be inserted into the tree between the invocation of this function and the insertion of `content`.
+ * The insertion of `content` must occur or else this function will cause memory leaks.
+ * @param content - the tree of content to be inserted, of which any of its object/map/array nodes might be a proxy
+ * @param anchors - the {@link AnchorSet} for the tree
+ * @returns The content after having all proxies replaced inline with plain javascript objects.
+ * See {@link extractFactoryContent} for more details.
  */
-function createNodeProxy(flexNode, allowAdditionalProperties, targetObject) {
-    const schema = flexNode.schema;
-    if ((0, index_js_2.schemaIsLeaf)(schema)) {
-        // Can't use `??` here since null is a valid TreeValue.
-        (0, core_utils_1.assert)(flexNode.value !== undefined, 0x887 /* Leaf must have value */);
-        return flexNode.value;
-    }
-    let proxy;
-    if ((0, index_js_2.schemaIsMap)(schema)) {
-        proxy = createMapProxy(allowAdditionalProperties, targetObject);
-    }
-    else if ((0, index_js_2.schemaIsFieldNode)(schema)) {
-        proxy = createArrayNodeProxy(allowAdditionalProperties, targetObject);
-    }
-    else if ((0, index_js_2.schemaIsObjectNode)(schema)) {
-        proxy = createObjectProxy(schema, allowAdditionalProperties, targetObject);
+function prepareContentForInsert(content, forest) {
+    if ((0, index_js_3.isReadonlyArray)(content)) {
+        return prepareArrayContentForInsert(content, forest);
     }
-    else {
-        (0, index_js_1.fail)("unrecognized node kind");
-    }
-    (0, flexNode_js_1.setFlexNode)(proxy, flexNode);
-    return proxy;
-}
-exports.createNodeProxy = createNodeProxy;
-/**
- * @param allowAdditionalProperties - If true, setting of unexpected properties will be forwarded to the target object.
- * Otherwise setting of unexpected properties will error.
- * @param customTargetObject - Target object of the proxy.
- * If not provided `{}` is used for the target.
- */
-function createObjectProxy(schema, allowAdditionalProperties, targetObject = {}) {
-    // To satisfy 'deepEquals' level scrutiny, the target of the proxy must be an object with the same
-    // prototype as an object literal '{}'.  This is because 'deepEquals' uses 'Object.getPrototypeOf'
-    // as a way to quickly reject objects with different prototype chains.
-    //
-    // (Note that the prototype of an object literal appears as '[Object: null prototype] {}', not because
-    // the prototype is null, but because the prototype object itself has a null prototype.)
-    // TODO: Although the target is an object literal, it's still worthwhile to try experimenting with
-    // a dispatch object to see if it improves performance.
-    const proxy = new Proxy(targetObject, {
-        get(target, key) {
-            const field = (0, flexNode_js_1.getFlexNode)(proxy).tryGetField(key);
-            if (field !== undefined) {
-                return getProxyForField(field);
-            }
-            // Pass the proxy as the receiver here, so that any methods on the prototype receive `proxy` as `this`.
-            return Reflect.get(target, key, proxy);
-        },
-        set(target, key, value) {
-            const flexNode = (0, flexNode_js_1.getFlexNode)(proxy);
-            const flexNodeSchema = flexNode.schema;
-            (0, core_utils_1.assert)(flexNodeSchema instanceof index_js_2.FlexObjectNodeSchema, 0x888 /* invalid schema */);
-            const fieldSchema = flexNodeSchema.objectNodeFields.get(key);
-            if (fieldSchema === undefined) {
-                return allowAdditionalProperties ? Reflect.set(target, key, value) : false;
-            }
-            // TODO: Is it safe to assume 'content' is a LazyObjectNode?
-            (0, core_utils_1.assert)(flexNode instanceof lazyNode_js_1.LazyObjectNode, 0x7e0 /* invalid content */);
-            (0, core_utils_1.assert)(typeof key === "string", 0x7e1 /* invalid key */);
-            const field = (0, lazyNode_js_1.getBoxedField)(flexNode, (0, index_js_1.brand)(key), fieldSchema);
-            switch (field.schema.kind) {
-                case index_js_2.FieldKinds.required:
-                case index_js_2.FieldKinds.optional: {
-                    const typedField = field;
-                    const { content, hydrateProxies } = extractFactoryContent(value);
-                    const cursor = (0, toMapTree_js_1.cursorFromNodeData)(content, flexNode.context.schema, fieldSchema.allowedTypeSet);
-                    modifyChildren(flexNode, () => {
-                        typedField.content = cursor;
-                    }, () => hydrateProxies(typedField.boxedContent));
-                    break;
-                }
-                default:
-                    (0, index_js_1.fail)("invalid FieldKind");
-            }
-            return true;
-        },
-        has: (target, key) => {
-            return (schema.objectNodeFields.has(key) ||
-                (allowAdditionalProperties ? Reflect.has(target, key) : false));
-        },
-        ownKeys: (target) => {
-            return [
-                ...schema.objectNodeFields.keys(),
-                ...(allowAdditionalProperties ? Reflect.ownKeys(target) : []),
-            ];
-        },
-        getOwnPropertyDescriptor: (target, key) => {
-            const field = (0, flexNode_js_1.getFlexNode)(proxy).tryGetField(key);
-            if (field === undefined) {
-                return allowAdditionalProperties
-                    ? Reflect.getOwnPropertyDescriptor(target, key)
-                    : undefined;
-            }
-            const p = {
-                value: getProxyForField(field),
-                writable: true,
-                enumerable: true,
-                configurable: true, // Must be 'configurable' if property is absent from proxy target.
-            };
-            return p;
+    const proxies = {
+        rootPath: { parent: undefined, parentField: index_js_1.EmptyKey, parentIndex: 0 },
+        proxyPaths: [],
+    };
+    const extractedContent = extractFactoryContent(content, {
+        path: proxies.rootPath,
+        onVisitProxy: (p, proxy) => {
+            proxies.proxyPaths.push({ path: p, proxy });
         },
     });
-    return proxy;
-}
-exports.createObjectProxy = createObjectProxy;
-/**
- * Given a array node proxy, returns its underlying LazySequence field.
- */
-const getSequenceField = (arrayNode) => (0, flexNode_js_1.getFlexNode)(arrayNode).content;
-exports.getSequenceField = getSequenceField;
-// Used by 'insert*()' APIs to converts new content (expressed as a proxy union) to contextually
-// typed data prior to forwarding to 'LazySequence.insert*()'.
-function contextualizeInsertedArrayContent(insertedAtIndex, content) {
-    return extractFactoryContent(content.flatMap((c) => c instanceof treeArrayNode_js_1.IterableTreeArrayContent ? Array.from(c) : [c]), insertedAtIndex);
-}
-// #region Create dispatch map for array nodes
-// TODO: Experiment with alternative dispatch methods to see if we can improve performance.
-/**
- * PropertyDescriptorMap used to build the prototype for our array node dispatch object.
- */
-exports.arrayNodePrototypeProperties = {
-    // We manually add [Symbol.iterator] to the dispatch map rather than use '[fn.name] = fn' as
-    // below when adding 'Array.prototype.*' properties to this map because 'Array.prototype[Symbol.iterator].name'
-    // returns "values" (i.e., Symbol.iterator is an alias for the '.values()' function.)
-    [Symbol.iterator]: {
-        value: Array.prototype[Symbol.iterator],
-    },
-    at: {
-        value(index) {
-            const field = (0, exports.getSequenceField)(this);
-            const val = field.boxedAt(index);
-            if (val === undefined) {
-                return val;
-            }
-            return getOrCreateNodeProxy(val);
-        },
-    },
-    insertAt: {
-        value(index, ...value) {
-            const sequenceField = (0, exports.getSequenceField)(this);
-            const { content, hydrateProxies } = contextualizeInsertedArrayContent(index, value);
-            const cursor = (0, toMapTree_js_1.cursorFromFieldData)(content, sequenceField.context.schema, sequenceField.schema);
-            modifyChildren((0, flexNode_js_1.getFlexNode)(this), () => sequenceField.insertAt(index, cursor), (listFlexNode) => hydrateProxies(listFlexNode));
-        },
-    },
-    insertAtStart: {
-        value(...value) {
-            const sequenceField = (0, exports.getSequenceField)(this);
-            const { content, hydrateProxies } = contextualizeInsertedArrayContent(0, value);
-            const cursor = (0, toMapTree_js_1.cursorFromFieldData)(content, sequenceField.context.schema, sequenceField.schema);
-            modifyChildren((0, flexNode_js_1.getFlexNode)(this), () => sequenceField.insertAtStart(cursor), (listFlexNode) => hydrateProxies(listFlexNode));
-        },
-    },
-    insertAtEnd: {
-        value(...value) {
-            const sequenceField = (0, exports.getSequenceField)(this);
-            const { content, hydrateProxies } = contextualizeInsertedArrayContent(this.length, value);
-            const cursor = (0, toMapTree_js_1.cursorFromFieldData)(content, sequenceField.context.schema, sequenceField.schema);
-            modifyChildren((0, flexNode_js_1.getFlexNode)(this), () => sequenceField.insertAtEnd(cursor), (listFlexNode) => hydrateProxies(listFlexNode));
-        },
-    },
-    removeAt: {
-        value(index) {
-            (0, exports.getSequenceField)(this).removeAt(index);
-        },
-    },
-    removeRange: {
-        value(start, end) {
-            (0, exports.getSequenceField)(this).removeRange(start, end);
-        },
-    },
-    moveToStart: {
-        value(sourceIndex, source) {
-            if (source !== undefined) {
-                (0, exports.getSequenceField)(this).moveToStart(sourceIndex, (0, exports.getSequenceField)(source));
-            }
-            else {
-                (0, exports.getSequenceField)(this).moveToStart(sourceIndex);
-            }
-        },
-    },
-    moveToEnd: {
-        value(sourceIndex, source) {
-            if (source !== undefined) {
-                (0, exports.getSequenceField)(this).moveToEnd(sourceIndex, (0, exports.getSequenceField)(source));
-            }
-            else {
-                (0, exports.getSequenceField)(this).moveToEnd(sourceIndex);
-            }
-        },
-    },
-    moveToIndex: {
-        value(index, sourceIndex, source) {
-            if (source !== undefined) {
-                (0, exports.getSequenceField)(this).moveToIndex(index, sourceIndex, (0, exports.getSequenceField)(source));
-            }
-            else {
-                (0, exports.getSequenceField)(this).moveToIndex(index, sourceIndex);
-            }
-        },
-    },
-    moveRangeToStart: {
-        value(sourceStart, sourceEnd, source) {
-            if (source !== undefined) {
-                (0, exports.getSequenceField)(this).moveRangeToStart(sourceStart, sourceEnd, (0, exports.getSequenceField)(source));
-            }
-            else {
-                (0, exports.getSequenceField)(this).moveRangeToStart(sourceStart, sourceEnd);
-            }
-        },
-    },
-    moveRangeToEnd: {
-        value(sourceStart, sourceEnd, source) {
-            if (source !== undefined) {
-                (0, exports.getSequenceField)(this).moveRangeToEnd(sourceStart, sourceEnd, (0, exports.getSequenceField)(source));
-            }
-            else {
-                (0, exports.getSequenceField)(this).moveRangeToEnd(sourceStart, sourceEnd);
-            }
-        },
-    },
-    moveRangeToIndex: {
-        value(index, sourceStart, sourceEnd, source) {
-            if (source !== undefined) {
-                (0, exports.getSequenceField)(this).moveRangeToIndex(index, sourceStart, sourceEnd, (0, exports.getSequenceField)(source));
-            }
-            else {
-                (0, exports.getSequenceField)(this).moveRangeToIndex(index, sourceStart, sourceEnd);
-            }
-        },
-    },
-};
-/* eslint-disable @typescript-eslint/unbound-method */
-// 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
-// to avoid re-entering the proxy as these methods access 'length' and the indexed properties.
-//
-// For brevity, the current implementation dynamically builds a property descriptor map from a list of
-// Array functions we want to re-expose via the proxy.
-// TODO: This assumes 'Function.name' matches the property name on 'Array.prototype', which may be
-// dubious across JS engines.
-[
-    Array.prototype.concat,
-    // Array.prototype.copyWithin,
-    Array.prototype.entries,
-    Array.prototype.every,
-    // Array.prototype.fill,
-    Array.prototype.filter,
-    Array.prototype.find,
-    Array.prototype.findIndex,
-    Array.prototype.flat,
-    Array.prototype.flatMap,
-    Array.prototype.forEach,
-    Array.prototype.includes,
-    Array.prototype.indexOf,
-    Array.prototype.join,
-    Array.prototype.keys,
-    Array.prototype.lastIndexOf,
-    // Array.prototype.length,
-    Array.prototype.map,
-    // Array.prototype.pop,
-    // Array.prototype.push,
-    Array.prototype.reduce,
-    Array.prototype.reduceRight,
-    // Array.prototype.reverse,
-    // Array.prototype.shift,
-    Array.prototype.slice,
-    Array.prototype.some,
-    // Array.prototype.sort,
-    // Array.prototype.splice,
-    Array.prototype.toLocaleString,
-    Array.prototype.toString,
-    // Array.prototype.unshift,
-    Array.prototype.values,
-].forEach((fn) => {
-    exports.arrayNodePrototypeProperties[fn.name] = { value: fn };
-});
-/* eslint-enable @typescript-eslint/unbound-method */
-const arrayNodePrototype = Object.create(Object.prototype, exports.arrayNodePrototypeProperties);
-// #endregion
-/**
- * Helper to coerce property keys to integer indexes (or undefined if not an in-range integer).
- */
-function asIndex(key, length) {
-    if (typeof key === "string") {
-        // TODO: It may be worth a '0' <= ch <= '9' check before calling 'Number' to quickly
-        // reject 'length' as an index, or even parsing integers ourselves.
-        const asNumber = Number(key);
-        // TODO: See 'matrix/range.ts' for fast integer coercing + range check.
-        if (Number.isInteger(asNumber)) {
-            return 0 <= asNumber && asNumber < length ? asNumber : undefined;
-        }
-    }
+    bindProxies([proxies], forest);
+    return extractedContent;
 }
-/**
- * @param allowAdditionalProperties - If true, setting of unexpected properties will be forwarded to the target object.
- * Otherwise setting of unexpected properties will error.
- * @param customTargetObject - Target object of the proxy.
- * If not provided `[]` is used for the target and a separate object created to dispatch array methods.
- * If provided, the customTargetObject will be used as both the dispatch object and the proxy target, and therefor must provide `length` and the array functionality from {@link arrayNodePrototype}.
- */
-function createArrayNodeProxy(allowAdditionalProperties, customTargetObject) {
-    const targetObject = customTargetObject ?? [];
-    // Create a 'dispatch' object that this Proxy forwards to instead of the proxy target, because we need
-    // the proxy target to be a plain JS array (see comments below when we instantiate the Proxy).
-    // Own properties on the dispatch object are surfaced as own properties of the proxy.
-    // (e.g., 'length', which is defined below).
-    //
-    // Properties normally inherited from 'Array.prototype' are surfaced via the prototype chain.
-    const dispatch = customTargetObject ??
-        Object.create(arrayNodePrototype, {
-            length: {
-                get() {
-                    return (0, exports.getSequenceField)(this).length;
-                },
-                set() { },
-                enumerable: false,
-                configurable: false,
+exports.prepareContentForInsert = prepareContentForInsert;
+function prepareArrayContentForInsert(content, forest) {
+    const proxies = [];
+    const extractedContent = [];
+    for (let i = 0; i < content.length; i++) {
+        proxies.push({
+            rootPath: {
+                parent: undefined,
+                parentField: index_js_1.EmptyKey,
+                parentIndex: 0,
             },
+            proxyPaths: [],
         });
-    // To satisfy 'deepEquals' level scrutiny, the target of the proxy must be an array literal in order
-    // to pass 'Object.getPrototypeOf'.  It also satisfies 'Array.isArray' and 'Object.prototype.toString'
-    // requirements without use of Array[Symbol.species], which is potentially on a path ot deprecation.
-    const proxy = new Proxy(targetObject, {
-        get: (target, key) => {
-            const field = (0, exports.getSequenceField)(proxy);
-            const maybeIndex = asIndex(key, field.length);
-            if (maybeIndex === undefined) {
-                // Pass the proxy as the receiver here, so that any methods on
-                // the prototype receive `proxy` as `this`.
-                return Reflect.get(dispatch, key, proxy);
-            }
-            const value = field.boxedAt(maybeIndex);
-            if (value === undefined) {
-                return undefined;
-            }
-            // TODO: Ideally, we would return leaves without first boxing them.  However, this is not
-            //       as simple as calling '.content' since this skips the node and returns the FieldNode's
-            //       inner field.
-            return getOrCreateNodeProxy(value);
-        },
-        set: (target, key, newValue, receiver) => {
-            // 'Symbol.isConcatSpreadable' may be set on an Array instance to modify the behavior of
-            // the concat method.  We allow this property to be added to the dispatch object.
-            if (key === Symbol.isConcatSpreadable) {
-                return Reflect.set(dispatch, key, newValue, proxy);
-            }
-            const field = (0, exports.getSequenceField)(proxy);
-            const maybeIndex = asIndex(key, field.length);
-            if (maybeIndex !== undefined) {
-                // For MVP, we otherwise disallow setting properties (mutation is only available via the array node mutation APIs).
-                return false;
-            }
-            return allowAdditionalProperties ? Reflect.set(target, key, newValue) : false;
-        },
-        has: (target, key) => {
-            const field = (0, exports.getSequenceField)(proxy);
-            const maybeIndex = asIndex(key, field.length);
-            return maybeIndex !== undefined || Reflect.has(dispatch, key);
-        },
-        ownKeys: (target) => {
-            const field = (0, exports.getSequenceField)(proxy);
-            // TODO: Would a lazy iterator to produce the indexes work / be more efficient?
-            // TODO: Need to surface 'Symbol.isConcatSpreadable' as an own key.
-            return Array.from({ length: field.length }, (_, index) => `${index}`).concat("length");
-        },
-        getOwnPropertyDescriptor: (target, key) => {
-            const field = (0, exports.getSequenceField)(proxy);
-            const maybeIndex = asIndex(key, field.length);
-            if (maybeIndex !== undefined) {
-                const val = field.boxedAt(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 : getOrCreateNodeProxy(val),
-                    writable: true,
-                    enumerable: true,
-                    configurable: true,
-                };
-            }
-            else if (key === "length") {
-                // To satisfy 'deepEquals' level scrutiny, the property descriptor for 'length' must be a simple
-                // value property (as opposed to using getter) and be declared writable / non-configurable.
-                return {
-                    value: (0, exports.getSequenceField)(proxy).length,
-                    writable: true,
-                    enumerable: false,
-                    configurable: false,
-                };
-            }
-            return Reflect.getOwnPropertyDescriptor(dispatch, key);
-        },
-    });
-    return proxy;
+        extractedContent.push(extractFactoryContent(content[i], {
+            path: proxies[i].rootPath,
+            onVisitProxy: (p, proxy) => {
+                proxies[i].proxyPaths.push({ path: p, proxy });
+            },
+        }));
+    }
+    bindProxies(proxies, forest);
+    return extractedContent;
 }
-// #region Create dispatch map for maps
-exports.mapStaticDispatchMap = {
-    [Symbol.iterator]: {
-        value() {
-            return this.entries();
-        },
-    },
-    delete: {
-        value(key) {
-            const node = (0, flexNode_js_1.getFlexNode)(this);
-            node.delete(key);
-        },
-    },
-    entries: {
-        *value() {
-            const node = (0, flexNode_js_1.getFlexNode)(this);
-            for (const key of node.keys()) {
-                yield [key, getProxyForField(node.getBoxed(key))];
+function bindProxies(proxies, forest) {
+    // Only subscribe to the event if there is at least one proxy tree to hydrate - this is not the case when inserting an empty array [].
+    if (proxies.length > 0) {
+        // Creating a new array emits one event per element in the array, so listen to the event once for each element
+        let i = 0;
+        const off = forest.on("afterRootFieldCreated", (fieldKey) => {
+            proxies[i].rootPath.parentField = fieldKey;
+            for (const { path, proxy } of proxies[i].proxyPaths) {
+                (0, proxyBinding_js_1.anchorProxy)(forest.anchors, path, proxy);
             }
-        },
-    },
-    get: {
-        value(key) {
-            const node = (0, flexNode_js_1.getFlexNode)(this);
-            const field = node.getBoxed(key);
-            return getProxyForField(field);
-        },
-    },
-    has: {
-        value(key) {
-            const node = (0, flexNode_js_1.getFlexNode)(this);
-            return node.has(key);
-        },
-    },
-    keys: {
-        value() {
-            const node = (0, flexNode_js_1.getFlexNode)(this);
-            return node.keys();
-        },
-    },
-    set: {
-        value(key, value) {
-            const node = (0, flexNode_js_1.getFlexNode)(this);
-            const { content, hydrateProxies } = extractFactoryContent(value);
-            const cursor = (0, toMapTree_js_1.cursorFromNodeData)(content, node.context.schema, node.schema.mapFields.allowedTypeSet);
-            modifyChildren(node, (mapNode) => mapNode.set(key, cursor), (mapNode) => hydrateProxies(getMapChildNode(mapNode, key)));
-            return this;
-        },
-    },
-    size: {
-        get() {
-            return (0, flexNode_js_1.getFlexNode)(this).size;
-        },
-    },
-    values: {
-        *value() {
-            for (const [, value] of this.entries()) {
-                yield value;
+            if (++i === proxies.length) {
+                off();
             }
-        },
-    },
-    // TODO: add `clear` once we have established merge semantics for it.
-};
-const mapPrototype = Object.create(Object.prototype, exports.mapStaticDispatchMap);
-// #endregion
-/**
- * @param allowAdditionalProperties - If true, setting of unexpected properties will be forwarded to the target object.
- * Otherwise setting of unexpected properties will error.
- * @param customTargetObject - Target object of the proxy.
- * If not provided `new Map()` is used for the target and a separate object created to dispatch map methods.
- * If provided, the customTargetObject will be used as both the dispatch object and the proxy target, and therefor must provide the map functionality from {@link mapPrototype}.
- */
-function createMapProxy(allowAdditionalProperties, customTargetObject) {
-    // Create a 'dispatch' object that this Proxy forwards to instead of the proxy target.
-    const dispatch = customTargetObject ??
-        Object.create(mapPrototype, {
-        // Empty - JavaScript Maps do not expose any "own" properties.
         });
-    const targetObject = customTargetObject ?? new Map();
-    // TODO: Although the target is an object literal, it's still worthwhile to try experimenting with
-    // a dispatch object to see if it improves performance.
-    const proxy = new Proxy(targetObject, {
-        get: (target, key, receiver) => {
-            // Pass the proxy as the receiver here, so that any methods on the prototype receive `proxy` as `this`.
-            return Reflect.get(dispatch, key, proxy);
-        },
-        getOwnPropertyDescriptor: (target, key) => {
-            return Reflect.getOwnPropertyDescriptor(dispatch, key);
-        },
-        has: (target, key) => {
-            return Reflect.has(dispatch, key);
-        },
-        set: (target, key, newValue) => {
-            return allowAdditionalProperties ? Reflect.set(dispatch, key, newValue) : false;
-        },
-        ownKeys: (target) => {
-            // All of Map's properties are inherited via its prototype, so there is nothing to return here,
-            return [];
-        },
-    });
-    return proxy;
-}
-/**
- * Create a proxy to a {@link TreeObjectNode} that is backed by a raw object node (see {@link createRawNode}).
- * @param schema - the schema of the object node
- * @param content - the content to be stored in the raw node.
- * A copy of content is stored, the input `content` is not modified and can be safely reused in another call to {@link createRawObjectProxy}.
- * @param allowAdditionalProperties - If true, setting of unexpected properties will be forwarded to the target object.
- * Otherwise setting of unexpected properties will error.
- * @param customTargetObject - Target object of the proxy.
- * If not provided `{}` is used for the target.
- * @remarks
- * Because this proxy is backed by a raw node, it has the same limitations as the node created by {@link createRawNode}.
- * Most of its properties and methods will error if read/called.
- */
-function createRawNodeProxy(schema, content, allowAdditionalProperties, target) {
-    // Shallow copy the content and then add the type name symbol to it.
-    let flexNode;
-    let proxy;
-    if (schema instanceof index_js_2.FlexObjectNodeSchema) {
-        const contentCopy = copyContent(schema.name, content);
-        flexNode = (0, rawNode_js_1.createRawNode)(schema, contentCopy);
-        proxy = createObjectProxy(schema, allowAdditionalProperties, target);
-    }
-    else if (schema instanceof index_js_2.FlexFieldNodeSchema) {
-        // simple-tree uses field nodes exclusively to represent array nodes
-        const contentCopy = copyContent(schema.name, content);
-        flexNode = (0, rawNode_js_1.createRawNode)(schema, contentCopy);
-        proxy = createArrayNodeProxy(allowAdditionalProperties, target);
     }
-    else if (schema instanceof index_js_2.FlexMapNodeSchema) {
-        const contentCopy = copyContent(schema.name, content);
-        flexNode = (0, rawNode_js_1.createRawNode)(schema, contentCopy);
-        proxy = createMapProxy(allowAdditionalProperties, target);
-    }
-    else {
-        (0, index_js_1.fail)("Unrecognized content schema");
-    }
-    return (0, flexNode_js_1.setFlexNode)(proxy, flexNode);
-}
-exports.createRawNodeProxy = createRawNodeProxy;
-function copyContent(typeName, content) {
-    const copy = content instanceof Map
-        ? new Map(content)
-        : Array.isArray(content)
-            ? content.slice()
-            : { ...content };
-    return Object.defineProperty(copy, index_js_2.typeNameSymbol, { value: typeName });
 }
-const noopHydrator = () => { };
 /**
  * Given a content tree that is to be inserted into the shared tree, replace all subtrees that were created by factories
  * (via {@link SharedTreeObjectFactory.create}) with the content that was passed to those factories.
  * @param content - the content being inserted which may be, and/or may contain, factory-created content
+ * @param onVisitProxy - an optional callback that will run for each proxy (i.e. object created by a factory) found in the inserted content
  * @param insertedAtIndex - if the content being inserted is array node content, this must be the index in the array node at which the content is being inserted
  * @returns the result of the content replacement and a {@link ExtractedFactoryContent.hydrateProxies} function which must be invoked if present.
  * @remarks
@@ -685,161 +178,117 @@ const noopHydrator = () => { };
  * }
  * ```
  */
-function extractFactoryContent(input, insertedAtIndex = 0) {
+function extractFactoryContent(input, visitProxies) {
     let content;
-    let fromFactory = false;
-    const rawFlexNode = (0, flexNode_js_1.tryGetFlexNode)(input);
+    const rawFlexNode = (0, proxyBinding_js_1.tryGetFlexNode)(input);
     if (rawFlexNode !== undefined) {
         const factoryContent = (0, rawNode_js_1.extractRawNodeContent)(rawFlexNode);
         if (factoryContent === undefined) {
             // We were passed a proxy, but that proxy doesn't have any raw content.
             throw new Error("Cannot insert a node that is already in the tree");
         }
+        visitProxies?.onVisitProxy(visitProxies.path, input);
         content = factoryContent;
-        fromFactory = true;
     }
     else {
         content = input;
     }
-    (0, core_utils_1.assert)(!isTreeNode(content), 0x844 /* Unhydrated insertion content should have FlexNode */);
+    (0, internal_1.assert)(!isTreeNode(content), 0x844 /* Unhydrated insertion content should have FlexNode */);
     let type;
     let extractedContent;
-    if ((0, index_js_1.isReadonlyArray)(content)) {
+    if ((0, index_js_3.isReadonlyArray)(content)) {
         type = schemaTypes_js_1.NodeKind.Array;
-        extractedContent = extractContentArray(content, insertedAtIndex);
+        extractedContent = extractContentArray(content, visitProxies);
     }
     else if (content instanceof Map) {
         type = schemaTypes_js_1.NodeKind.Map;
-        extractedContent = extractContentMap(content);
+        extractedContent = extractContentMap(content, visitProxies);
     }
     else if (typeof content === "object" && content !== null && !(0, index_js_2.isFluidHandle)(content)) {
         type = schemaTypes_js_1.NodeKind.Object;
-        extractedContent = extractContentObject(content);
+        extractedContent = extractContentObject(content, visitProxies);
     }
     else {
-        extractedContent = { content, hydrateProxies: noopHydrator };
+        extractedContent = content;
         type = schemaTypes_js_1.NodeKind.Leaf;
     }
-    if (isTreeNode(input)) {
-        const kindFromSchema = getNodeKind(input);
-        (0, core_utils_1.assert)(kindFromSchema === type, 0x845 /* kind of data should match kind of schema */);
-    }
-    if (fromFactory) {
-        return {
-            content: extractedContent.content,
-            hydrateProxies: (flexNode) => {
-                // This makes the input proxy usable and updates the proxy cache
-                (0, flexNode_js_1.setFlexNode)(input, flexNode ?? (0, index_js_1.fail)("Expected edit node"));
-                extractedContent.hydrateProxies(flexNode);
-            },
-        };
+    if (rawFlexNode !== undefined) {
+        const kindFromSchema = (0, schemaCaching_js_1.tryGetSimpleNodeSchema)(rawFlexNode.schema)?.kind ??
+            (0, index_js_3.fail)("NodeBase should always have class schema");
+        (0, internal_1.assert)(kindFromSchema === type, 0x845 /* kind of data should match kind of schema */);
     }
     return extractedContent;
 }
 exports.extractFactoryContent = extractFactoryContent;
-/**
- * @param insertedAtIndex - Supply this if the extracted array content will be inserted into an existing array node in the tree.
- */
-function extractContentArray(input, insertedAtIndex) {
+function extractContentArray(input, visitProxies) {
     const output = [];
     if (index_js_2.typeNameSymbol in input) {
         Object.defineProperty(output, index_js_2.typeNameSymbol, { value: input[index_js_2.typeNameSymbol] });
     }
-    const hydrators = [];
     for (let i = 0; i < input.length; i++) {
-        const { content: childContent, hydrateProxies } = extractFactoryContent(input[i]);
+        const childContent = extractFactoryContent(input[i], visitProxies !== undefined
+            ? {
+                path: {
+                    parent: visitProxies.path,
+                    parentField: index_js_1.EmptyKey,
+                    parentIndex: i,
+                },
+                onVisitProxy: visitProxies?.onVisitProxy,
+            }
+            : undefined);
         output.push(childContent);
-        // The conditional here is an optimization so that primitive items don't incur boxed reads for hydration
-        if (hydrateProxies !== noopHydrator) {
-            hydrators.push([i, hydrateProxies]);
-        }
     }
-    return {
-        content: output,
-        hydrateProxies: (flexNode) => {
-            (0, core_utils_1.assert)(flexNode !== undefined, 0x7f6 /* Expected edit node to be defined when hydrating array node */);
-            (0, core_utils_1.assert)((0, index_js_2.schemaIsFieldNode)(flexNode.schema), 0x7f7 /* Expected field node when hydrating array node */);
-            hydrators.forEach(([i, hydrate]) => hydrate(getArrayNodeChildNode(flexNode, insertedAtIndex + i)));
-        },
-    };
+    return output;
 }
-function extractContentMap(input) {
+function extractContentMap(input, visitProxies) {
     const output = new Map();
     if (index_js_2.typeNameSymbol in input) {
         Object.defineProperty(output, index_js_2.typeNameSymbol, { value: input[index_js_2.typeNameSymbol] });
     }
-    const hydrators = [];
     for (const [key, value] of input) {
-        const { content: childContent, hydrateProxies } = extractFactoryContent(value);
+        const childContent = extractFactoryContent(value, visitProxies !== undefined
+            ? {
+                path: {
+                    parent: visitProxies.path,
+                    parentField: (0, index_js_3.brand)(key),
+                    parentIndex: 0,
+                },
+                onVisitProxy: visitProxies?.onVisitProxy,
+            }
+            : undefined);
         output.set(key, childContent);
-        // The conditional here is an optimization so that primitive values don't incur boxed reads for hydration
-        if (hydrateProxies !== noopHydrator) {
-            hydrators.push([key, hydrateProxies]);
-        }
     }
-    return {
-        content: output,
-        hydrateProxies: (flexNode) => {
-            (0, core_utils_1.assert)(flexNode !== undefined, 0x7f8 /* Expected edit node to be defined when hydrating map */);
-            (0, core_utils_1.assert)((0, index_js_2.schemaIsMap)(flexNode.schema), 0x7f9 /* Expected map node when hydrating map */);
-            hydrators.forEach(([key, hydrate]) => hydrate(getMapChildNode(flexNode, key)));
-        },
-    };
+    return output;
 }
-function extractContentObject(input) {
+function extractContentObject(input, visitProxies) {
     const output = {};
     if (index_js_2.typeNameSymbol in input) {
         Object.defineProperty(output, index_js_2.typeNameSymbol, { value: input[index_js_2.typeNameSymbol] });
     }
-    const hydrators = [];
     for (const [key, value] of Object.entries(input)) {
         // Treat undefined fields and missing fields the same.
         // Generally tree does not require explicit undefined values at runtime despite some of the schema aware type checking currently requiring it.
         if (value !== undefined) {
-            const { content: childContent, hydrateProxies } = extractFactoryContent(value);
+            const childContent = extractFactoryContent(value, visitProxies !== undefined
+                ? {
+                    path: {
+                        parent: visitProxies.path,
+                        parentField: (0, index_js_3.brand)(key),
+                        parentIndex: 0,
+                    },
+                    onVisitProxy: visitProxies?.onVisitProxy,
+                }
+                : undefined);
             output[key] = childContent;
-            hydrators.push([key, hydrateProxies]);
         }
     }
-    return {
-        content: output,
-        hydrateProxies: (flexNode) => {
-            (0, core_utils_1.assert)(flexNode !== undefined, 0x7fa /* Expected edit node to be defined when hydrating object */);
-            (0, core_utils_1.assert)((0, index_js_2.schemaIsObjectNode)(flexNode.schema), 0x7fb /* Expected object node when hydrating object content */);
-            hydrators.forEach(([key, hydrate]) => hydrate(getObjectChildNode(flexNode, key)));
-        },
-    };
-}
-function getArrayNodeChildNode(arrayNode, index) {
-    const field = arrayNode.tryGetField(index_js_3.EmptyKey);
-    (0, core_utils_1.assert)(field?.schema.kind === index_js_2.FieldKinds.sequence, 0x7fc /* Expected sequence field when hydrating array node */);
-    return field.boxedAt(index);
-}
-function getMapChildNode(mapNode, key) {
-    const field = mapNode.getBoxed(key);
-    (0, core_utils_1.assert)(field.schema.kind === index_js_2.FieldKinds.optional, 0x7fd /* Sequence field kind is unsupported as map values */);
-    return field.boxedContent;
-}
-function getObjectChildNode(objectNode, key) {
-    const field = objectNode.tryGetField((0, index_js_1.brand)(key)) ?? (0, index_js_1.fail)("Expected a field for inserted content");
-    (0, core_utils_1.assert)(field.schema.kind === index_js_2.FieldKinds.required || field.schema.kind === index_js_2.FieldKinds.optional, 0x7fe /* Expected required or optional field kind */);
-    return field.boxedContent;
+    return output;
 }
 /**
- * Run the given function `modify`.
- * If the function results in any changes to the direct children of `parent`, `after` will be run immediately thereafter.
+ * Brand `copy` with the type (under {@link typeNameSymbol}) to avoid ambiguity when inferring types from this data.
  */
-function modifyChildren(parent, modify, after) {
-    const offNextChange = parent[index_js_2.onNextChange](() => after?.(parent));
-    modify(parent);
-    // `onNextChange` unsubscribes itself after firing once. However, there is no guarantee that it will fire.
-    // For example, the `modify` function may result in a no-op that doesn't trigger an edit (e.g. inserting `[]` into an array node).
-    // In those cases, we must unsubscribe manually here. If `modify` was not a no-op, it does no harm to call this function anyway.
-    offNextChange();
-}
-// TODO: Replace this with calls to `Tree.schema(node).kind` when dependency cycles are no longer a problem.
-function getNodeKind(node) {
-    return (getClassSchema((0, flexNode_js_1.getFlexNode)(node).schema)?.kind ??
-        (0, index_js_1.fail)("NodeBase should always have class schema"));
+function markContentType(typeName, copy) {
+    Object.defineProperty(copy, index_js_2.typeNameSymbol, { value: typeName });
 }
+exports.markContentType = markContentType;
 //# sourceMappingURL=proxies.js.map