@fluidframework/tree 2.11.0 → 2.13.0

package/src/util/rangeMap.ts

@@ -6,229 +6,239 @@
 import { oob } from "@fluidframework/core-utils/internal";
 
 /**
- * A map keyed on integers allowing reading and writing contiguous ranges of integer keys.
- *
- * TODO: We should avoid the direct exposure of RangeEntry. AB#7414
+ * RangeMap represents a mapping from integers to values of type T or undefined.
+ * The values for a range of consecutive keys can be changed or queried in a single operation.
  */
-export type RangeMap<T> = RangeEntry<T>[];
+export class RangeMap<T> {
+	private readonly entries: RangeEntry<T>[];
 
-export interface RangeEntry<T> {
-	start: number;
-	length: number;
-	value: T;
-}
+	public constructor(initialEntries?: RangeEntry<T>[]) {
+		this.entries = initialEntries ? [...initialEntries] : [];
+	}
 
-/**
- * The result of a query about a range of keys.
- */
-export interface RangeQueryResult<T> {
 	/**
-	 * The value of the first key in the query range.
+	 * Retrieves all entries from the rangeMap.
+	 * @returns An array of RangeEntryResult objects, each containing the start index, length, and value of a contiguous range.
 	 */
-	value: T | undefined;
+	public getAllEntries(): readonly RangeQueryResult<T>[] {
+		return this.entries;
+	}
 
 	/**
-	 * The length of the prefix of the query range which have the same value.
-	 * For example, if a RangeMap has the same value for keys 5, 6, and 7,
-	 * a query about the range [5, 10] would give a result with length 3.
+	 * Retrieves the value for some prefix of the query range.
+	 *
+	 * @param start - The first key in the query range.
+	 * @param length - The length of the query range.
+	 * @returns A RangeQueryResult containing the value associated with `start`,
+	 * and the number of consecutive keys with that same value.
 	 */
-	length: number;
-}
+	public get(start: number, length: number): RangeQueryResult<T> {
+		for (const entry of this.entries) {
+			if (entry.start > start) {
+				return { value: undefined, length: Math.min(entry.start - start, length) };
+			}
 
-/**
- * See comments on `RangeQueryResult`.
- */
-export function getFromRangeMap<T>(
-	map: RangeMap<T>,
-	start: number,
-	length: number,
-): RangeQueryResult<T> {
-	for (const range of map) {
-		if (range.start > start) {
-			return { value: undefined, length: Math.min(range.start - start, length) };
+			const lastRangeKey = entry.start + entry.length - 1;
+			if (lastRangeKey >= start) {
+				const overlapLength = lastRangeKey - start + 1;
+				return { value: entry.value, length: Math.min(overlapLength, length) };
+			}
 		}
 
-		const lastRangeKey = range.start + range.length - 1;
-		if (lastRangeKey >= start) {
-			// This range contains `start`.
-			const overlapLength = lastRangeKey - start + 1;
-			return { value: range.value, length: Math.min(overlapLength, length) };
-		}
+		// There were no entries intersecting the query range, so the entire query range has undefined value.
+		return { value: undefined, length };
 	}
 
-	// There were no entries intersecting the query range, so the entire query range has undefined value.
-	return { value: undefined, length };
-}
+	/**
+	 * Sets the value for a specified range.
+	 *
+	 * @param start - The first key in the range being set.
+	 * @param length - The length of the range.
+	 * @param value - The value to associate with the range.
+	 */
+	public set(start: number, length: number, value: T | undefined): void {
+		if (value === undefined) {
+			this.delete(start, length);
+			return;
+		}
 
-export function getFirstEntryFromRangeMap<T>(
-	map: RangeMap<T>,
-	start: number,
-	length: number,
-): RangeEntry<T> | undefined {
-	const lastQueryKey = start + length - 1;
-	for (const range of map) {
-		if (range.start > lastQueryKey) {
-			// We've passed the end of the query range.
-			break;
+		const end = start + length - 1;
+		const newEntry: RangeEntry<T> = { start, length, value };
+
+		let iBefore = -1;
+		let iAfter = this.entries.length;
+		for (const [i, entry] of this.entries.entries()) {
+			const entryLastKey = entry.start + entry.length - 1;
+			if (entryLastKey < start) {
+				iBefore = i;
+			} else if (entry.start > end) {
+				iAfter = i;
+				break;
+			}
 		}
 
-		const lastRangeKey = range.start + range.length - 1;
-		if (lastRangeKey >= start) {
-			return range;
+		const numOverlappingEntries = iAfter - iBefore - 1;
+		if (numOverlappingEntries === 0) {
+			this.entries.splice(iAfter, 0, newEntry);
+			return;
 		}
-	}
 
-	return undefined;
-}
+		const iFirst = iBefore + 1;
+		const firstEntry = this.entries[iFirst] ?? oob();
+		const iLast = iAfter - 1;
+		const lastEntry = this.entries[iLast] ?? oob();
+		const lengthBeforeFirst = start - firstEntry.start;
+		const lastEntryKey = lastEntry.start + lastEntry.length - 1;
+		const lengthAfterLast = lastEntryKey - end;
+
+		if (lengthBeforeFirst > 0 && lengthAfterLast > 0 && iFirst === iLast) {
+			// The new entry fits in the middle of an existing entry.
+			// We replace the existing entry with:
+			// 1) the portion which comes before `newEntry`
+			// 2) `newEntry`
+			// 3) the portion which comes after `newEntry`
+			this.entries.splice(iFirst, 1, { ...firstEntry, length: lengthBeforeFirst }, newEntry, {
+				...lastEntry,
+				start: end + 1,
+				length: lengthAfterLast,
+			});
+			return;
+		}
 
-/**
- * Sets the keys from `start` to `start + length - 1` to `value`.
- */
-export function setInRangeMap<T>(
-	map: RangeMap<T>,
-	start: number,
-	length: number,
-	value: T,
-): void {
-	const end = start + length - 1;
-	const newEntry: RangeEntry<T> = { start, length, value };
-
-	let iBefore = -1;
-	let iAfter = map.length;
-	for (const [i, entry] of map.entries()) {
-		const entryLastKey = entry.start + entry.length - 1;
-		if (entryLastKey < start) {
-			iBefore = i;
-		} else if (entry.start > end) {
-			iAfter = i;
-			break;
+		if (lengthBeforeFirst > 0) {
+			this.entries[iFirst] = { ...firstEntry, length: lengthBeforeFirst };
+			// The entry at `iFirst` is no longer overlapping with `newEntry`.
+			iBefore = iFirst;
 		}
-	}
 
-	const numOverlappingEntries = iAfter - iBefore - 1;
-	if (numOverlappingEntries === 0) {
-		map.splice(iAfter, 0, newEntry);
-		return;
-	}
+		if (lengthAfterLast > 0) {
+			this.entries[iLast] = {
+				...lastEntry,
+				start: end + 1,
+				length: lengthAfterLast,
+			};
 
-	const iFirst = iBefore + 1;
-	const firstEntry = map[iFirst] ?? oob();
-	const iLast = iAfter - 1;
-	const lastEntry = map[iLast] ?? oob();
-	const lengthBeforeFirst = start - firstEntry.start;
-	const lastEntryKey = lastEntry.start + lastEntry.length - 1;
-	const lengthAfterLast = lastEntryKey - end;
-
-	if (lengthBeforeFirst > 0 && lengthAfterLast > 0 && iFirst === iLast) {
-		// The new entry fits in the middle of an existing entry.
-		// We replace the existing entry with:
-		// 1) the portion which comes before `newEntry`
-		// 2) `newEntry`
-		// 3) the portion which comes after `newEntry`
-		map.splice(iFirst, 1, { ...firstEntry, length: lengthBeforeFirst }, newEntry, {
-			...lastEntry,
-			start: end + 1,
-			length: lengthAfterLast,
-		});
-		return;
+			// The entry at `iLast` is no longer overlapping with `newEntry`.
+			iAfter = iLast;
+		}
+
+		const numContainedEntries = iAfter - iBefore - 1;
+		this.entries.splice(iBefore + 1, numContainedEntries, newEntry);
 	}
 
-	if (lengthBeforeFirst > 0) {
-		map[iFirst] = { ...firstEntry, length: lengthBeforeFirst };
+	/**
+	 * Deletes values within a specified range, updating or removing existing entries.
+	 *
+	 * 1. If an entry is completely included in the deletion range, the whole entry will be deleted
+	 * e.g.: map = [[1, 2], [4, 6]], delete range: [3, 6]
+	 * map becomes [[1, 2]] after deletion
+	 * (Note: the notation [a, b] represents start = a, end = b for simpler visualization, instead of `b`
+	 * representing the length)
+	 *
+	 * 2. If an entry is partially overlapped with the deletion range, the start or end point will be shifted
+	 * e.g.: map = [[1, 2], [4, 6]], delete range: [2, 4]
+	 * map becomes [[1, 1], [5, 6]] after deletion
+	 *
+	 * 3. If an entry completely includes the deletion range, the original entry may be split into two.
+	 * e.g.: map = [[1, 6]], delete range: [2, 4]
+	 * map becomes [[1, 1], [5, 6]]
+	 *
+	 * @param start - The start of the range to delete (inclusive).
+	 * @param length - The length of the range to delete.
+	 */
+	public delete(start: number, length: number): void {
+		const end = start + length - 1;
+
+		let iBefore = -1;
+		let iAfter = this.entries.length;
+
+		for (const [i, entry] of this.entries.entries()) {
+			const entryLastKey = entry.start + entry.length - 1;
+			if (entryLastKey < start) {
+				iBefore = i;
+			} else if (entry.start > end) {
+				iAfter = i;
+				break;
+			}
+		}
 
-		// The entry at `iFirst` is no longer overlapping with `newEntry`.
-		iBefore = iFirst;
-	}
+		const numOverlappingEntries = iAfter - iBefore - 1;
 
-	if (lengthAfterLast > 0) {
-		map[iLast] = {
-			...lastEntry,
-			start: end + 1,
-			length: lengthAfterLast,
-		};
+		if (numOverlappingEntries === 0) {
+			// No entry will be removed
+			return;
+		}
 
-		// The entry at `iLast` is no longer overlapping with `newEntry`.
-		iAfter = iLast;
+		const iFirst = iBefore + 1;
+		const iLast = iAfter - 1;
+
+		for (let i = iFirst; i <= iLast; ++i) {
+			const entry = this.entries[i] ?? oob();
+			const entryLastKey = entry.start + entry.length - 1;
+			let isDirty = false;
+
+			if (entry.start >= start && entryLastKey <= end) {
+				// If the entry lies within the range to be deleted, remove it
+				this.entries.splice(i, 1);
+			} else {
+				// If the entry partially or completely overlaps with the range to be deleted
+				if (entry.start < start) {
+					// Update the endpoint and length of the portion before the range to be deleted
+					const lengthBefore = start - entry.start;
+					this.entries[i] = { ...entry, length: lengthBefore };
+					isDirty = true;
+				}
+
+				if (entryLastKey > end) {
+					// Update the startpoint and length of the portion after the range to be deleted
+					const newStart = end + 1;
+					const newLength = entryLastKey - end;
+					this.entries.splice(isDirty ? i + 1 : i, isDirty ? 0 : 1, {
+						start: newStart,
+						length: newLength,
+						value: entry.value,
+					});
+				}
+			}
+		}
 	}
-
-	const numContainedEntries = iAfter - iBefore - 1;
-	map.splice(iBefore + 1, numContainedEntries, newEntry);
 }
 
 /**
- * Delete the keys from `start` to `start + length - 1`
- *
- * 1. If an entry is completely included in the deletion range, the whole entry will be deleted
- * e.g.: map = [[1, 2], [4, 6]], delete range: [3, 6]
- * map becomes [[1, 2]] after deletion
- * (Note: the notation [a, b] represents start = a, end = b for simpler visiualization, instead of `b`
- * representing the length)
- *
- * 2. If an entry is partially overlapped with the deletion range, the start or end point will be shifted
- * e.g.: map = [[1, 2], [4, 6]], delete range: [2, 4]
- * map becomes [[1, 1], [5, 6]] after deletion
- *
- * 3. If an entry completely includes the deletion range, the original entry may be split into two.
- * e.g.: map = [[1, 6]], delete range: [2, 4]
- * map becomes [[1, 1], [5, 6]]
- *
- * TODO: We may find ways to mitigate the code duplication between set and delete, and we need to better
- * document the API.  AB#7413
+ * Represents a contiguous range of values in the RangeMap.
+ * This interface is used internally and should not be exposed to consumers.
  */
-export function deleteFromRangeMap<T>(map: RangeMap<T>, start: number, length: number): void {
-	const end = start + length - 1;
-
-	let iBefore = -1;
-	let iAfter = map.length;
-
-	for (const [i, entry] of map.entries()) {
-		const entryLastKey = entry.start + entry.length - 1;
-		if (entryLastKey < start) {
-			iBefore = i;
-		} else if (entry.start > end) {
-			iAfter = i;
-			break;
-		}
-	}
+interface RangeEntry<T> {
+	/**
+	 * The starting index of the range (inclusive).
+	 */
+	readonly start: number;
 
-	const numOverlappingEntries = iAfter - iBefore - 1;
+	/**
+	 * The length of the range.
+	 */
+	readonly length: number;
 
-	if (numOverlappingEntries === 0) {
-		// No entry will be removed
-		return;
-	}
+	/**
+	 * The value associated with this range.
+	 */
+	readonly value: T;
+}
 
-	const iFirst = iBefore + 1;
-	const iLast = iAfter - 1;
-
-	// Update or remove the overlapping entries
-	for (let i = iFirst; i <= iLast; ++i) {
-		const entry = map[i] ?? oob();
-		const entryLastKey = entry.start + entry.length - 1;
-		let isDirty = false;
-
-		// If the entry lies within the range to be deleted, remove it
-		if (entry.start >= start && entryLastKey <= end) {
-			map.splice(i, 1);
-		} else {
-			// If the entry partially or completely overlaps with the range to be deleted
-			if (entry.start < start) {
-				// Update the endpoint and length of the portion before the range to be deleted
-				const lengthBefore = start - entry.start;
-				map[i] = { ...entry, length: lengthBefore };
-				isDirty = true;
-			}
+/**
+ * Describes the result of a range query, including the value and length of the matching prefix.
+ */
+export interface RangeQueryResult<T> {
+	/**
+	 * The value of the first key in the query range.
+	 * If no matching range is found, this will be undefined.
+	 */
+	readonly value: T | undefined;
 
-			if (entryLastKey > end) {
-				// Update the startpoint and length of the portion after the range to be deleted
-				const newStart = end + 1;
-				const newLength = entryLastKey - end;
-				map.splice(isDirty ? i + 1 : i, isDirty ? 0 : 1, {
-					start: newStart,
-					length: newLength,
-					value: entry.value,
-				});
-			}
-		}
-	}
+	/**
+	 * The length of the prefix of the query range which has the same value.
+	 * For example, if a RangeMap has the same value for keys 5, 6, and 7,
+	 * a query about the range [5, 10] would give a result with length 3.
+	 */
+	readonly length: number;
 }

package/src/util/typeCheck.ts

@@ -107,8 +107,6 @@ export interface Contravariant<in T> {
  * ```typescript
  * protected _typeCheck?: Covariant<T>;
  * ```
- *
- * @internal
  */
 export interface Covariant<out T> {
 	_removeContravariance?: T;

package/src/util/utils.ts

@@ -16,7 +16,7 @@ export interface MapGetSet<K, V> {
 }
 
 /**
- * Make all transitive properties in T readonly
+ * Make all transitive properties in `T` readonly
  */
 export type RecursiveReadonly<T> = {
 	readonly [P in keyof T]: RecursiveReadonly<T[P]>;
@@ -537,3 +537,75 @@ export function capitalize<S extends string>(s: S): Capitalize<S> {
 export function compareStrings<T extends string>(a: T, b: T): number {
 	return a > b ? 1 : a === b ? 0 : -1;
 }
+
+/**
+ * Defines a property on an object that is lazily initialized and cached.
+ * @remarks This is useful for properties that are expensive to compute and it is not guaranteed that they will be accessed.
+ * This function initially defines a getter on the object, but after first read it replaces the getter with a value property.
+ * @param obj - The object on which to define the property.
+ * @param key - The key of the property to define.
+ * @param get - The function (called either once or not at all) to compute the value of the property.
+ * @returns `obj`, typed such that it has the new property.
+ * This allows for the new property to be read off of `obj` in a type-safe manner after calling this function.
+ */
+export function defineLazyCachedProperty<
+	T extends object,
+	K extends string | number | symbol,
+	V,
+>(obj: T, key: K, get: () => V): typeof obj & { [P in K]: V } {
+	Reflect.defineProperty(obj, key, {
+		get() {
+			const value = get();
+			Reflect.defineProperty(obj, key, { value });
+			return value;
+		},
+		configurable: true,
+	});
+	return obj as typeof obj & { [P in K]: V };
+}
+
+/**
+ * Copies a given property from one object to another if and only if the property is defined.
+ * @param source - The object to copy the property from.
+ * If `source` is undefined or does not have the property defined, then this function will do nothing.
+ * @param property - The property to copy.
+ * @param destination - The object to copy the property to.
+ * @remarks This function is useful for copying properties from one object to another while minimizing the presence of `undefined` values.
+ * If `property` is not present on `source` - or if `property` is present, but has a value of `undefined` - then this function will not modify `destination`.
+ * This is different from doing `destination.foo = source.foo`, which would define a `"foo"` property on `destination` with the value `undefined`.
+ *
+ * If the type of `source` is known to have `property`, then this function asserts that the type of `destination` has `property` as well after the call.
+ *
+ * This function first reads the property value (if present) from `source` and then sets it on `destination`, as opposed to e.g. directly copying the property descriptor.
+ * @privateRemarks The first overload of this function allows auto-complete to suggest property names from `source`, but by having the second overload we still allow for arbitrary property names.
+ */
+export function copyPropertyIfDefined<S extends object, K extends keyof S, D extends object>(
+	source: S | undefined,
+	property: K,
+	destination: D,
+): asserts destination is K extends keyof S ? D & { [P in K]: S[K] } : D;
+export function copyPropertyIfDefined<
+	S extends object,
+	K extends string | number | symbol,
+	D extends object,
+>(
+	source: S | undefined,
+	property: K,
+	destination: D,
+): asserts destination is K extends keyof S ? D & { [P in K]: S[K] } : D;
+export function copyPropertyIfDefined<
+	S extends object,
+	K extends string | number | symbol,
+	D extends object,
+>(
+	source: S | undefined,
+	property: K,
+	destination: D,
+): asserts destination is K extends keyof S ? D & { [P in K]: S[K] } : D {
+	if (source !== undefined) {
+		const value = (source as { [P in K]?: unknown })[property];
+		if (value !== undefined) {
+			(destination as { [P in K]: unknown })[property] = value;
+		}
+	}
+}

package/dist/feature-libraries/chunked-forest/chunk.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chunk.d.ts","sourceRoot":"","sources":["../../../src/feature-libraries/chunked-forest/chunk.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,EAEN,KAAK,QAAQ,EACb,KAAK,WAAW,EAChB,KAAK,sBAAsB,EAE3B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5D;;;;GAIG;AACH,MAAM,WAAW,SAAU,SAAQ,gBAAgB;IAClD;;;;OAIG;IACH,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAEhC;;;;;;;;;;OAUG;IACH,MAAM,IAAI,aAAa,CAAC;CACxB;AAED;;;;GAIG;AACH,eAAO,MAAM,SAAS,EAAE,QAAuB,CAAC;AAEhD;;GAEG;AACH,eAAO,MAAM,WAAW,EAAE,OAAO,MAA8B,CAAC;AAEhE;;GAEG;AACH,UAAU,SAAS;IAClB;;;;;;;;;;;;;;;;;OAiBG;IACH,QAAQ,CAAC,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,GAAG,SAAS,CAAC;CAC/C;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,WAAW,GAAG,SAAS,GAAG,SAAS,CAMtE;AAED;;;;GAIG;AACH,MAAM,WAAW,aAAc,SAAQ,sBAAsB,EAAE,SAAS;IACvE;;;;OAIG;IACH,WAAW,IAAI,OAAO,CAAC;IAEvB;;;OAGG;IACH,IAAI,IAAI,aAAa,CAAC;CACtB"}

package/dist/feature-libraries/chunked-forest/chunk.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"chunk.js","sourceRoot":"","sources":["../../../src/feature-libraries/chunked-forest/chunk.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,kEAA6D;AAE7D,kDAM6B;AA8B7B;;;;GAIG;AACU,QAAA,SAAS,GAAa,uBAAY,CAAC;AAEhD;;GAEG;AACU,QAAA,WAAW,GAAkB,MAAM,CAAC,aAAa,CAAC,CAAC;AA2BhE;;GAEG;AACH,SAAgB,WAAW,CAAC,MAAmB;IAC9C,IAAA,iBAAM,EACL,MAAM,CAAC,IAAI,qCAA6B,EACxC,KAAK,CAAC,+CAA+C,CACrD,CAAC;IACF,OAAQ,MAAoB,CAAC,mBAAW,CAAC,CAAC;AAC3C,CAAC;AAND,kCAMC","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 {\n\tCursorLocationType,\n\ttype FieldKey,\n\ttype ITreeCursor,\n\ttype ITreeCursorSynchronous,\n\trootFieldKey,\n} from \"../../core/index.js\";\nimport type { ReferenceCounted } from \"../../util/index.js\";\n\n/**\n * Contiguous part of the tree which get stored together in some data format.\n * Copy-on-write, but optimized to be mutated in place when a chunk only has a single user (detected using reference counting).\n * This allows for efficient cloning without major performance overheads for non-cloning scenarios.\n */\nexport interface TreeChunk extends ReferenceCounted {\n\t/**\n\t * The number of nodes at the top level of this chunk.\n\t *\n\t * If this chunk is included in a field, this is the amount this chunk contributes to the length of the field.\n\t */\n\treadonly topLevelLength: number;\n\n\t/**\n\t * Creates a cursor for navigating the content of this chunk.\n\t *\n\t * Starts in \"fields\" mode in a `dummyRoot` field containing the top level nodes.\n\t *\n\t * This cursor does not own a reference to the data:\n\t * it is up to the caller of this function to ensure the cursor is not used after they release their owning ref to this chunk.\n\t *\n\t * TODO: consider starting this in \"fields\" mode above the top level\n\t * which would compose better with utilities for processing sequences of nodes.\n\t */\n\tcursor(): ChunkedCursor;\n}\n\n/**\n * The key used for the field that contains the root of chunks when not parented anywhere.\n *\n * For now this is using the document root key to ease testing/compatibility, but this may change.\n */\nexport const dummyRoot: FieldKey = rootFieldKey;\n\n/**\n * A symbol for extracting a TreeChunk from {@link ITreeCursor}.\n */\nexport const cursorChunk: unique symbol = Symbol(\"cursorChunk\");\n\n/**\n * Cursors can optionally implement this interface, allowing querying them for the chunk they are traversing.\n */\ninterface WithChunk {\n\t/**\n\t * When in nodes mode, if a value is returned, it is a TreeChunk who's top level nodes are the\n\t * chunkLength nodes starting from chunkStart.\n\t *\n\t *\n\t * @remarks\n\t * Note that there may be other tree representations with different chunk APIs and thus different ways to query them.\n\t * The chunkStart and chunkLength values thus to not uniquely apply to the chunks accessed through this field.\n\t *\n\t * TODO:\n\t * This API (including the chunk start and end on ITreeCUrsor) have some issues:\n\t * 1. There are cases where multiple possible chunks could be considered.\n\t * For example, when in a SequenceChunk, it could be returned, or the chunk within it could be.\n\t * 2. When in a location other than the root of a chunk,\n\t * it can't provide information about the containing chunk other than by allocating a new chunk that just represents that field.\n\t *\n\t * As more optimizations get implemented, this API may need to change to better address these issues.\n\t */\n\treadonly [cursorChunk]?: TreeChunk | undefined;\n}\n\n/**\n * See {@link WithChunk}.\n */\nexport function tryGetChunk(cursor: ITreeCursor): undefined | TreeChunk {\n\tassert(\n\t\tcursor.mode === CursorLocationType.Nodes,\n\t\t0x57b /* cursorChunk only accessible in nodes mode */,\n\t);\n\treturn (cursor as WithChunk)[cursorChunk];\n}\n\n/**\n * Cursor for a chunk which can be wrapped by another cursor.\n *\n * @remarks See `BasicChunkCursor` which uses this.\n */\nexport interface ChunkedCursor extends ITreeCursorSynchronous, WithChunk {\n\t/**\n\t * Checks if the cursor is in the top level nodes of the chunk.\n\t *\n\t * @returns true iff cursor is within the root field, including at a node within that field.\n\t */\n\tatChunkRoot(): boolean;\n\n\t/**\n\t * Clones the cursor to produce a new independent cursor.\n\t * Does not add any counted references to any chunks.\n\t */\n\tfork(): ChunkedCursor;\n}\n"]}

package/dist/feature-libraries/memoizedIdRangeAllocator.d.ts

@@ -1,38 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import type { ChangesetLocalId, RevisionTag } from "../core/index.js";
-/**
- * A unique ID allocator that returns the output ID for the same input ID.
- */
-export interface MemoizedIdRangeAllocator {
-    /**
-     * A unique ID allocator that returns the output ID for the same input ID.
-     *
-     * "The same" here includes cases where a prior call allocated a range of IDs that partially or fully overlap with the
-     * current call.
-     * @param revision - The revision associated with the range of IDs to allocate.
-     * @param startId - The first ID to allocate.
-     * @param count - The number of IDs to allocate. Interpreted as 1 if undefined.
-     */
-    allocate(revision: RevisionTag | undefined, startId: ChangesetLocalId, count?: number): IdRange[];
-    /**
-     * Allocates a new range of IDs.
-     *
-     * @param count - The number of IDs to allocate. Interpreted as 1 if undefined.
-     */
-    mint(count?: number): ChangesetLocalId;
-}
-/**
- */
-export interface IdRange {
-    readonly first: ChangesetLocalId;
-    readonly count: number;
-}
-/**
- */
-export declare const MemoizedIdRangeAllocator: {
-    fromNextId(nextId?: number): MemoizedIdRangeAllocator;
-};
-//# sourceMappingURL=memoizedIdRangeAllocator.d.ts.map

package/dist/feature-libraries/memoizedIdRangeAllocator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"memoizedIdRangeAllocator.d.ts","sourceRoot":"","sources":["../../src/feature-libraries/memoizedIdRangeAllocator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAUtE;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACxC;;;;;;;;OAQG;IACH,QAAQ,CACP,QAAQ,EAAE,WAAW,GAAG,SAAS,EACjC,OAAO,EAAE,gBAAgB,EACzB,KAAK,CAAC,EAAE,MAAM,GACZ,OAAO,EAAE,CAAC;IACb;;;;OAIG;IACH,IAAI,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,gBAAgB,CAAC;CACvC;AAED;GACG;AACH,MAAM,WAAW,OAAO;IACvB,QAAQ,CAAC,KAAK,EAAE,gBAAgB,CAAC;IACjC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACvB;AAED;GACG;AACH,eAAO,MAAM,wBAAwB;wBACjB,MAAM,GAAO,wBAAwB;CA4DxD,CAAC"}

package/dist/feature-libraries/memoizedIdRangeAllocator.js

@@ -1,74 +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.MemoizedIdRangeAllocator = void 0;
-const index_js_1 = require("../util/index.js");
-/**
- */
-exports.MemoizedIdRangeAllocator = {
-    fromNextId(nextId = 0) {
-        const rangeMap = new Map();
-        let _nextId = nextId;
-        return {
-            allocate(key, startId, length) {
-                let count = length ?? 1;
-                const out = [];
-                const ranges = (0, index_js_1.getOrAddEmptyToMap)(rangeMap, key);
-                let currId = startId;
-                while (count > 0) {
-                    const firstRange = (0, index_js_1.getFirstEntryFromRangeMap)(ranges, currId, count);
-                    if (firstRange === undefined) {
-                        const newId = _nextId;
-                        _nextId += count;
-                        (0, index_js_1.setInRangeMap)(ranges, currId, count, newId);
-                        out.push({ first: (0, index_js_1.brand)(newId), count });
-                        count = 0;
-                    }
-                    else {
-                        const idRange = {
-                            first: (0, index_js_1.brand)(firstRange.value),
-                            count: firstRange.length,
-                        };
-                        if (currId < firstRange.start) {
-                            const countToAdd = firstRange.start - currId;
-                            (0, index_js_1.setInRangeMap)(ranges, currId, countToAdd, _nextId);
-                            out.push({ first: (0, index_js_1.brand)(_nextId), count: countToAdd });
-                            _nextId += countToAdd;
-                            currId += countToAdd;
-                            count -= countToAdd;
-                        }
-                        else if (firstRange.start < currId) {
-                            const countToTrim = currId - firstRange.start;
-                            idRange.first = (0, index_js_1.brand)(idRange.first + countToTrim);
-                            idRange.count -= countToTrim;
-                        }
-                        if (idRange.count > count) {
-                            idRange.count = count;
-                        }
-                        else if (idRange.count < count &&
-                            firstRange.value + firstRange.length === _nextId) {
-                            // The existing range can be extended
-                            _nextId += count - idRange.count;
-                            firstRange.length = count;
-                            idRange.count = count;
-                        }
-                        out.push(idRange);
-                        count -= idRange.count;
-                        currId += idRange.count;
-                    }
-                }
-                return out;
-            },
-            mint(length) {
-                const count = length ?? 1;
-                const out = _nextId;
-                _nextId += count;
-                return (0, index_js_1.brand)(out);
-            },
-        };
-    },
-};
-//# sourceMappingURL=memoizedIdRangeAllocator.js.map