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

package/dist/core/tree/anchorSet.js

@@ -5,7 +5,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AnchorSet = exports.anchorSlot = void 0;
-const core_utils_1 = require("@fluidframework/core-utils");
+const internal_1 = require("@fluidframework/core-utils/internal");
 const index_js_1 = require("../../events/index.js");
 const index_js_2 = require("../../util/index.js");
 const types_js_1 = require("./types.js");
@@ -103,13 +103,13 @@ class AnchorSet {
             return undefined;
         }
         const path = this.anchorToPath.get(anchor);
-        (0, core_utils_1.assert)(path !== undefined, 0x3a6 /* Cannot locate anchor which is not in this AnchorSet */);
+        (0, internal_1.assert)(path !== undefined, 0x3a6 /* Cannot locate anchor which is not in this AnchorSet */);
         return path.status === Status.Alive ? path : undefined;
     }
     forget(anchor) {
         if (anchor !== NeverAnchor) {
             const path = this.anchorToPath.get(anchor);
-            (0, core_utils_1.assert)(path !== undefined, 0x351 /* cannot forget unknown Anchor */);
+            (0, internal_1.assert)(path !== undefined, 0x351 /* cannot forget unknown Anchor */);
             path.removeRef();
             this.anchorToPath.delete(anchor);
         }
@@ -214,7 +214,7 @@ class AnchorSet {
         while (stack.length > 0) {
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             const node = stack.pop();
-            (0, core_utils_1.assert)(node.status === Status.Alive, 0x408 /* PathNode must be alive */);
+            (0, internal_1.assert)(node.status === Status.Alive, 0x408 /* PathNode must be alive */);
             node.status = Status.Dangling;
             node.events.emit("afterDestroy", node);
             for (const children of node.children.values()) {
@@ -233,7 +233,7 @@ class AnchorSet {
      * TODO: tests
      */
     decoupleNodes(startPath, count) {
-        (0, core_utils_1.assert)(count > 0, 0x681 /* count must be positive */);
+        (0, internal_1.assert)(count > 0, 0x681 /* count must be positive */);
         const sourceParent = this.find(startPath.parent ?? this.root);
         const sourceChildren = sourceParent?.children?.get(startPath.parentField);
         let nodes = [];
@@ -274,7 +274,7 @@ class AnchorSet {
      * TODO: tests
      */
     coupleNodes(destination, count, coupleInfo) {
-        (0, core_utils_1.assert)(coupleInfo.nodes.length > 0, 0x682 /* coupleInfo must have nodes to couple */);
+        (0, internal_1.assert)(coupleInfo.nodes.length > 0, 0x682 /* coupleInfo must have nodes to couple */);
         // The destination needs to be created if it does not exist yet.
         const destinationPath = this.trackInner(destination.parent ?? this.root);
         // Update nodes for new parent.
@@ -379,7 +379,8 @@ class AnchorSet {
      * and this method will throw an error if this is attempted.
      */
     acquireVisitor() {
-        (0, core_utils_1.assert)(this.activeVisitor === undefined, 0x767 /* Must release existing visitor before acquiring another */);
+        (0, internal_1.assert)(this.activeVisitor === undefined, 0x767 /* Must release existing visitor before acquiring another */);
+        const referencedPathNodes = [];
         const visitor = {
             anchorSet: this,
             // Run `withNode` on anchorNode for parent if there is such an anchorNode.
@@ -389,30 +390,18 @@ class AnchorSet {
                     withRoot();
                 }
                 else {
-                    (0, core_utils_1.assert)(this.parent !== undefined, 0x5b0 /* parent must exist */);
+                    (0, internal_1.assert)(this.parent !== undefined, 0x5b0 /* parent must exist */);
                     // TODO:Perf:
                     // When traversing to a depth D when there are not anchors in that subtree, this goes O(D^2).
                     // Delta traversal should early out in this case because no work is needed (and all move outs are known to not contain anchors).
                     this.parent = this.anchorSet.internalizePath(this.parent);
                     if (this.parent instanceof PathNode) {
+                        this.parent.addRef();
+                        referencedPathNodes.push(this.parent);
                         withNode(this.parent);
                     }
                 }
             },
-            // Run `withNode` on every node from the current `this.parent` to the root.
-            // Should only be called when in a field.
-            withParentNodeUpToRoot(withNode) {
-                (0, core_utils_1.assert)(this.parentField !== undefined, 0x7cd /* Must be in a field to call withNodeUpToRoot */);
-                // This function gets called when we attach a node to the root field, in which case there is no parent.
-                // It's expected this will do nothing in that case.
-                let currentParent = this.parent;
-                while (currentParent !== undefined) {
-                    if (currentParent instanceof PathNode) {
-                        withNode(currentParent);
-                    }
-                    currentParent = currentParent.parent;
-                }
-            },
             // Lookup table for path visitors collected from {@link AnchorEvents.visitSubtreeChanging} emitted events.
             // The key is the path of the node that the visitor is registered on. The code ensures that the path visitor visits only the appropriate subtrees
             // by maintaining the mapping only during time between the {@link DeltaVisitor.enterNode} and {@link DeltaVisitor.exitNode} calls for a given anchorNode.
@@ -420,7 +409,10 @@ class AnchorSet {
             parentField: undefined,
             parent: undefined,
             free() {
-                (0, core_utils_1.assert)(this.anchorSet.activeVisitor !== undefined, 0x768 /* Multiple free calls for same visitor */);
+                (0, internal_1.assert)(this.anchorSet.activeVisitor !== undefined, 0x768 /* Multiple free calls for same visitor */);
+                for (const node of referencedPathNodes) {
+                    node.removeRef();
+                }
                 this.anchorSet.activeVisitor = undefined;
             },
             notifyChildrenChanging() {
@@ -430,7 +422,7 @@ class AnchorSet {
                 this.maybeWithNode((p) => p.events.emit("childrenChanged", p), () => { });
             },
             beforeAttach(source, count, destination) {
-                (0, core_utils_1.assert)(this.parentField !== undefined, 0x7a0 /* Must be in a field in order to attach */);
+                (0, internal_1.assert)(this.parentField !== undefined, 0x7a0 /* Must be in a field in order to attach */);
                 const destinationPath = {
                     parent: this.parent,
                     field: this.parentField,
@@ -441,9 +433,6 @@ class AnchorSet {
                     start: 0,
                     end: count,
                 });
-                this.withParentNodeUpToRoot((p) => {
-                    p.events.emit("beforeChange", p);
-                });
                 for (const visitors of this.pathVisitors.values()) {
                     for (const pathVisitor of visitors) {
                         pathVisitor.beforeAttach(sourcePath, destinationPath);
@@ -451,7 +440,7 @@ class AnchorSet {
                 }
             },
             afterAttach(source, destination) {
-                (0, core_utils_1.assert)(this.parentField !== undefined, 0x7a1 /* Must be in a field in order to attach */);
+                (0, internal_1.assert)(this.parentField !== undefined, 0x7a1 /* Must be in a field in order to attach */);
                 const sourcePath = (0, index_js_2.brand)({
                     field: source,
                     index: 0,
@@ -461,9 +450,6 @@ class AnchorSet {
                     field: this.parentField,
                     ...destination,
                 };
-                this.withParentNodeUpToRoot((p) => {
-                    p.events.emit("afterChange", p);
-                });
                 for (const visitors of this.pathVisitors.values()) {
                     for (const pathVisitor of visitors) {
                         pathVisitor.afterAttach(sourcePath, destinationPath);
@@ -476,7 +462,7 @@ class AnchorSet {
                 this.notifyChildrenChanged();
             },
             attachEdit(source, count, destination) {
-                (0, core_utils_1.assert)(this.parentField !== undefined, 0x7a2 /* Must be in a field in order to attach */);
+                (0, internal_1.assert)(this.parentField !== undefined, 0x7a2 /* Must be in a field in order to attach */);
                 const sourcePath = {
                     parent: this.anchorSet.root,
                     parentField: source,
@@ -490,7 +476,7 @@ class AnchorSet {
                 this.anchorSet.moveChildren(sourcePath, destinationPath, count);
             },
             beforeDetach(source, destination) {
-                (0, core_utils_1.assert)(this.parentField !== undefined, 0x7a3 /* Must be in a field in order to attach */);
+                (0, internal_1.assert)(this.parentField !== undefined, 0x7a3 /* Must be in a field in order to attach */);
                 const sourcePath = {
                     parent: this.parent,
                     field: this.parentField,
@@ -500,9 +486,6 @@ class AnchorSet {
                     field: destination,
                     index: 0,
                 });
-                this.withParentNodeUpToRoot((p) => {
-                    p.events.emit("beforeChange", p);
-                });
                 for (const visitors of this.pathVisitors.values()) {
                     for (const pathVisitor of visitors) {
                         pathVisitor.beforeDetach(sourcePath, destinationPath);
@@ -510,7 +493,7 @@ class AnchorSet {
                 }
             },
             afterDetach(source, count, destination) {
-                (0, core_utils_1.assert)(this.parentField !== undefined, 0x7a4 /* Must be in a field in order to attach */);
+                (0, internal_1.assert)(this.parentField !== undefined, 0x7a4 /* Must be in a field in order to attach */);
                 const sourcePath = {
                     parent: this.parent,
                     field: this.parentField,
@@ -521,9 +504,6 @@ class AnchorSet {
                     start: 0,
                     end: count,
                 });
-                this.withParentNodeUpToRoot((p) => {
-                    p.events.emit("afterChange", p);
-                });
                 for (const visitors of this.pathVisitors.values()) {
                     for (const pathVisitor of visitors) {
                         pathVisitor.afterDetach(sourcePath, destinationPath);
@@ -536,7 +516,7 @@ class AnchorSet {
                 this.notifyChildrenChanged();
             },
             detachEdit(source, destination) {
-                (0, core_utils_1.assert)(this.parentField !== undefined, 0x7a5 /* Must be in a field in order to detach */);
+                (0, internal_1.assert)(this.parentField !== undefined, 0x7a5 /* Must be in a field in order to detach */);
                 const sourcePath = {
                     parent: this.parent,
                     parentField: this.parentField,
@@ -550,7 +530,7 @@ class AnchorSet {
                 this.anchorSet.moveChildren(sourcePath, destinationPath, source.end - source.start);
             },
             beforeReplace(newContent, oldContent, destination) {
-                (0, core_utils_1.assert)(this.parentField !== undefined, 0x7a6 /* Must be in a field in order to replace */);
+                (0, internal_1.assert)(this.parentField !== undefined, 0x7a6 /* Must be in a field in order to replace */);
                 const oldContentPath = {
                     parent: this.parent,
                     field: this.parentField,
@@ -565,9 +545,6 @@ class AnchorSet {
                     field: destination,
                     index: 0,
                 });
-                this.withParentNodeUpToRoot((p) => {
-                    p.events.emit("beforeChange", p);
-                });
                 for (const visitors of this.pathVisitors.values()) {
                     for (const pathVisitor of visitors) {
                         pathVisitor.beforeReplace(newNodesSourcePath, oldContentPath, oldNodesDestinationPath);
@@ -575,7 +552,7 @@ class AnchorSet {
                 }
             },
             afterReplace(newContentSource, newContent, oldContent) {
-                (0, core_utils_1.assert)(this.parentField !== undefined, 0x7a7 /* Must be in a field in order to replace */);
+                (0, internal_1.assert)(this.parentField !== undefined, 0x7a7 /* Must be in a field in order to replace */);
                 const newContentPath = {
                     parent: this.parent,
                     field: this.parentField,
@@ -590,9 +567,6 @@ class AnchorSet {
                     start: 0,
                     end: newContent.end - newContent.start,
                 });
-                this.withParentNodeUpToRoot((p) => {
-                    p.events.emit("afterChange", p);
-                });
                 for (const visitors of this.pathVisitors.values()) {
                     for (const pathVisitor of visitors) {
                         pathVisitor.afterReplace(newNodesSourcePath, newContentPath, oldNodesDestinationPath);
@@ -641,7 +615,7 @@ class AnchorSet {
                 }
             },
             enterNode(index) {
-                (0, core_utils_1.assert)(this.parentField !== undefined, 0x3ab /* Must be in a field to enter node */);
+                (0, internal_1.assert)(this.parentField !== undefined, 0x3ab /* Must be in a field to enter node */);
                 this.parent = {
                     parent: this.parent,
                     parentField: this.parentField,
@@ -659,8 +633,9 @@ class AnchorSet {
                 });
             },
             exitNode(index) {
-                (0, core_utils_1.assert)(this.parent !== undefined, 0x3ac /* Must have parent node */);
+                (0, internal_1.assert)(this.parent !== undefined, 0x3ac /* Must have parent node */);
                 this.maybeWithNode((p) => {
+                    p.events.emit("subtreeChanged", p);
                     // Remove subtree path visitors added at this node if there are any
                     this.pathVisitors.delete(p);
                 });
@@ -802,8 +777,8 @@ class PathNode extends index_js_2.ReferenceCountedBase {
         return this.parentPath === undefined;
     }
     get parent() {
-        (0, core_utils_1.assert)(this.status !== Status.Disposed, 0x409 /* PathNode must not be disposed */);
-        (0, core_utils_1.assert)(this.parentPath !== undefined, 0x355 /* PathNode.parent is an UpPath API and thus should never be called on the root PathNode. */);
+        (0, internal_1.assert)(this.status !== Status.Disposed, 0x409 /* PathNode must not be disposed */);
+        (0, internal_1.assert)(this.parentPath !== undefined, 0x355 /* PathNode.parent is an UpPath API and thus should never be called on the root PathNode. */);
         // Root PathNode corresponds to the undefined root for UpPath API.
         if (this.parentPath.isRoot()) {
             return undefined;
@@ -811,16 +786,16 @@ class PathNode extends index_js_2.ReferenceCountedBase {
         return this.parentPath;
     }
     addRef(count = 1) {
-        (0, core_utils_1.assert)(this.status === Status.Alive, 0x40a /* PathNode must be alive */);
+        (0, internal_1.assert)(this.status === Status.Alive, 0x40a /* PathNode must be alive */);
         this.referenceAdded(count);
     }
     removeRef(count = 1) {
-        (0, core_utils_1.assert)(this.status !== Status.Disposed, 0x40b /* PathNode must not be disposed */);
+        (0, internal_1.assert)(this.status !== Status.Disposed, 0x40b /* PathNode must not be disposed */);
         this.referenceRemoved(count);
     }
     // Called when refcount is set to 0.
     // Node may be kept alive by children or events after this point.
-    dispose() {
+    onUnreferenced() {
         this.considerDispose();
     }
     /**
@@ -828,7 +803,7 @@ class PathNode extends index_js_2.ReferenceCountedBase {
      * Creates child (with 1 ref) if needed.
      */
     getOrCreateChild(key, index) {
-        (0, core_utils_1.assert)(this.status === Status.Alive, 0x40c /* PathNode must be alive */);
+        (0, internal_1.assert)(this.status === Status.Alive, 0x40c /* PathNode must be alive */);
         let field = this.children.get(key);
         if (field === undefined) {
             field = [];
@@ -852,7 +827,7 @@ class PathNode extends index_js_2.ReferenceCountedBase {
      * Does NOT add a ref.
      */
     tryGetChild(key, index) {
-        (0, core_utils_1.assert)(this.status === Status.Alive, 0x40d /* PathNode must be alive */);
+        (0, internal_1.assert)(this.status === Status.Alive, 0x40d /* PathNode must be alive */);
         const field = this.children.get(key);
         // TODO: should do more optimized search (ex: binary search or better) using index.
         return field?.find((c) => c.parentIndex === index);
@@ -863,13 +838,13 @@ class PathNode extends index_js_2.ReferenceCountedBase {
      * the caller must ensure that the reference from child to parent is also removed (or the child is no longer used).
      */
     removeChild(child) {
-        (0, core_utils_1.assert)(this.status === Status.Alive, 0x40e /* PathNode must be alive */);
+        (0, internal_1.assert)(this.status === Status.Alive, 0x40e /* PathNode must be alive */);
         const key = child.parentField;
         const field = this.children.get(key);
         // TODO: should do more optimized search (ex: binary search or better) using child.parentIndex()
         // Note that this is the index in the list of child paths, not the index within the field
         const childIndex = field?.indexOf(child) ?? -1;
-        (0, core_utils_1.assert)(childIndex !== -1, 0x35c /* child must be parented to be removed */);
+        (0, internal_1.assert)(childIndex !== -1, 0x35c /* child must be parented to be removed */);
         field?.splice(childIndex, 1);
         if (field?.length === 0) {
             this.afterEmptyField(key);
@@ -881,7 +856,7 @@ class PathNode extends index_js_2.ReferenceCountedBase {
      * (like the field in the map, and possibly this entire PathNode and its parents if they are no longer needed.)
      */
     afterEmptyField(key) {
-        (0, core_utils_1.assert)(this.status === Status.Alive, 0x40f /* PathNode must be alive */);
+        (0, internal_1.assert)(this.status === Status.Alive, 0x40f /* PathNode must be alive */);
         this.children.delete(key);
         this.considerDispose();
     }
@@ -893,7 +868,7 @@ class PathNode extends index_js_2.ReferenceCountedBase {
      * Allowed when dangling (but not when disposed).
      */
     considerDispose() {
-        (0, core_utils_1.assert)(this.status !== Status.Disposed, 0x41d /* PathNode must not be disposed */);
+        (0, internal_1.assert)(this.status !== Status.Disposed, 0x41d /* PathNode must not be disposed */);
         if (this.isUnreferenced() && this.children.size === 0 && !this.events.hasListeners()) {
             if (this.status === Status.Alive) {
                 this.parentPath?.removeChild(this);