@fluidframework/tree 2.20.0 → 2.22.0

package/src/util/rangeMap.ts

@@ -24,10 +24,19 @@ export class RangeMap<K, V> {
 	 * Offsetting `b` by this difference should return `a`.
 	 * The difference can be infinite if `a` cannot be reached from `b` by offsetting,
 	 * but the difference should still be positive if `a` is larger than `b` and negative if smaller.
+	 *
+	 * @param offsetValue - Function used to associate a range of values with a range of keys.
+	 * When writing to a range of keys starting with `start`, the value of the nth key is interpreted to be
+	 * `offsetValue(firstValue, n - 1)`.
+	 * The same logic should be used when interpreting the values for keys after the first in a
+	 * `RangeQueryResult` or `RangeQueryEntry`.
+	 *
+	 * If `offsetValue` is left unspecified, all keys in a block will be given the same value.
 	 */
 	public constructor(
 		private readonly offsetKey: (key: K, offset: number) => K,
 		private readonly subtractKeys: (a: K, b: K) => number,
+		public readonly offsetValue: (value: V, offset: number) => V = defaultValueOffsetFn,
 	) {
 		this.tree = new BTree(undefined, subtractKeys);
 	}
@@ -52,7 +61,7 @@ export class RangeMap<K, V> {
 	 * Retrieves the values for all keys in the query range.
 	 *
 	 * @param start - The first key in the range being queried
-	 * @param length  - The length of the query range
+	 * @param length - The length of the query range
 	 * @returns A list of entries, each describing the value for some subrange of the query.
 	 * The entries are in the same order as the keys, and there is an entry for every key with a non `undefined` value.
 	 */
@@ -65,7 +74,11 @@ export class RangeMap<K, V> {
 		const firstEntry = entries[0] ?? oob();
 		const lengthBefore = this.subtractKeys(start, firstEntry.start);
 		if (lengthBefore > 0) {
-			entries[0] = { ...firstEntry, start, length: firstEntry.length - lengthBefore };
+			entries[0] = {
+				start,
+				length: firstEntry.length - lengthBefore,
+				value: this.offsetValue(firstEntry.value, lengthBefore),
+			};
 		}
 
 		const lastEntry = entries[entries.length - 1] ?? oob();
@@ -96,9 +109,14 @@ export class RangeMap<K, V> {
 				const { value, length: entryLength } = entry[1];
 
 				const entryLastKey = this.offsetKey(entryKey, entryLength - 1);
+				const lengthBeforeQuery = this.subtractKeys(start, entryKey);
 				const overlappingLength = Math.min(this.subtractKeys(entryLastKey, start) + 1, length);
 				if (overlappingLength > 0) {
-					return { value, start, length: overlappingLength };
+					return {
+						value: this.offsetValue(value, lengthBeforeQuery),
+						start,
+						length: overlappingLength,
+					};
 				}
 			}
 		}
@@ -171,13 +189,18 @@ export class RangeMap<K, V> {
 			const lengthAfter = this.subtractKeys(lastEntryKey, lastDeleteKey);
 			if (lengthAfter > 0) {
 				// A portion of this entry comes after the deletion range, so we reinsert that portion.
-				this.tree.set(this.offsetKey(lastDeleteKey, 1), { length: lengthAfter, value });
+				const newKey = this.offsetKey(lastDeleteKey, 1);
+				const difference = this.subtractKeys(newKey, key);
+				this.tree.set(newKey, {
+					length: lengthAfter,
+					value: this.offsetValue(value, difference),
+				});
 			}
 		}
 	}
 
 	public clone(): RangeMap<K, V> {
-		const cloned = new RangeMap<K, V>(this.offsetKey, this.subtractKeys);
+		const cloned = new RangeMap<K, V>(this.offsetKey, this.subtractKeys, this.offsetValue);
 		cloned.tree = this.tree.clone();
 		return cloned;
 	}
@@ -187,11 +210,13 @@ export class RangeMap<K, V> {
 	 */
 	public static union<K, V>(a: RangeMap<K, V>, b: RangeMap<K, V>): RangeMap<K, V> {
 		assert(
-			a.offsetKey === b.offsetKey && a.subtractKeys === b.subtractKeys,
+			a.offsetKey === b.offsetKey &&
+				a.subtractKeys === b.subtractKeys &&
+				a.offsetValue === b.offsetValue,
 			0xaae /* Maps should have the same behavior */,
 		);
 
-		const merged = new RangeMap<K, V>(a.offsetKey, a.subtractKeys);
+		const merged = new RangeMap<K, V>(a.offsetKey, a.subtractKeys, a.offsetValue);
 
 		// TODO: Is there a good pattern that lets us make `tree` readonly?
 		merged.tree = a.tree.clone();
@@ -307,3 +332,7 @@ function offsetInteger(key: number, offset: number): number {
 function subtractIntegers(a: number, b: number): number {
 	return a - b;
 }
+
+function defaultValueOffsetFn<T>(value: T, offset: number): T {
+	return value;
+}

package/dist/core/tree/visitPath.d.ts

@@ -1,101 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import type { ProtoNodes } from "./delta.js";
-import type { DetachedPlaceUpPath, DetachedRangeUpPath, PlaceUpPath, RangeUpPath, UpPath } from "./pathTree.js";
-/**
- * Delta visitor for the path tree.
- *
- * For any of these events, the paths are guaranteed to be valid at the time of the event,
- * and it is valid to read from the Forest at that path.
- */
-export interface PathVisitor {
-    /**
-     * Invoked after the creation of a range of nodes.
-     * @param content - The content that was created.
-     */
-    afterCreate(content: DetachedRangeUpPath): void;
-    /**
-     * Invoked before the attaching of a range of nodes.
-     * Not invoked for replacements.
-     * @param source - The content that will be attached.
-     * @param destination - The location where the content will be attached.
-     * @param kind - The kind of replacement that will occur.
-     */
-    beforeAttach(source: DetachedRangeUpPath, destination: PlaceUpPath): void;
-    /**
-     * Invoked after the attaching of a range of nodes.
-     * Not invoked for replacements.
-     * @param source - The location where the content originated.
-     * @param destination - The content that was attached.
-     * @param kind - The kind of replacement that will occur.
-     */
-    afterAttach(source: DetachedPlaceUpPath, destination: RangeUpPath): void;
-    /**
-     * Invoked before the detaching of a range of nodes.
-     * Not invoked for replacements.
-     * @param source - The content that will be detached.
-     * @param destination - The location where the content will be sent to.
-     * @param kind - The kind of replacement that will occur.
-     */
-    beforeDetach(source: RangeUpPath, destination: DetachedPlaceUpPath): void;
-    /**
-     * Invoked after the detaching of a range of nodes.
-     * Not invoked for replacements.
-     * @param source - The content that was detached.
-     * @param destination - The location where the content will be attached.
-     * @param kind - The kind of replacement that will occur.
-     */
-    afterDetach(source: PlaceUpPath, destination: DetachedRangeUpPath): void;
-    /**
-     * Invoked before the replacement of a range of nodes.
-     *
-     * Note that the `newContent` range length will always match the `oldContent` range length.
-     * A replace might actually be separate detaches and attaches which have been coalesced.
-     *
-     * @param newContent - The content that will be attached in place of the old.
-     * @param oldContent - The old that will be replaced.
-     * @param oldContentDestination - The destination of the old content.
-     * @param kind - The kind of replacement that will occur.
-     */
-    beforeReplace(newContent: DetachedRangeUpPath, oldContent: RangeUpPath, oldContentDestination: DetachedPlaceUpPath): void;
-    /**
-     * Invoked after the replacement of a range of nodes.
-     *
-     * Note that the `newContent` range length will always match the `oldContent` range length.
-     * A replace might actually be separate detaches and attaches which have been coalesced.
-     *
-     * @param newContentSource - The place that the new content came from.
-     * @param newContent - The new content.
-     * @param oldContent - The content that was replaced.
-     */
-    afterReplace(newContentSource: DetachedPlaceUpPath, newContent: RangeUpPath, oldContent: DetachedRangeUpPath): void;
-    /**
-     * Invoked before content is destroyed.
-     * @param content - The content that will be destroyed
-     */
-    beforeDestroy(content: DetachedRangeUpPath): void;
-    /**
-     * A sequence of nodes of length `count` is being removed starting with `path`.
-     * Called when these nodes are no longer parented under their previous parent, and do not have a new parent.
-     * It is possible they may be restored in the future (for example by a conflicted merge or undo).
-     *
-     * Not called for children of removed nodes.
-     *
-     * @param path - first node in the removed range.
-     * @param count - length of removed range.
-     *
-     * @deprecated Migrate to using the other events.
-     */
-    onRemove(path: UpPath, count: number): void;
-    /**
-     * @param path - location which first node of inserted range will have after insert.
-     * Any nodes at this index (or after it) will be moved to the right (have their indexes increased by `content.length`).
-     * @param content - content which is being inserted.
-     *
-     * @deprecated Migrate to using the other events.
-     */
-    onInsert(path: UpPath, content: ProtoNodes): void;
-}
-//# sourceMappingURL=visitPath.d.ts.map

package/dist/core/tree/visitPath.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"visitPath.d.ts","sourceRoot":"","sources":["../../../src/core/tree/visitPath.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,KAAK,EACX,mBAAmB,EACnB,mBAAmB,EACnB,WAAW,EACX,WAAW,EACX,MAAM,EACN,MAAM,eAAe,CAAC;AAEvB;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC3B;;;OAGG;IACH,WAAW,CAAC,OAAO,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAEhD;;;;;;OAMG;IACH,YAAY,CAAC,MAAM,EAAE,mBAAmB,EAAE,WAAW,EAAE,WAAW,GAAG,IAAI,CAAC;IAE1E;;;;;;OAMG;IACH,WAAW,CAAC,MAAM,EAAE,mBAAmB,EAAE,WAAW,EAAE,WAAW,GAAG,IAAI,CAAC;IAEzE;;;;;;OAMG;IACH,YAAY,CAAC,MAAM,EAAE,WAAW,EAAE,WAAW,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAE1E;;;;;;OAMG;IACH,WAAW,CAAC,MAAM,EAAE,WAAW,EAAE,WAAW,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAEzE;;;;;;;;;;OAUG;IACH,aAAa,CACZ,UAAU,EAAE,mBAAmB,EAC/B,UAAU,EAAE,WAAW,EACvB,qBAAqB,EAAE,mBAAmB,GACxC,IAAI,CAAC;IAER;;;;;;;;;OASG;IACH,YAAY,CACX,gBAAgB,EAAE,mBAAmB,EACrC,UAAU,EAAE,WAAW,EACvB,UAAU,EAAE,mBAAmB,GAC7B,IAAI,CAAC;IAER;;;OAGG;IACH,aAAa,CAAC,OAAO,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAElD;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5C;;;;;;OAMG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,GAAG,IAAI,CAAC;CAClD"}

package/dist/core/tree/visitPath.js

@@ -1,7 +0,0 @@
-"use strict";
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=visitPath.js.map

package/dist/core/tree/visitPath.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"visitPath.js","sourceRoot":"","sources":["../../../src/core/tree/visitPath.ts"],"names":[],"mappings":";AAAA;;;GAGG","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport type { ProtoNodes } from \"./delta.js\";\nimport type {\n\tDetachedPlaceUpPath,\n\tDetachedRangeUpPath,\n\tPlaceUpPath,\n\tRangeUpPath,\n\tUpPath,\n} from \"./pathTree.js\";\n\n/**\n * Delta visitor for the path tree.\n *\n * For any of these events, the paths are guaranteed to be valid at the time of the event,\n * and it is valid to read from the Forest at that path.\n */\nexport interface PathVisitor {\n\t/**\n\t * Invoked after the creation of a range of nodes.\n\t * @param content - The content that was created.\n\t */\n\tafterCreate(content: DetachedRangeUpPath): void;\n\n\t/**\n\t * Invoked before the attaching of a range of nodes.\n\t * Not invoked for replacements.\n\t * @param source - The content that will be attached.\n\t * @param destination - The location where the content will be attached.\n\t * @param kind - The kind of replacement that will occur.\n\t */\n\tbeforeAttach(source: DetachedRangeUpPath, destination: PlaceUpPath): void;\n\n\t/**\n\t * Invoked after the attaching of a range of nodes.\n\t * Not invoked for replacements.\n\t * @param source - The location where the content originated.\n\t * @param destination - The content that was attached.\n\t * @param kind - The kind of replacement that will occur.\n\t */\n\tafterAttach(source: DetachedPlaceUpPath, destination: RangeUpPath): void;\n\n\t/**\n\t * Invoked before the detaching of a range of nodes.\n\t * Not invoked for replacements.\n\t * @param source - The content that will be detached.\n\t * @param destination - The location where the content will be sent to.\n\t * @param kind - The kind of replacement that will occur.\n\t */\n\tbeforeDetach(source: RangeUpPath, destination: DetachedPlaceUpPath): void;\n\n\t/**\n\t * Invoked after the detaching of a range of nodes.\n\t * Not invoked for replacements.\n\t * @param source - The content that was detached.\n\t * @param destination - The location where the content will be attached.\n\t * @param kind - The kind of replacement that will occur.\n\t */\n\tafterDetach(source: PlaceUpPath, destination: DetachedRangeUpPath): void;\n\n\t/**\n\t * Invoked before the replacement of a range of nodes.\n\t *\n\t * Note that the `newContent` range length will always match the `oldContent` range length.\n\t * A replace might actually be separate detaches and attaches which have been coalesced.\n\t *\n\t * @param newContent - The content that will be attached in place of the old.\n\t * @param oldContent - The old that will be replaced.\n\t * @param oldContentDestination - The destination of the old content.\n\t * @param kind - The kind of replacement that will occur.\n\t */\n\tbeforeReplace(\n\t\tnewContent: DetachedRangeUpPath,\n\t\toldContent: RangeUpPath,\n\t\toldContentDestination: DetachedPlaceUpPath,\n\t): void;\n\n\t/**\n\t * Invoked after the replacement of a range of nodes.\n\t *\n\t * Note that the `newContent` range length will always match the `oldContent` range length.\n\t * A replace might actually be separate detaches and attaches which have been coalesced.\n\t *\n\t * @param newContentSource - The place that the new content came from.\n\t * @param newContent - The new content.\n\t * @param oldContent - The content that was replaced.\n\t */\n\tafterReplace(\n\t\tnewContentSource: DetachedPlaceUpPath,\n\t\tnewContent: RangeUpPath,\n\t\toldContent: DetachedRangeUpPath,\n\t): void;\n\n\t/**\n\t * Invoked before content is destroyed.\n\t * @param content - The content that will be destroyed\n\t */\n\tbeforeDestroy(content: DetachedRangeUpPath): void;\n\n\t/**\n\t * A sequence of nodes of length `count` is being removed starting with `path`.\n\t * Called when these nodes are no longer parented under their previous parent, and do not have a new parent.\n\t * It is possible they may be restored in the future (for example by a conflicted merge or undo).\n\t *\n\t * Not called for children of removed nodes.\n\t *\n\t * @param path - first node in the removed range.\n\t * @param count - length of removed range.\n\t *\n\t * @deprecated Migrate to using the other events.\n\t */\n\tonRemove(path: UpPath, count: number): void;\n\t/**\n\t * @param path - location which first node of inserted range will have after insert.\n\t * Any nodes at this index (or after it) will be moved to the right (have their indexes increased by `content.length`).\n\t * @param content - content which is being inserted.\n\t *\n\t * @deprecated Migrate to using the other events.\n\t */\n\tonInsert(path: UpPath, content: ProtoNodes): void;\n}\n"]}

package/dist/shared-tree/transactionTypes.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"transactionTypes.d.ts","sourceRoot":"","sources":["../../src/shared-tree/transactionTypes.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAExD;;;GAGG;AACH,eAAO,MAAM,QAAQ,eAA4C,CAAC;AAElE;;;;;;;;;GASG;AACH,MAAM,MAAM,qBAAqB,GAAG,wBAAwB,CAAC;AAE7D;;;;GAIG;AACH,MAAM,WAAW,wBAAwB;IACxC,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAChC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;CACxB;AAED;;;GAGG;AACH,MAAM,MAAM,yBAAyB,CAAC,aAAa,EAAE,aAAa,IAAI,CACnE;IACA,gEAAgE;IAChE,QAAQ,CAAC,EAAE,KAAK,CAAC;IACjB,oEAAoE;IACpE,KAAK,EAAE,aAAa,CAAC;CACpB,GACD;IACA,gGAAgG;IAChG,QAAQ,EAAE,IAAI,CAAC;IACf,0DAA0D;IAC1D,KAAK,EAAE,aAAa,CAAC;CACpB,CACH,GAAG;IACH;;;;;;OAMG;IACH,qBAAqB,CAAC,EAAE,SAAS,qBAAqB,EAAE,CAAC;CACzD,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,6BAA6B,GAAG,IAAI,CAC/C,yBAAyB,CAAC,OAAO,EAAE,OAAO,CAAC,EAC3C,OAAO,CACP,CAAC;AAEF;;;GAGG;AACH,MAAM,WAAW,wBAAwB,CAAC,aAAa;IACtD,qDAAqD;IACrD,OAAO,EAAE,IAAI,CAAC;IACd,kEAAkE;IAClE,KAAK,EAAE,aAAa,CAAC;CACrB;AAED;;;GAGG;AACH,MAAM,WAAW,uBAAuB,CAAC,aAAa;IACrD,6CAA6C;IAC7C,OAAO,EAAE,KAAK,CAAC;IACf,0DAA0D;IAC1D,KAAK,EAAE,aAAa,CAAC;CACrB;AAED;;;GAGG;AACH,MAAM,MAAM,oBAAoB,CAAC,aAAa,EAAE,aAAa,IAC1D,wBAAwB,CAAC,aAAa,CAAC,GACvC,uBAAuB,CAAC,aAAa,CAAC,CAAC;AAE1C;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,GAC1B,IAAI,CAAC,wBAAwB,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,GAChD,IAAI,CAAC,uBAAuB,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,CAAC;AAEnD;;;GAGG;AACH,MAAM,WAAW,oBAAoB;IACpC;;;;;OAKG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,qBAAqB,EAAE,CAAC;CAC1D"}

package/lib/core/tree/visitPath.d.ts

@@ -1,101 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import type { ProtoNodes } from "./delta.js";
-import type { DetachedPlaceUpPath, DetachedRangeUpPath, PlaceUpPath, RangeUpPath, UpPath } from "./pathTree.js";
-/**
- * Delta visitor for the path tree.
- *
- * For any of these events, the paths are guaranteed to be valid at the time of the event,
- * and it is valid to read from the Forest at that path.
- */
-export interface PathVisitor {
-    /**
-     * Invoked after the creation of a range of nodes.
-     * @param content - The content that was created.
-     */
-    afterCreate(content: DetachedRangeUpPath): void;
-    /**
-     * Invoked before the attaching of a range of nodes.
-     * Not invoked for replacements.
-     * @param source - The content that will be attached.
-     * @param destination - The location where the content will be attached.
-     * @param kind - The kind of replacement that will occur.
-     */
-    beforeAttach(source: DetachedRangeUpPath, destination: PlaceUpPath): void;
-    /**
-     * Invoked after the attaching of a range of nodes.
-     * Not invoked for replacements.
-     * @param source - The location where the content originated.
-     * @param destination - The content that was attached.
-     * @param kind - The kind of replacement that will occur.
-     */
-    afterAttach(source: DetachedPlaceUpPath, destination: RangeUpPath): void;
-    /**
-     * Invoked before the detaching of a range of nodes.
-     * Not invoked for replacements.
-     * @param source - The content that will be detached.
-     * @param destination - The location where the content will be sent to.
-     * @param kind - The kind of replacement that will occur.
-     */
-    beforeDetach(source: RangeUpPath, destination: DetachedPlaceUpPath): void;
-    /**
-     * Invoked after the detaching of a range of nodes.
-     * Not invoked for replacements.
-     * @param source - The content that was detached.
-     * @param destination - The location where the content will be attached.
-     * @param kind - The kind of replacement that will occur.
-     */
-    afterDetach(source: PlaceUpPath, destination: DetachedRangeUpPath): void;
-    /**
-     * Invoked before the replacement of a range of nodes.
-     *
-     * Note that the `newContent` range length will always match the `oldContent` range length.
-     * A replace might actually be separate detaches and attaches which have been coalesced.
-     *
-     * @param newContent - The content that will be attached in place of the old.
-     * @param oldContent - The old that will be replaced.
-     * @param oldContentDestination - The destination of the old content.
-     * @param kind - The kind of replacement that will occur.
-     */
-    beforeReplace(newContent: DetachedRangeUpPath, oldContent: RangeUpPath, oldContentDestination: DetachedPlaceUpPath): void;
-    /**
-     * Invoked after the replacement of a range of nodes.
-     *
-     * Note that the `newContent` range length will always match the `oldContent` range length.
-     * A replace might actually be separate detaches and attaches which have been coalesced.
-     *
-     * @param newContentSource - The place that the new content came from.
-     * @param newContent - The new content.
-     * @param oldContent - The content that was replaced.
-     */
-    afterReplace(newContentSource: DetachedPlaceUpPath, newContent: RangeUpPath, oldContent: DetachedRangeUpPath): void;
-    /**
-     * Invoked before content is destroyed.
-     * @param content - The content that will be destroyed
-     */
-    beforeDestroy(content: DetachedRangeUpPath): void;
-    /**
-     * A sequence of nodes of length `count` is being removed starting with `path`.
-     * Called when these nodes are no longer parented under their previous parent, and do not have a new parent.
-     * It is possible they may be restored in the future (for example by a conflicted merge or undo).
-     *
-     * Not called for children of removed nodes.
-     *
-     * @param path - first node in the removed range.
-     * @param count - length of removed range.
-     *
-     * @deprecated Migrate to using the other events.
-     */
-    onRemove(path: UpPath, count: number): void;
-    /**
-     * @param path - location which first node of inserted range will have after insert.
-     * Any nodes at this index (or after it) will be moved to the right (have their indexes increased by `content.length`).
-     * @param content - content which is being inserted.
-     *
-     * @deprecated Migrate to using the other events.
-     */
-    onInsert(path: UpPath, content: ProtoNodes): void;
-}
-//# sourceMappingURL=visitPath.d.ts.map

package/lib/core/tree/visitPath.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"visitPath.d.ts","sourceRoot":"","sources":["../../../src/core/tree/visitPath.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,KAAK,EACX,mBAAmB,EACnB,mBAAmB,EACnB,WAAW,EACX,WAAW,EACX,MAAM,EACN,MAAM,eAAe,CAAC;AAEvB;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC3B;;;OAGG;IACH,WAAW,CAAC,OAAO,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAEhD;;;;;;OAMG;IACH,YAAY,CAAC,MAAM,EAAE,mBAAmB,EAAE,WAAW,EAAE,WAAW,GAAG,IAAI,CAAC;IAE1E;;;;;;OAMG;IACH,WAAW,CAAC,MAAM,EAAE,mBAAmB,EAAE,WAAW,EAAE,WAAW,GAAG,IAAI,CAAC;IAEzE;;;;;;OAMG;IACH,YAAY,CAAC,MAAM,EAAE,WAAW,EAAE,WAAW,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAE1E;;;;;;OAMG;IACH,WAAW,CAAC,MAAM,EAAE,WAAW,EAAE,WAAW,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAEzE;;;;;;;;;;OAUG;IACH,aAAa,CACZ,UAAU,EAAE,mBAAmB,EAC/B,UAAU,EAAE,WAAW,EACvB,qBAAqB,EAAE,mBAAmB,GACxC,IAAI,CAAC;IAER;;;;;;;;;OASG;IACH,YAAY,CACX,gBAAgB,EAAE,mBAAmB,EACrC,UAAU,EAAE,WAAW,EACvB,UAAU,EAAE,mBAAmB,GAC7B,IAAI,CAAC;IAER;;;OAGG;IACH,aAAa,CAAC,OAAO,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAElD;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5C;;;;;;OAMG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,GAAG,IAAI,CAAC;CAClD"}

package/lib/core/tree/visitPath.js

@@ -1,6 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-export {};
-//# sourceMappingURL=visitPath.js.map

package/lib/core/tree/visitPath.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"visitPath.js","sourceRoot":"","sources":["../../../src/core/tree/visitPath.ts"],"names":[],"mappings":"AAAA;;;GAGG","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport type { ProtoNodes } from \"./delta.js\";\nimport type {\n\tDetachedPlaceUpPath,\n\tDetachedRangeUpPath,\n\tPlaceUpPath,\n\tRangeUpPath,\n\tUpPath,\n} from \"./pathTree.js\";\n\n/**\n * Delta visitor for the path tree.\n *\n * For any of these events, the paths are guaranteed to be valid at the time of the event,\n * and it is valid to read from the Forest at that path.\n */\nexport interface PathVisitor {\n\t/**\n\t * Invoked after the creation of a range of nodes.\n\t * @param content - The content that was created.\n\t */\n\tafterCreate(content: DetachedRangeUpPath): void;\n\n\t/**\n\t * Invoked before the attaching of a range of nodes.\n\t * Not invoked for replacements.\n\t * @param source - The content that will be attached.\n\t * @param destination - The location where the content will be attached.\n\t * @param kind - The kind of replacement that will occur.\n\t */\n\tbeforeAttach(source: DetachedRangeUpPath, destination: PlaceUpPath): void;\n\n\t/**\n\t * Invoked after the attaching of a range of nodes.\n\t * Not invoked for replacements.\n\t * @param source - The location where the content originated.\n\t * @param destination - The content that was attached.\n\t * @param kind - The kind of replacement that will occur.\n\t */\n\tafterAttach(source: DetachedPlaceUpPath, destination: RangeUpPath): void;\n\n\t/**\n\t * Invoked before the detaching of a range of nodes.\n\t * Not invoked for replacements.\n\t * @param source - The content that will be detached.\n\t * @param destination - The location where the content will be sent to.\n\t * @param kind - The kind of replacement that will occur.\n\t */\n\tbeforeDetach(source: RangeUpPath, destination: DetachedPlaceUpPath): void;\n\n\t/**\n\t * Invoked after the detaching of a range of nodes.\n\t * Not invoked for replacements.\n\t * @param source - The content that was detached.\n\t * @param destination - The location where the content will be attached.\n\t * @param kind - The kind of replacement that will occur.\n\t */\n\tafterDetach(source: PlaceUpPath, destination: DetachedRangeUpPath): void;\n\n\t/**\n\t * Invoked before the replacement of a range of nodes.\n\t *\n\t * Note that the `newContent` range length will always match the `oldContent` range length.\n\t * A replace might actually be separate detaches and attaches which have been coalesced.\n\t *\n\t * @param newContent - The content that will be attached in place of the old.\n\t * @param oldContent - The old that will be replaced.\n\t * @param oldContentDestination - The destination of the old content.\n\t * @param kind - The kind of replacement that will occur.\n\t */\n\tbeforeReplace(\n\t\tnewContent: DetachedRangeUpPath,\n\t\toldContent: RangeUpPath,\n\t\toldContentDestination: DetachedPlaceUpPath,\n\t): void;\n\n\t/**\n\t * Invoked after the replacement of a range of nodes.\n\t *\n\t * Note that the `newContent` range length will always match the `oldContent` range length.\n\t * A replace might actually be separate detaches and attaches which have been coalesced.\n\t *\n\t * @param newContentSource - The place that the new content came from.\n\t * @param newContent - The new content.\n\t * @param oldContent - The content that was replaced.\n\t */\n\tafterReplace(\n\t\tnewContentSource: DetachedPlaceUpPath,\n\t\tnewContent: RangeUpPath,\n\t\toldContent: DetachedRangeUpPath,\n\t): void;\n\n\t/**\n\t * Invoked before content is destroyed.\n\t * @param content - The content that will be destroyed\n\t */\n\tbeforeDestroy(content: DetachedRangeUpPath): void;\n\n\t/**\n\t * A sequence of nodes of length `count` is being removed starting with `path`.\n\t * Called when these nodes are no longer parented under their previous parent, and do not have a new parent.\n\t * It is possible they may be restored in the future (for example by a conflicted merge or undo).\n\t *\n\t * Not called for children of removed nodes.\n\t *\n\t * @param path - first node in the removed range.\n\t * @param count - length of removed range.\n\t *\n\t * @deprecated Migrate to using the other events.\n\t */\n\tonRemove(path: UpPath, count: number): void;\n\t/**\n\t * @param path - location which first node of inserted range will have after insert.\n\t * Any nodes at this index (or after it) will be moved to the right (have their indexes increased by `content.length`).\n\t * @param content - content which is being inserted.\n\t *\n\t * @deprecated Migrate to using the other events.\n\t */\n\tonInsert(path: UpPath, content: ProtoNodes): void;\n}\n"]}

package/lib/shared-tree/transactionTypes.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"transactionTypes.d.ts","sourceRoot":"","sources":["../../src/shared-tree/transactionTypes.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAExD;;;GAGG;AACH,eAAO,MAAM,QAAQ,eAA4C,CAAC;AAElE;;;;;;;;;GASG;AACH,MAAM,MAAM,qBAAqB,GAAG,wBAAwB,CAAC;AAE7D;;;;GAIG;AACH,MAAM,WAAW,wBAAwB;IACxC,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAChC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;CACxB;AAED;;;GAGG;AACH,MAAM,MAAM,yBAAyB,CAAC,aAAa,EAAE,aAAa,IAAI,CACnE;IACA,gEAAgE;IAChE,QAAQ,CAAC,EAAE,KAAK,CAAC;IACjB,oEAAoE;IACpE,KAAK,EAAE,aAAa,CAAC;CACpB,GACD;IACA,gGAAgG;IAChG,QAAQ,EAAE,IAAI,CAAC;IACf,0DAA0D;IAC1D,KAAK,EAAE,aAAa,CAAC;CACpB,CACH,GAAG;IACH;;;;;;OAMG;IACH,qBAAqB,CAAC,EAAE,SAAS,qBAAqB,EAAE,CAAC;CACzD,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,6BAA6B,GAAG,IAAI,CAC/C,yBAAyB,CAAC,OAAO,EAAE,OAAO,CAAC,EAC3C,OAAO,CACP,CAAC;AAEF;;;GAGG;AACH,MAAM,WAAW,wBAAwB,CAAC,aAAa;IACtD,qDAAqD;IACrD,OAAO,EAAE,IAAI,CAAC;IACd,kEAAkE;IAClE,KAAK,EAAE,aAAa,CAAC;CACrB;AAED;;;GAGG;AACH,MAAM,WAAW,uBAAuB,CAAC,aAAa;IACrD,6CAA6C;IAC7C,OAAO,EAAE,KAAK,CAAC;IACf,0DAA0D;IAC1D,KAAK,EAAE,aAAa,CAAC;CACrB;AAED;;;GAGG;AACH,MAAM,MAAM,oBAAoB,CAAC,aAAa,EAAE,aAAa,IAC1D,wBAAwB,CAAC,aAAa,CAAC,GACvC,uBAAuB,CAAC,aAAa,CAAC,CAAC;AAE1C;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,GAC1B,IAAI,CAAC,wBAAwB,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,GAChD,IAAI,CAAC,uBAAuB,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,CAAC;AAEnD;;;GAGG;AACH,MAAM,WAAW,oBAAoB;IACpC;;;;;OAKG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,qBAAqB,EAAE,CAAC;CAC1D"}

package/src/core/tree/visitPath.ts

@@ -1,124 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-
-import type { ProtoNodes } from "./delta.js";
-import type {
-	DetachedPlaceUpPath,
-	DetachedRangeUpPath,
-	PlaceUpPath,
-	RangeUpPath,
-	UpPath,
-} from "./pathTree.js";
-
-/**
- * Delta visitor for the path tree.
- *
- * For any of these events, the paths are guaranteed to be valid at the time of the event,
- * and it is valid to read from the Forest at that path.
- */
-export interface PathVisitor {
-	/**
-	 * Invoked after the creation of a range of nodes.
-	 * @param content - The content that was created.
-	 */
-	afterCreate(content: DetachedRangeUpPath): void;
-
-	/**
-	 * Invoked before the attaching of a range of nodes.
-	 * Not invoked for replacements.
-	 * @param source - The content that will be attached.
-	 * @param destination - The location where the content will be attached.
-	 * @param kind - The kind of replacement that will occur.
-	 */
-	beforeAttach(source: DetachedRangeUpPath, destination: PlaceUpPath): void;
-
-	/**
-	 * Invoked after the attaching of a range of nodes.
-	 * Not invoked for replacements.
-	 * @param source - The location where the content originated.
-	 * @param destination - The content that was attached.
-	 * @param kind - The kind of replacement that will occur.
-	 */
-	afterAttach(source: DetachedPlaceUpPath, destination: RangeUpPath): void;
-
-	/**
-	 * Invoked before the detaching of a range of nodes.
-	 * Not invoked for replacements.
-	 * @param source - The content that will be detached.
-	 * @param destination - The location where the content will be sent to.
-	 * @param kind - The kind of replacement that will occur.
-	 */
-	beforeDetach(source: RangeUpPath, destination: DetachedPlaceUpPath): void;
-
-	/**
-	 * Invoked after the detaching of a range of nodes.
-	 * Not invoked for replacements.
-	 * @param source - The content that was detached.
-	 * @param destination - The location where the content will be attached.
-	 * @param kind - The kind of replacement that will occur.
-	 */
-	afterDetach(source: PlaceUpPath, destination: DetachedRangeUpPath): void;
-
-	/**
-	 * Invoked before the replacement of a range of nodes.
-	 *
-	 * Note that the `newContent` range length will always match the `oldContent` range length.
-	 * A replace might actually be separate detaches and attaches which have been coalesced.
-	 *
-	 * @param newContent - The content that will be attached in place of the old.
-	 * @param oldContent - The old that will be replaced.
-	 * @param oldContentDestination - The destination of the old content.
-	 * @param kind - The kind of replacement that will occur.
-	 */
-	beforeReplace(
-		newContent: DetachedRangeUpPath,
-		oldContent: RangeUpPath,
-		oldContentDestination: DetachedPlaceUpPath,
-	): void;
-
-	/**
-	 * Invoked after the replacement of a range of nodes.
-	 *
-	 * Note that the `newContent` range length will always match the `oldContent` range length.
-	 * A replace might actually be separate detaches and attaches which have been coalesced.
-	 *
-	 * @param newContentSource - The place that the new content came from.
-	 * @param newContent - The new content.
-	 * @param oldContent - The content that was replaced.
-	 */
-	afterReplace(
-		newContentSource: DetachedPlaceUpPath,
-		newContent: RangeUpPath,
-		oldContent: DetachedRangeUpPath,
-	): void;
-
-	/**
-	 * Invoked before content is destroyed.
-	 * @param content - The content that will be destroyed
-	 */
-	beforeDestroy(content: DetachedRangeUpPath): void;
-
-	/**
-	 * A sequence of nodes of length `count` is being removed starting with `path`.
-	 * Called when these nodes are no longer parented under their previous parent, and do not have a new parent.
-	 * It is possible they may be restored in the future (for example by a conflicted merge or undo).
-	 *
-	 * Not called for children of removed nodes.
-	 *
-	 * @param path - first node in the removed range.
-	 * @param count - length of removed range.
-	 *
-	 * @deprecated Migrate to using the other events.
-	 */
-	onRemove(path: UpPath, count: number): void;
-	/**
-	 * @param path - location which first node of inserted range will have after insert.
-	 * Any nodes at this index (or after it) will be moved to the right (have their indexes increased by `content.length`).
-	 * @param content - content which is being inserted.
-	 *
-	 * @deprecated Migrate to using the other events.
-	 */
-	onInsert(path: UpPath, content: ProtoNodes): void;
-}