@fluidframework/tree 2.83.0 → 2.90.0-378676

package/src/simple-tree/unhydratedFlexTreeFromInsertable.ts

@@ -7,6 +7,7 @@ import type { IFluidHandle } from "@fluidframework/core-interfaces";
 import { assert, debugAssert, fail } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
+import type { FlexTreeNode } from "../feature-libraries/index.js";
 import { filterIterable, hasSingle, oneFromIterable } from "../util/index.js";
 
 import {
@@ -24,7 +25,7 @@ import { getUnhydratedContext } from "./createContext.js";
 import { normalizeFieldSchema, FieldKind, type ImplicitFieldSchema } from "./fieldSchema.js";
 
 /**
- * Transforms an input {@link TypedNode} tree to an {@link UnhydratedFlexTreeNode}.
+ * Transforms an input {@link TypedNode} tree to a {@link FlexTreeNode}.
  * @param data - The input tree to be converted.
  * If the data is an unsupported value (e.g. NaN), a fallback value will be used when supported,
  * otherwise an error will be thrown.
@@ -49,10 +50,10 @@ import { normalizeFieldSchema, FieldKind, type ImplicitFieldSchema } from "./fie
  * Output should comply with the provided view schema, but this is not explicitly validated:
  * validation against stored schema (to guard against document corruption) is done elsewhere.
  */
-export function unhydratedFlexTreeFromInsertable<TIn extends InsertableContent | undefined>(
+export function flexTreeFromInsertable<TIn extends InsertableContent | undefined>(
 	data: TIn,
 	allowedTypes: ImplicitFieldSchema,
-): TIn extends undefined ? undefined : UnhydratedFlexTreeNode {
+): TIn extends undefined ? undefined : FlexTreeNode {
 	const normalizedFieldSchema = normalizeFieldSchema(allowedTypes);
 
 	if (data === undefined) {
@@ -62,15 +63,15 @@ export function unhydratedFlexTreeFromInsertable<TIn extends InsertableContent |
 				`Got undefined for non-optional field expecting one of ${quotedAllowedTypesWithNames(normalizedFieldSchema.allowedTypeSet)}`,
 			);
 		}
-		return undefined as TIn extends undefined ? undefined : UnhydratedFlexTreeNode;
+		return undefined as TIn extends undefined ? undefined : FlexTreeNode;
 	}
 
-	const flexTree: UnhydratedFlexTreeNode = unhydratedFlexTreeFromInsertableNode(
+	const flexTree: FlexTreeNode = flexTreeFromInsertableNode(
 		data,
 		normalizedFieldSchema.allowedTypeSet,
 	);
 
-	return flexTree as TIn extends undefined ? undefined : UnhydratedFlexTreeNode;
+	return flexTree as TIn extends undefined ? undefined : FlexTreeNode;
 }
 
 /**
@@ -117,23 +118,42 @@ function quotedAllowedTypesWithNames(allowedTypes: Iterable<TreeNodeSchema>): st
 /**
  * Copy content from `data` into a UnhydratedFlexTreeNode.
  */
-export function unhydratedFlexTreeFromInsertableNode(
+export function unhydratedFlexTreeFromInsertable<TIn extends InsertableContent | undefined>(
+	data: TIn,
+	allowedTypes: ImplicitFieldSchema,
+): TIn extends undefined ? undefined : UnhydratedFlexTreeNode {
+	const result = flexTreeFromInsertable(data, allowedTypes);
+	if (result === undefined) {
+		return undefined as TIn extends undefined ? undefined : UnhydratedFlexTreeNode;
+	}
+	assert(result instanceof UnhydratedFlexTreeNode, "expected unhydrated node");
+	return result as TIn extends undefined ? undefined : UnhydratedFlexTreeNode;
+}
+
+/**
+ * Copy content from `data` into a UnhydratedFlexTreeNode or return an existing node if `data` is a TreeNode.
+ */
+export function flexTreeFromInsertableNode(
 	data: InsertableContent,
 	allowedTypes: ReadonlySet<TreeNodeSchema>,
-): UnhydratedFlexTreeNode {
+): FlexTreeNode {
 	if (isTreeNode(data)) {
 		const kernel = getKernel(data);
-		const inner = kernel.getInnerNodeIfUnhydrated();
-		if (inner === undefined) {
-			// The node is already hydrated, meaning that it already got inserted into the tree previously
-			throw new UsageError(
-				`A node with schema ${quotedSchemaIdentifierWithName(kernel.schema)} was inserted into the tree more than once. This is not supported.`,
-			);
-		} else {
+		const inner = kernel.getInnerNode();
+		if (inner.parentField.parent.parent === undefined) {
 			if (!allowedTypes.has(kernel.schema)) {
 				allowedTypesInsertableSchemaError(allowedTypes, kernel.schema);
 			}
+
+			if (inner.isHydrated()) {
+				// TODO: hook up event bubbling from hydrated to unhydrated tree.
+			}
+
 			return inner;
+		} else {
+			throw new UsageError(
+				"A node which already has a parent may not be used as part of a new tree.",
+			);
 		}
 	}
 

package/src/treeFactory.ts

@@ -26,7 +26,9 @@ import {
 	type SharedTreeKernelView,
 } from "./shared-tree/index.js";
 import {
+	editManagerFormatVersionSelectorForDetachedRootEditing,
 	editManagerFormatVersionSelectorForSharedBranches,
+	messageFormatVersionSelectorForDetachedRootEditing,
 	messageFormatVersionSelectorForSharedBranches,
 } from "./shared-tree-core/index.js";
 import { SharedTreeFactoryType, SharedTreeAttributes } from "./sharedTreeAttributes.js";
@@ -212,12 +214,17 @@ export function resolveOptions(options: SharedTreeOptions): SharedTreeOptionsInt
 }
 
 function resolveFormatOptions(options: SharedTreeOptions): SharedTreeOptionsInternal {
-	const enableSharedBranches = options.enableSharedBranches ?? false;
-
-	if (enableSharedBranches) {
+	if (options.enableSharedBranches === true && options.enableDetachedRootEditing === true) {
+		throw new UsageError(
+			"enableDetachedRootEditing cannot be used with enableSharedBranches.",
+		);
+	}
+	if (options.enableSharedBranches === true) {
 		return sharedBranchesOptions;
 	}
-
+	if (options.enableDetachedRootEditing === true) {
+		return detachRootEditingOptions;
+	}
 	return {};
 }
 
@@ -225,3 +232,8 @@ const sharedBranchesOptions: SharedTreeOptionsInternal = {
 	messageFormatSelector: messageFormatVersionSelectorForSharedBranches,
 	editManagerFormatSelector: editManagerFormatVersionSelectorForSharedBranches,
 };
+const detachRootEditingOptions: SharedTreeOptionsInternal = {
+	messageFormatSelector: messageFormatVersionSelectorForDetachedRootEditing,
+	editManagerFormatSelector: editManagerFormatVersionSelectorForDetachedRootEditing,
+	enableDetachedRootEditing: true,
+};

package/src/util/index.ts

@@ -135,7 +135,10 @@ export {
 export {
 	RangeMap,
 	type RangeQueryResult,
+	type RangeQueryResultFragment,
+	type RangeQueryEntry,
 	newIntegerRangeMap,
+	areAdjacentIntegerRanges,
 } from "./rangeMap.js";
 
 export {

package/src/util/rangeMap.ts

@@ -5,8 +5,6 @@
 
 import { assert, oob } from "@fluidframework/core-utils/internal";
 import { BTree } from "@tylerbu/sorted-btree-es6";
-// eslint-disable-next-line import-x/no-internal-modules
-import { union } from "@tylerbu/sorted-btree-es6/extended/union";
 
 /**
  * RangeMap represents a mapping from keys of type K to values of type V or undefined.
@@ -36,8 +34,8 @@ export class RangeMap<K, V> {
 	 * 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 offsetKey: (key: K, offset: number) => K,
+		public readonly subtractKeys: (a: K, b: K) => number,
 		public readonly offsetValue: (value: V, offset: number) => V = defaultValueOffsetFn,
 	) {
 		this.tree = new BTree(undefined, subtractKeys);
@@ -94,6 +92,34 @@ export class RangeMap<K, V> {
 		return entries;
 	}
 
+	// XXX: Merge with getAll
+	/**
+	 * Like getAll, but includes entries where the value is undefined.
+	 */
+	public getAll2(start: K, length: number): RangeQueryResultFragment<V | undefined>[] {
+		let nextKey = start;
+		let offset = 0;
+		const result: RangeQueryResultFragment<V | undefined>[] = [];
+		for (const entry of this.getAll(start, length)) {
+			const lengthBefore = this.subtractKeys(entry.start, nextKey);
+			if (lengthBefore > 0) {
+				result.push({ offset, length: lengthBefore, value: undefined });
+				offset += lengthBefore;
+			}
+
+			result.push({ offset, length: entry.length, value: entry.value });
+			nextKey = this.offsetKey(entry.start, entry.length);
+			offset += entry.length;
+		}
+
+		const lengthRemaining = length - offset;
+		if (lengthRemaining > 0) {
+			result.push({ offset, length: lengthRemaining, value: undefined });
+		}
+
+		return result;
+	}
+
 	/**
 	 * Retrieves the value for some prefix of the query range.
 	 *
@@ -102,7 +128,7 @@ export class RangeMap<K, V> {
 	 * @returns A RangeQueryResult containing the value associated with `start`,
 	 * and the number of consecutive keys with that same value (at least 1, at most `length`).
 	 */
-	public getFirst(start: K, length: number): RangeQueryResult<K, V> {
+	public getFirst(start: K, length: number): RangeQueryResult<V | undefined> {
 		{
 			// We first check for an entry with a key less than or equal to `start`.
 			const entry = this.tree.getPairOrNextLower(start);
@@ -116,7 +142,6 @@ export class RangeMap<K, V> {
 				if (overlappingLength > 0) {
 					return {
 						value: this.offsetValue(value, lengthBeforeQuery),
-						start,
 						length: overlappingLength,
 					};
 				}
@@ -132,11 +157,11 @@ export class RangeMap<K, V> {
 
 				const lastQueryKey = this.offsetKey(start, length - 1);
 				if (this.le(entryKey, lastQueryKey)) {
-					return { value: undefined, start, length: this.subtractKeys(entryKey, start) };
+					return { value: undefined, length: this.subtractKeys(entryKey, start) };
 				}
 			}
 
-			return { value: undefined, start, length };
+			return { value: undefined, length };
 		}
 	}
 
@@ -213,8 +238,17 @@ export class RangeMap<K, V> {
 		return cloned;
 	}
 
+	public mapEntries(mapKey: (key: K) => K, mapValue: (value: V) => V): RangeMap<K, V> {
+		const result = new RangeMap<K, V>(this.offsetKey, this.subtractKeys, this.offsetValue);
+		for (const entry of this.entries()) {
+			result.set(mapKey(entry.start), entry.length, mapValue(entry.value));
+		}
+		return result;
+	}
+
 	/**
 	 * Returns a new map which contains the entries from both input maps.
+	 * Whenever both maps contain entires for the same keys, the value from map `b` is used in the returned map.
 	 */
 	public static union<K, V>(a: RangeMap<K, V>, b: RangeMap<K, V>): RangeMap<K, V> {
 		assert(
@@ -224,15 +258,10 @@ export class RangeMap<K, V> {
 			0xaae /* Maps should have the same behavior */,
 		);
 
-		const merged = new RangeMap<K, V>(a.offsetKey, a.subtractKeys, a.offsetValue);
-
-		merged.tree = union<BTree<K, RangeEntry<V>>, K, RangeEntry<V>>(
-			a.tree,
-			b.tree,
-			(_key, _val1, val2) => {
-				return val2;
-			},
-		);
+		const merged = a.clone();
+		for (const entry of b.entries()) {
+			merged.set(entry.start, entry.length, entry.value);
+		}
 
 		return merged;
 	}
@@ -306,17 +335,11 @@ interface RangeEntry<V> {
 /**
  * Describes the result of a range query, including the value and length of the matching prefix.
  */
-export interface RangeQueryResult<K, V> {
-	/**
-	 * The key for the first element in the range.
-	 */
-	readonly start: K;
-
+export interface RangeQueryResult<V> {
 	/**
 	 * The value of the first key in the query range.
-	 * If no matching range is found, this will be undefined.
 	 */
-	readonly value: V | undefined;
+	readonly value: V;
 
 	/**
 	 * The length of the prefix of the query range which has the same value.
@@ -326,8 +349,19 @@ export interface RangeQueryResult<K, V> {
 	readonly length: number;
 }
 
-export interface RangeQueryEntry<K, V> extends RangeQueryResult<K, V> {
+export interface RangeQueryResultFragment<V> extends RangeQueryResult<V> {
+	/**
+	 * The offset from the query key to the key this result is associated with.
+	 * This is useful in the case where a query returns multiple `RangeQueryResults`
+	 * addressing the key range.
+	 */
+	readonly offset: number;
+}
+
+export interface RangeQueryEntry<K, V> {
+	readonly start: K;
 	readonly value: V;
+	readonly length: number;
 }
 
 export function newIntegerRangeMap<V, K extends number = number>(): RangeMap<K, V> {
@@ -345,3 +379,11 @@ function subtractIntegers<K extends number>(a: K, b: K): number {
 function defaultValueOffsetFn<T>(value: T, offset: number): T {
 	return value;
 }
+
+export function areAdjacentIntegerRanges(
+	firstStart: number,
+	firstLength: number,
+	secondStart: number,
+): boolean {
+	return firstStart + firstLength === secondStart;
+}

package/dist/feature-libraries/sequence-field/relevantRemovedRoots.d.ts

@@ -1,9 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import { type DeltaDetachedNodeId } from "../../core/index.js";
-import type { RelevantRemovedRootsFromChild } from "../modular-schema/index.js";
-import type { Changeset } from "./types.js";
-export declare function relevantRemovedRoots(change: Changeset, relevantRemovedRootsFromChild: RelevantRemovedRootsFromChild): Iterable<DeltaDetachedNodeId>;
-//# sourceMappingURL=relevantRemovedRoots.d.ts.map

package/dist/feature-libraries/sequence-field/relevantRemovedRoots.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"relevantRemovedRoots.d.ts","sourceRoot":"","sources":["../../../src/feature-libraries/sequence-field/relevantRemovedRoots.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,EAAE,KAAK,mBAAmB,EAAkB,MAAM,qBAAqB,CAAC;AAE/E,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,4BAA4B,CAAC;AAEhF,OAAO,KAAK,EAAE,SAAS,EAAQ,MAAM,YAAY,CAAC;AAGlD,wBAAiB,oBAAoB,CACpC,MAAM,EAAE,SAAS,EACjB,6BAA6B,EAAE,6BAA6B,GAC1D,QAAQ,CAAC,mBAAmB,CAAC,CAgB/B"}

package/dist/feature-libraries/sequence-field/relevantRemovedRoots.js

@@ -1,50 +0,0 @@
-"use strict";
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.relevantRemovedRoots = void 0;
-const internal_1 = require("@fluidframework/core-utils/internal");
-const index_js_1 = require("../../core/index.js");
-const deltaUtils_js_1 = require("../deltaUtils.js");
-const utils_js_1 = require("./utils.js");
-function* relevantRemovedRoots(change, relevantRemovedRootsFromChild) {
-    for (const mark of change) {
-        if (refersToRelevantRemovedRoots(mark)) {
-            (0, internal_1.assert)(mark.cellId !== undefined, 0x81d /* marks referring to removed trees must have an assigned cell ID */);
-            const nodeId = (0, deltaUtils_js_1.nodeIdFromChangeAtom)(mark.cellId);
-            for (let i = 0; i < mark.count; i += 1) {
-                yield (0, index_js_1.offsetDetachId)(nodeId, i);
-            }
-        }
-        if (mark.changes !== undefined) {
-            yield* relevantRemovedRootsFromChild(mark.changes);
-        }
-    }
-}
-exports.relevantRemovedRoots = relevantRemovedRoots;
-function refersToRelevantRemovedRoots(mark) {
-    if (mark.cellId !== undefined) {
-        const effect = (0, utils_js_1.isAttachAndDetachEffect)(mark) ? mark.attach : mark;
-        if ((0, utils_js_1.isInsert)(effect)) {
-            // This tree is being inserted or restored.
-            return true;
-        }
-        else if ((0, utils_js_1.isDetachOfRemovedNodes)(mark)) {
-            // This removed tree is being restored as part of a detach.
-            return true;
-        }
-        if (mark.changes !== undefined) {
-            // This removed tree is being edited.
-            // Note: there is a possibility that the child changes only affect a distant descendant
-            // which may have been removed from this (removed) subtree. In such a case, this tree is not truly
-            // relevant, but including it is the conservative thing to do.
-            // In the future, we may represent changes to removed trees using the ID of the lowest removed
-            // ancestor, which would allow us to avoid including such trees when they truly are not needed.
-            return true;
-        }
-    }
-    return false;
-}
-//# sourceMappingURL=relevantRemovedRoots.js.map

package/dist/feature-libraries/sequence-field/relevantRemovedRoots.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"relevantRemovedRoots.js","sourceRoot":"","sources":["../../../src/feature-libraries/sequence-field/relevantRemovedRoots.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,kEAA6D;AAE7D,kDAA+E;AAC/E,oDAAwD;AAIxD,yCAAuF;AAEvF,QAAe,CAAC,CAAC,oBAAoB,CACpC,MAAiB,EACjB,6BAA4D;IAE5D,KAAK,MAAM,IAAI,IAAI,MAAM,EAAE,CAAC;QAC3B,IAAI,4BAA4B,CAAC,IAAI,CAAC,EAAE,CAAC;YACxC,IAAA,iBAAM,EACL,IAAI,CAAC,MAAM,KAAK,SAAS,EACzB,KAAK,CAAC,oEAAoE,CAC1E,CAAC;YACF,MAAM,MAAM,GAAG,IAAA,oCAAoB,EAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YACjD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;gBACxC,MAAM,IAAA,yBAAc,EAAC,MAAM,EAAE,CAAC,CAAC,CAAC;YACjC,CAAC;QACF,CAAC;QACD,IAAI,IAAI,CAAC,OAAO,KAAK,SAAS,EAAE,CAAC;YAChC,KAAK,CAAC,CAAC,6BAA6B,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACpD,CAAC;IACF,CAAC;AACF,CAAC;AAnBD,oDAmBC;AAED,SAAS,4BAA4B,CAAC,IAAU;IAC/C,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;QAC/B,MAAM,MAAM,GAAG,IAAA,kCAAuB,EAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC;QAClE,IAAI,IAAA,mBAAQ,EAAC,MAAM,CAAC,EAAE,CAAC;YACtB,2CAA2C;YAC3C,OAAO,IAAI,CAAC;QACb,CAAC;aAAM,IAAI,IAAA,iCAAsB,EAAC,IAAI,CAAC,EAAE,CAAC;YACzC,2DAA2D;YAC3D,OAAO,IAAI,CAAC;QACb,CAAC;QACD,IAAI,IAAI,CAAC,OAAO,KAAK,SAAS,EAAE,CAAC;YAChC,qCAAqC;YACrC,uFAAuF;YACvF,kGAAkG;YAClG,8DAA8D;YAC9D,8FAA8F;YAC9F,+FAA+F;YAC/F,OAAO,IAAI,CAAC;QACb,CAAC;IACF,CAAC;IACD,OAAO,KAAK,CAAC;AACd,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { assert } from \"@fluidframework/core-utils/internal\";\n\nimport { type DeltaDetachedNodeId, offsetDetachId } from \"../../core/index.js\";\nimport { nodeIdFromChangeAtom } from \"../deltaUtils.js\";\nimport type { RelevantRemovedRootsFromChild } from \"../modular-schema/index.js\";\n\nimport type { Changeset, Mark } from \"./types.js\";\nimport { isAttachAndDetachEffect, isDetachOfRemovedNodes, isInsert } from \"./utils.js\";\n\nexport function* relevantRemovedRoots(\n\tchange: Changeset,\n\trelevantRemovedRootsFromChild: RelevantRemovedRootsFromChild,\n): Iterable<DeltaDetachedNodeId> {\n\tfor (const mark of change) {\n\t\tif (refersToRelevantRemovedRoots(mark)) {\n\t\t\tassert(\n\t\t\t\tmark.cellId !== undefined,\n\t\t\t\t0x81d /* marks referring to removed trees must have an assigned cell ID */,\n\t\t\t);\n\t\t\tconst nodeId = nodeIdFromChangeAtom(mark.cellId);\n\t\t\tfor (let i = 0; i < mark.count; i += 1) {\n\t\t\t\tyield offsetDetachId(nodeId, i);\n\t\t\t}\n\t\t}\n\t\tif (mark.changes !== undefined) {\n\t\t\tyield* relevantRemovedRootsFromChild(mark.changes);\n\t\t}\n\t}\n}\n\nfunction refersToRelevantRemovedRoots(mark: Mark): boolean {\n\tif (mark.cellId !== undefined) {\n\t\tconst effect = isAttachAndDetachEffect(mark) ? mark.attach : mark;\n\t\tif (isInsert(effect)) {\n\t\t\t// This tree is being inserted or restored.\n\t\t\treturn true;\n\t\t} else if (isDetachOfRemovedNodes(mark)) {\n\t\t\t// This removed tree is being restored as part of a detach.\n\t\t\treturn true;\n\t\t}\n\t\tif (mark.changes !== undefined) {\n\t\t\t// This removed tree is being edited.\n\t\t\t// Note: there is a possibility that the child changes only affect a distant descendant\n\t\t\t// which may have been removed from this (removed) subtree. In such a case, this tree is not truly\n\t\t\t// relevant, but including it is the conservative thing to do.\n\t\t\t// In the future, we may represent changes to removed trees using the ID of the lowest removed\n\t\t\t// ancestor, which would allow us to avoid including such trees when they truly are not needed.\n\t\t\treturn true;\n\t\t}\n\t}\n\treturn false;\n}\n"]}

package/docs/main/sequence-field/move-composition.md

@@ -1,46 +0,0 @@
-# Move Composition
-
-A move of a node in a sequence field is represented by a pair of marks:
-a MoveOut at the initial location of the node to be moved, and a MoveIn at the location the node will be moved to.
-Each of these move pairs is identified by a ChangeAtomId.
-
-For various reasons, we preserve the intermediate move steps when composing a series of moves of the same node.
-Note the cell IDs are changed at the intermediate locations, so it is necessary to record some information about the intermediate steps.
-The composition of move1, moving a node from A to B, with move2, moving the same node from B to C (where A, B, and C are distinct cells),
-is represented with MoveOut1 at A, MoveIn2 at C, and AttachAndDetach(MoveIn1, MoveOut2) at B.
-We say that the composite change in this example contains a single move chain which consists of move1 and move2 as its move atoms.
-Note that a move chain may have only a single move atom.
-Composition of move chains may lead to the creation of arbitrarily long move chains.
-
-To allow efficient processing a move chain without having to traverse all its elements,
-in a chain consisting of more than one atom each endpoint (the first MoveOut and last MoveIn of the chain)
-will have its `finalEndpoint` field set to the ID of the other endpoint.
-
-When composing a move chain which starts at A and ends at B with a move chain which starts at B and ends at C, we call cell B the pivot of the chains.
-Each of the chains will have a endpoint at B, which we call the inner endpoint. The other endpoint of each chain is called the outer endpoint.
-
-In the common case when composing chains we notice that the chains are moving the same node when we encounter the inner endpoints.
-Each inner endpoint stores the ID of the corresponding outer endpoint.
-We set `MoveEffect.endpoint` for each outer endpoint to be the other outer endpoint.
-When we encounter each outer endpoint we update its `finalEndpoint` to `MoveEffect.endpoint`,
-unless `MoveEffect.truncatedEndpoint` is also defined (see below), in which case we use that instead.
-
-A special case arises when the location outer endpoint of one of the move chains is the location of an intermediate move in the other move chain.
-For example, the first chain might consist of move1 from A to B, and the second chain consist of move2 from B to A and move3 from B to C.
-The endpoints of the composed move are at the locations of the outer endpoints (A and C) as usual,
-but the starting endpoint of the composed move will be the second chain's MoveOut (move3) at A instead of the first chain's outer endpoint at A (the MoveOut from move1).
-This follows from the rules for composing attach and detach marks at the same cell (A in this case).
-We can think of the composed move chain as truncating from `A -move1-> B -move2-> A -move3-> C` to `A -move3-> C`.
-We call the MoveOut from move3 the truncated endpoint and the MoveOut from move1 the redundant endpoint.
-We call the MoveIn from move3 the ordinary endpoint.
-
-We detect that we are in such a scenario when processing the location of the redundant and truncated endpoints.
-We set `MoveEffect.truncatedEndpointForInner` for the inner endpoint from the redundant move chain to the ID of the truncated endpoint.
-If we already know the ordinary endpoint (because we already processed the pivot and have `MoveEffect.endpoint` for the redundant endpoint)
-we also set `MoveEffect.truncatedEndpoint` for the ordinary endpoint.
-
-When processing the pivot, if `MoveEffect.truncatedEndpoint` is defined for an inner endpoint,
-we copy its value into `MoveEffect.truncatedEndpoint` for the corresponding outer endpoint (which will be the ordinary endpoint).
-
-Note that there are two places where we may set `truncatedEndpoint` on the ordinary endpoint.
-This is necessary for composition to complete with a single amend pass regardless of whether we happen to process the pivot or the truncation point first.

package/lib/feature-libraries/sequence-field/relevantRemovedRoots.d.ts

@@ -1,9 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import { type DeltaDetachedNodeId } from "../../core/index.js";
-import type { RelevantRemovedRootsFromChild } from "../modular-schema/index.js";
-import type { Changeset } from "./types.js";
-export declare function relevantRemovedRoots(change: Changeset, relevantRemovedRootsFromChild: RelevantRemovedRootsFromChild): Iterable<DeltaDetachedNodeId>;
-//# sourceMappingURL=relevantRemovedRoots.d.ts.map

package/lib/feature-libraries/sequence-field/relevantRemovedRoots.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"relevantRemovedRoots.d.ts","sourceRoot":"","sources":["../../../src/feature-libraries/sequence-field/relevantRemovedRoots.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,EAAE,KAAK,mBAAmB,EAAkB,MAAM,qBAAqB,CAAC;AAE/E,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,4BAA4B,CAAC;AAEhF,OAAO,KAAK,EAAE,SAAS,EAAQ,MAAM,YAAY,CAAC;AAGlD,wBAAiB,oBAAoB,CACpC,MAAM,EAAE,SAAS,EACjB,6BAA6B,EAAE,6BAA6B,GAC1D,QAAQ,CAAC,mBAAmB,CAAC,CAgB/B"}

package/lib/feature-libraries/sequence-field/relevantRemovedRoots.js

@@ -1,46 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import { assert } from "@fluidframework/core-utils/internal";
-import { offsetDetachId } from "../../core/index.js";
-import { nodeIdFromChangeAtom } from "../deltaUtils.js";
-import { isAttachAndDetachEffect, isDetachOfRemovedNodes, isInsert } from "./utils.js";
-export function* relevantRemovedRoots(change, relevantRemovedRootsFromChild) {
-    for (const mark of change) {
-        if (refersToRelevantRemovedRoots(mark)) {
-            assert(mark.cellId !== undefined, 0x81d /* marks referring to removed trees must have an assigned cell ID */);
-            const nodeId = nodeIdFromChangeAtom(mark.cellId);
-            for (let i = 0; i < mark.count; i += 1) {
-                yield offsetDetachId(nodeId, i);
-            }
-        }
-        if (mark.changes !== undefined) {
-            yield* relevantRemovedRootsFromChild(mark.changes);
-        }
-    }
-}
-function refersToRelevantRemovedRoots(mark) {
-    if (mark.cellId !== undefined) {
-        const effect = isAttachAndDetachEffect(mark) ? mark.attach : mark;
-        if (isInsert(effect)) {
-            // This tree is being inserted or restored.
-            return true;
-        }
-        else if (isDetachOfRemovedNodes(mark)) {
-            // This removed tree is being restored as part of a detach.
-            return true;
-        }
-        if (mark.changes !== undefined) {
-            // This removed tree is being edited.
-            // Note: there is a possibility that the child changes only affect a distant descendant
-            // which may have been removed from this (removed) subtree. In such a case, this tree is not truly
-            // relevant, but including it is the conservative thing to do.
-            // In the future, we may represent changes to removed trees using the ID of the lowest removed
-            // ancestor, which would allow us to avoid including such trees when they truly are not needed.
-            return true;
-        }
-    }
-    return false;
-}
-//# sourceMappingURL=relevantRemovedRoots.js.map

package/lib/feature-libraries/sequence-field/relevantRemovedRoots.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"relevantRemovedRoots.js","sourceRoot":"","sources":["../../../src/feature-libraries/sequence-field/relevantRemovedRoots.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,qCAAqC,CAAC;AAE7D,OAAO,EAA4B,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC/E,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAIxD,OAAO,EAAE,uBAAuB,EAAE,sBAAsB,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEvF,MAAM,SAAS,CAAC,CAAC,oBAAoB,CACpC,MAAiB,EACjB,6BAA4D;IAE5D,KAAK,MAAM,IAAI,IAAI,MAAM,EAAE,CAAC;QAC3B,IAAI,4BAA4B,CAAC,IAAI,CAAC,EAAE,CAAC;YACxC,MAAM,CACL,IAAI,CAAC,MAAM,KAAK,SAAS,EACzB,KAAK,CAAC,oEAAoE,CAC1E,CAAC;YACF,MAAM,MAAM,GAAG,oBAAoB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YACjD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;gBACxC,MAAM,cAAc,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;YACjC,CAAC;QACF,CAAC;QACD,IAAI,IAAI,CAAC,OAAO,KAAK,SAAS,EAAE,CAAC;YAChC,KAAK,CAAC,CAAC,6BAA6B,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACpD,CAAC;IACF,CAAC;AACF,CAAC;AAED,SAAS,4BAA4B,CAAC,IAAU;IAC/C,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;QAC/B,MAAM,MAAM,GAAG,uBAAuB,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC;QAClE,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;YACtB,2CAA2C;YAC3C,OAAO,IAAI,CAAC;QACb,CAAC;aAAM,IAAI,sBAAsB,CAAC,IAAI,CAAC,EAAE,CAAC;YACzC,2DAA2D;YAC3D,OAAO,IAAI,CAAC;QACb,CAAC;QACD,IAAI,IAAI,CAAC,OAAO,KAAK,SAAS,EAAE,CAAC;YAChC,qCAAqC;YACrC,uFAAuF;YACvF,kGAAkG;YAClG,8DAA8D;YAC9D,8FAA8F;YAC9F,+FAA+F;YAC/F,OAAO,IAAI,CAAC;QACb,CAAC;IACF,CAAC;IACD,OAAO,KAAK,CAAC;AACd,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { assert } from \"@fluidframework/core-utils/internal\";\n\nimport { type DeltaDetachedNodeId, offsetDetachId } from \"../../core/index.js\";\nimport { nodeIdFromChangeAtom } from \"../deltaUtils.js\";\nimport type { RelevantRemovedRootsFromChild } from \"../modular-schema/index.js\";\n\nimport type { Changeset, Mark } from \"./types.js\";\nimport { isAttachAndDetachEffect, isDetachOfRemovedNodes, isInsert } from \"./utils.js\";\n\nexport function* relevantRemovedRoots(\n\tchange: Changeset,\n\trelevantRemovedRootsFromChild: RelevantRemovedRootsFromChild,\n): Iterable<DeltaDetachedNodeId> {\n\tfor (const mark of change) {\n\t\tif (refersToRelevantRemovedRoots(mark)) {\n\t\t\tassert(\n\t\t\t\tmark.cellId !== undefined,\n\t\t\t\t0x81d /* marks referring to removed trees must have an assigned cell ID */,\n\t\t\t);\n\t\t\tconst nodeId = nodeIdFromChangeAtom(mark.cellId);\n\t\t\tfor (let i = 0; i < mark.count; i += 1) {\n\t\t\t\tyield offsetDetachId(nodeId, i);\n\t\t\t}\n\t\t}\n\t\tif (mark.changes !== undefined) {\n\t\t\tyield* relevantRemovedRootsFromChild(mark.changes);\n\t\t}\n\t}\n}\n\nfunction refersToRelevantRemovedRoots(mark: Mark): boolean {\n\tif (mark.cellId !== undefined) {\n\t\tconst effect = isAttachAndDetachEffect(mark) ? mark.attach : mark;\n\t\tif (isInsert(effect)) {\n\t\t\t// This tree is being inserted or restored.\n\t\t\treturn true;\n\t\t} else if (isDetachOfRemovedNodes(mark)) {\n\t\t\t// This removed tree is being restored as part of a detach.\n\t\t\treturn true;\n\t\t}\n\t\tif (mark.changes !== undefined) {\n\t\t\t// This removed tree is being edited.\n\t\t\t// Note: there is a possibility that the child changes only affect a distant descendant\n\t\t\t// which may have been removed from this (removed) subtree. In such a case, this tree is not truly\n\t\t\t// relevant, but including it is the conservative thing to do.\n\t\t\t// In the future, we may represent changes to removed trees using the ID of the lowest removed\n\t\t\t// ancestor, which would allow us to avoid including such trees when they truly are not needed.\n\t\t\treturn true;\n\t\t}\n\t}\n\treturn false;\n}\n"]}

package/src/feature-libraries/sequence-field/relevantRemovedRoots.ts

@@ -1,57 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-
-import { assert } from "@fluidframework/core-utils/internal";
-
-import { type DeltaDetachedNodeId, offsetDetachId } from "../../core/index.js";
-import { nodeIdFromChangeAtom } from "../deltaUtils.js";
-import type { RelevantRemovedRootsFromChild } from "../modular-schema/index.js";
-
-import type { Changeset, Mark } from "./types.js";
-import { isAttachAndDetachEffect, isDetachOfRemovedNodes, isInsert } from "./utils.js";
-
-export function* relevantRemovedRoots(
-	change: Changeset,
-	relevantRemovedRootsFromChild: RelevantRemovedRootsFromChild,
-): Iterable<DeltaDetachedNodeId> {
-	for (const mark of change) {
-		if (refersToRelevantRemovedRoots(mark)) {
-			assert(
-				mark.cellId !== undefined,
-				0x81d /* marks referring to removed trees must have an assigned cell ID */,
-			);
-			const nodeId = nodeIdFromChangeAtom(mark.cellId);
-			for (let i = 0; i < mark.count; i += 1) {
-				yield offsetDetachId(nodeId, i);
-			}
-		}
-		if (mark.changes !== undefined) {
-			yield* relevantRemovedRootsFromChild(mark.changes);
-		}
-	}
-}
-
-function refersToRelevantRemovedRoots(mark: Mark): boolean {
-	if (mark.cellId !== undefined) {
-		const effect = isAttachAndDetachEffect(mark) ? mark.attach : mark;
-		if (isInsert(effect)) {
-			// This tree is being inserted or restored.
-			return true;
-		} else if (isDetachOfRemovedNodes(mark)) {
-			// This removed tree is being restored as part of a detach.
-			return true;
-		}
-		if (mark.changes !== undefined) {
-			// This removed tree is being edited.
-			// Note: there is a possibility that the child changes only affect a distant descendant
-			// which may have been removed from this (removed) subtree. In such a case, this tree is not truly
-			// relevant, but including it is the conservative thing to do.
-			// In the future, we may represent changes to removed trees using the ID of the lowest removed
-			// ancestor, which would allow us to avoid including such trees when they truly are not needed.
-			return true;
-		}
-	}
-	return false;
-}