@fluidframework/tree 2.74.0-370705 → 2.80.0

package/src/simple-tree/toStoredSchema.ts

@@ -186,27 +186,31 @@ export function transformSimpleSchema(
 ): SimpleTreeSchema {
 	const simpleNodeSchema = new Map<string, SimpleNodeSchema>();
 	const root = filterFieldAllowedTypes(schema.root, options);
-	const queue = Array.from(root.simpleAllowedTypes.keys());
+	const queue = [...root.simpleAllowedTypes.keys()];
 	for (const identifier of queue) {
 		getOrCreate(simpleNodeSchema, identifier, (id) => {
-			const nodeSchema = schema.definitions.get(id) ?? fail("missing schema");
+			const nodeSchema = schema.definitions.get(id) ?? fail(0xca8 /* missing schema */);
 			const transformed = transformSimpleNodeSchema(nodeSchema, options);
 			const kind = transformed.kind;
 			switch (kind) {
-				case NodeKind.Leaf:
+				case NodeKind.Leaf: {
 					break;
+				}
 				case NodeKind.Array:
 				case NodeKind.Map:
-				case NodeKind.Record:
+				case NodeKind.Record: {
 					queue.push(...transformed.simpleAllowedTypes.keys());
 					break;
-				case NodeKind.Object:
+				}
+				case NodeKind.Object: {
 					for (const fieldSchema of transformed.fields.values()) {
 						queue.push(...fieldSchema.simpleAllowedTypes.keys());
 					}
 					break;
-				default:
+				}
+				default: {
 					unreachableCase(kind);
+				}
 			}
 			return transformed;
 		});
@@ -216,12 +220,12 @@ export function transformSimpleSchema(
 	const definitions = new Map<string, SimpleNodeSchema>(
 		mapIterable(
 			filterIterable(schema.definitions.keys(), (id) => simpleNodeSchema.has(id)),
-			(id) => [id, simpleNodeSchema.get(id) ?? fail("missing schema")],
+			(id) => [id, simpleNodeSchema.get(id) ?? fail(0xca9 /* missing schema */)],
 		),
 	);
 	assert(
 		definitions.size === simpleNodeSchema.size,
-		"Reachable schema missing from input TreeSchema",
+		0xcaa /* Reachable schema missing from input TreeSchema */,
 	);
 	return { root, definitions };
 }

package/src/simple-tree/unhydratedFlexTreeFromInsertable.ts

@@ -9,10 +9,7 @@ import { assert, fail } from "@fluidframework/core-utils/internal";
 
 import { filterIterable, hasSingle, oneFromIterable } from "../util/index.js";
 
-import type { FlexTreeNode } from "../feature-libraries/index.js";
-
-import type { ImplicitFieldSchema } from "./fieldSchema.js";
-import { normalizeFieldSchema, FieldKind } from "./fieldSchema.js";
+import { normalizeFieldSchema, FieldKind, type ImplicitFieldSchema } from "./fieldSchema.js";
 import {
 	CompatibilityLevel,
 	getKernel,
@@ -27,7 +24,7 @@ import {
 import { getUnhydratedContext } from "./createContext.js";
 
 /**
- * Transforms an input {@link TypedNode} tree to a {@link FlexTreeNode}.
+ * Transforms an input {@link TypedNode} tree to an {@link UnhydratedFlexTreeNode}.
  * @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.
@@ -52,10 +49,10 @@ import { getUnhydratedContext } from "./createContext.js";
  * 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 flexTreeFromInsertable<TIn extends InsertableContent | undefined>(
+export function unhydratedFlexTreeFromInsertable<TIn extends InsertableContent | undefined>(
 	data: TIn,
 	allowedTypes: ImplicitFieldSchema,
-): TIn extends undefined ? undefined : FlexTreeNode {
+): TIn extends undefined ? undefined : UnhydratedFlexTreeNode {
 	const normalizedFieldSchema = normalizeFieldSchema(allowedTypes);
 
 	if (data === undefined) {
@@ -63,59 +60,34 @@ export function flexTreeFromInsertable<TIn extends InsertableContent | undefined
 		if (normalizedFieldSchema.kind !== FieldKind.Optional) {
 			throw new UsageError("Got undefined for non-optional field.");
 		}
-		return undefined as TIn extends undefined ? undefined : FlexTreeNode;
+		return undefined as TIn extends undefined ? undefined : UnhydratedFlexTreeNode;
 	}
 
-	const flexTree: FlexTreeNode = flexTreeFromInsertableNode(
+	const flexTree: UnhydratedFlexTreeNode = unhydratedFlexTreeFromInsertableNode(
 		data,
 		normalizedFieldSchema.allowedTypeSet,
 	);
 
-	return flexTree as TIn extends undefined ? undefined : FlexTreeNode;
+	return flexTree as TIn extends undefined ? undefined : UnhydratedFlexTreeNode;
 }
 
 /**
- * Wrapper around {@link flexTreeFromInsertable} which always returns an unhydrated nodes (or undefined).
- * @remarks
- * This does not deeply check content is unhydrated.
- *
- * Once hybrid content is better supported, this should likely be removed as a simplification.
+ * Copy content from `data` into a UnhydratedFlexTreeNode.
  */
-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(
+export function unhydratedFlexTreeFromInsertableNode(
 	data: InsertableContent,
 	allowedTypes: ReadonlySet<TreeNodeSchema>,
-): FlexTreeNode {
+): UnhydratedFlexTreeNode {
 	if (isTreeNode(data)) {
 		const kernel = getKernel(data);
-		const inner = kernel.getInnerNode();
-		if (inner.parentField.parent.parent !== undefined) {
-			throw new UsageError(
-				"A node which already has a parent may not be used as part of a new tree.",
-			);
+		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 may not be inserted into the tree more than once");
 		} else {
 			if (!allowedTypes.has(kernel.schema)) {
 				throw new UsageError("Invalid schema for this context.");
 			}
-
-			if (inner.isHydrated()) {
-				// TODO: hook up event bubbling from hydrated to unhydrated tree.
-			}
-
 			return inner;
 		}
 	}

package/src/tableSchema.ts

@@ -30,6 +30,9 @@ import {
 	withBufferedTreeEvents,
 	type TreeRecordNode,
 	objectSchema,
+	eraseSchemaDetailsSubclassable,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars, unused-imports/no-unused-imports -- This makes the API report slightly cleaner.
+	TreeNodeSchemaCore,
 } from "./simple-tree/index.js";
 import { validateIndex, validateIndexRange } from "./util/index.js";
 import { EmptyKey } from "./core/index.js";
@@ -515,9 +518,6 @@ export namespace System_TableSchema {
 		type TableValueType = TreeNode &
 			TableSchema.Table<TUserScope, TCellSchema, TColumnSchema, TRowSchema> &
 			WithType<ScopedSchemaName<Scope, "TableRoot">>;
-		// Prevent users from calling the table node constructor directly.
-		// They should use the static `create` factory method instead.
-		type TableInsertableType = never;
 		type TableConstructorType = new (data?: InternalTreeNode | undefined) => TableValueType;
 
 		/**
@@ -1120,20 +1120,8 @@ export namespace System_TableSchema {
 		// eslint-disable-next-line @typescript-eslint/no-explicit-any
 		(Table as any)[tableSchemaSymbol] = true;
 
-		// Returning SingletonSchema without a type conversion results in TypeScript generating something like `readonly "__#124291@#brand": unknown;`
-		// for the private brand field of TreeNode.
-		// This numeric id doesn't seem to be stable over incremental builds, and thus causes diffs in the API extractor reports.
-		// This is avoided by doing this type conversion.
-		// The conversion is done via assignment instead of `as` to get stronger type safety.
-		const TableSchemaType: TreeNodeSchemaClass<
-			/* Name */ ScopedSchemaName<Scope, "TableRoot">,
-			/* Kind */ NodeKind.Object,
-			/* TNode */ TableValueType,
-			/* TInsertable */ TableInsertableType,
-			/* ImplicitlyConstructable */ false,
-			/* Info */ typeof tableFields,
-			/* TConstructorExtra */ undefined
-		> & {
+		// Named interfaces here do not compile.
+		type Statics = {
 			/**
 			 * Create a table with initial contents.
 			 * @param initialContents - The initial contents of the table.
@@ -1153,7 +1141,14 @@ export namespace System_TableSchema {
 					  >
 					| undefined,
 			): InstanceType<TThis>;
-		} = Table;
+		} & TableConstructorType;
+
+		// Returning SingletonSchema without a type conversion results in TypeScript generating something like `readonly "__#124291@#brand": unknown;`
+		// for the private brand field of TreeNode.
+		// This numeric id doesn't seem to be stable over incremental builds, and thus causes diffs in the API extractor reports.
+		// This is avoided by doing this type conversion.
+		// The conversion is done via eraseSubclassableSchemaDetails to erase internal details.
+		const TableSchemaType = eraseSchemaDetailsSubclassable<TableValueType, Statics>()(Table);
 
 		// Return the table schema
 		return TableSchemaType;

package/src/treeFactory.ts

@@ -29,9 +29,7 @@ import type { ITree } from "./simple-tree/index.js";
 import { Breakable, copyProperty } from "./util/index.js";
 import { FluidClientVersion } from "./codec/index.js";
 import {
-	editManagerFormatVersionSelectorForDetachedRootEditing,
 	editManagerFormatVersionSelectorForSharedBranches,
-	messageFormatVersionSelectorForDetachedRootEditing,
 	messageFormatVersionSelectorForSharedBranches,
 } from "./shared-tree-core/index.js";
 
@@ -214,23 +212,16 @@ export function resolveOptions(options: SharedTreeOptions): SharedTreeOptionsInt
 }
 
 function resolveFormatOptions(options: SharedTreeOptions): SharedTreeOptionsInternal {
-	if (options.enableSharedBranches === true && options.enableDetachedRootEditing === true) {
-		throw new UsageError("enableDetachRootEditing cannot be used with enableSharedBranches.");
-	}
-	if (options.enableSharedBranches === true) {
+	const enableSharedBranches = options.enableSharedBranches ?? false;
+
+	if (enableSharedBranches) {
 		return sharedBranchesOptions;
 	}
-	if (options.enableDetachedRootEditing === true) {
-		return detachRootEditingOptions;
-	}
+
 	return {};
 }
+
 const sharedBranchesOptions: SharedTreeOptionsInternal = {
 	messageFormatSelector: messageFormatVersionSelectorForSharedBranches,
 	editManagerFormatSelector: editManagerFormatVersionSelectorForSharedBranches,
 };
-const detachRootEditingOptions: SharedTreeOptionsInternal = {
-	messageFormatSelector: messageFormatVersionSelectorForDetachedRootEditing,
-	editManagerFormatSelector: editManagerFormatVersionSelectorForDetachedRootEditing,
-	canMakeDetachedRootEdits: true,
-};

package/src/util/bTreeUtils.ts

@@ -45,7 +45,7 @@ export function mergeTupleBTrees<K extends readonly unknown[], V>(
 	preferLeft = true,
 ): TupleBTree<K, V> {
 	if (tree1 === undefined) {
-		return tree2 !== undefined ? brand(tree2.clone()) : newTupleBTree<K, V>();
+		return tree2 === undefined ? newTupleBTree<K, V>() : brand(tree2.clone());
 	}
 
 	const result: TupleBTree<K, V> = brand(tree1.clone());

package/src/util/brand.ts

@@ -149,3 +149,64 @@ export function brandConst<const T>(
 ) => T2 & T {
 	return <T2>() => value as T2 & T;
 }
+
+/**
+ * Removes a type brand from a branded value.
+ * @remarks
+ * This is useful when trying to do an exhaustive switch over a union of branded types,
+ * which for some reason fails if the brand is not removed from the "case" entries.
+ */
+export function unbrand<const T extends BrandedType<unknown, unknown>>(
+	value: T,
+): ValueFromBranded<T> {
+	return value as never;
+}
+
+/**
+ * Make an enum like object using {@link Brand} to brand the values.
+ * @remarks
+ * This has stricter typing than TypeScript built in enums since it does not allow implicit assignment of `number` to enums with a numeric value.
+ * It also blocks implicit conversions of individual constants to the enum type:
+ * such cases must use {@link brand} or get the branded value from the enum instead.
+ *
+ * One limitation is that narrowing does not work in switch statements:
+ * the values in each case can use {@link unbrand} to work around this.
+ *
+ * This object does not provide {@link https://www.typescriptlang.org/docs/handbook/enums.html#reverse-mappings | reverse mappings}.
+ *
+ * @example
+ * ```typescript
+ * const TestA = strictEnum("TestA", {
+ * 	a: 1,
+ * 	b: 2,
+ * });
+ * type TestA = Values<typeof TestA>;
+ *
+ * function switchUnbrand(x: TestA) {
+ * 	switch (x) {
+ * 		case unbrand(TestA.a):
+ * 			return "a";
+ * 		case unbrand(TestA.b):
+ * 			return "b";
+ * 		default:
+ * 			unreachableCase(x);
+ * 	}
+ * }
+ * ```
+ */
+export function strictEnum<const T, const TBrand>(
+	name: TBrand,
+	entries: T,
+): { readonly [Property in keyof T]: Brand<T[Property], TBrand> } {
+	return entries as {
+		readonly [Property in keyof T]: Brand<T[Property], TBrand>;
+	};
+}
+
+/**
+ * Extracts the values of an object type as a union.
+ * @remarks
+ * Like `keyof`	except for values.
+ * This is useful for extracting the value types of enums created with {@link strictEnum}.
+ */
+export type Values<T> = T[keyof T];

package/src/util/breakable.ts

@@ -221,15 +221,15 @@ export function breakingClass<Target extends abstract new (...args: any[]) => Wi
 			if (!doNotWrap.has(key)) {
 				doNotWrap.add(key);
 				const descriptor = Reflect.getOwnPropertyDescriptor(prototype, key);
-				if (descriptor !== undefined) {
-					// Method
-					if (typeof descriptor.value === "function") {
-						if (!isBreaker(descriptor.value)) {
-							// This does not affect the original class, see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyDescriptor
-							descriptor.value = breakingMethod(descriptor.value);
-							Object.defineProperty(DecoratedBreakable.prototype, key, descriptor);
-						}
-					}
+				// Method
+				if (
+					descriptor !== undefined &&
+					typeof descriptor.value === "function" &&
+					!isBreaker(descriptor.value)
+				) {
+					// This does not affect the original class, see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyDescriptor
+					descriptor.value = breakingMethod(descriptor.value);
+					Object.defineProperty(DecoratedBreakable.prototype, key, descriptor);
 				}
 			}
 		}

package/src/util/idAllocator.ts

@@ -30,8 +30,7 @@ export function idAllocatorFromMaxId(maxId: number | undefined = undefined): IdA
 
 export function idAllocatorFromState(state: IdAllocationState): IdAllocator {
 	return {
-		allocate: (c?: number): number => {
-			const count = c ?? 1;
+		allocate: (count: number = 1): number => {
 			assert(count > 0, 0x5cf /* Must allocate at least one ID */);
 			const id: number = state.maxId + 1;
 			state.maxId += count;

package/src/util/index.ts

@@ -16,6 +16,9 @@ export {
 	type NameFromBranded,
 	type ValueFromBranded,
 	brandConst,
+	type Values,
+	strictEnum,
+	unbrand,
 } from "./brand.js";
 export { brandedNumberType, brandedStringType } from "./typeboxBrand.js";
 export {
@@ -131,10 +134,7 @@ export {
 export {
 	RangeMap,
 	type RangeQueryResult,
-	type RangeQueryResultFragment,
-	type RangeQueryEntry,
 	newIntegerRangeMap,
-	areAdjacentIntegerRanges,
 } from "./rangeMap.js";
 
 export {

package/src/util/nestedMap.ts

@@ -314,9 +314,7 @@ export class SizedNestedMap<Key1, Key2, Value> {
 	}
 
 	public values(): IterableIterator<Value> {
-		return (
-			Array.from(this.nestedMap.values()).flatMap((innerMap) => innerMap.values())[0] ?? oob()
-		);
+		return [...this.nestedMap.values()].flatMap((innerMap) => innerMap.values())[0] ?? oob();
 	}
 
 	public [Symbol.iterator](): IterableIterator<[Key1, Map<Key2, Value>]> {

package/src/util/rangeMap.ts

@@ -34,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(
-		public readonly offsetKey: (key: K, offset: number) => K,
-		public readonly subtractKeys: (a: K, b: K) => number,
+		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);
@@ -92,34 +92,6 @@ 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.
 	 *
@@ -128,7 +100,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<V | undefined> {
+	public getFirst(start: K, length: number): RangeQueryResult<K, V> {
 		{
 			// We first check for an entry with a key less than or equal to `start`.
 			const entry = this.tree.getPairOrNextLower(start);
@@ -142,6 +114,7 @@ export class RangeMap<K, V> {
 				if (overlappingLength > 0) {
 					return {
 						value: this.offsetValue(value, lengthBeforeQuery),
+						start,
 						length: overlappingLength,
 					};
 				}
@@ -157,11 +130,11 @@ export class RangeMap<K, V> {
 
 				const lastQueryKey = this.offsetKey(start, length - 1);
 				if (this.le(entryKey, lastQueryKey)) {
-					return { value: undefined, length: this.subtractKeys(entryKey, start) };
+					return { value: undefined, start, length: this.subtractKeys(entryKey, start) };
 				}
 			}
 
-			return { value: undefined, length };
+			return { value: undefined, start, length };
 		}
 	}
 
@@ -198,22 +171,18 @@ export class RangeMap<K, V> {
 	 *
 	 * @param start - The start of the range to delete (inclusive).
 	 * @param length - The length of the range to delete.
-	 * @returns The number of entries deleted.
 	 */
-	public delete(start: K, length: number): number {
-		let deleteCount = 0;
+	public delete(start: K, length: number): void {
 		const lastDeleteKey = this.offsetKey(start, length - 1);
 		for (const { start: key, length: entryLength, value } of this.getIntersectingEntries(
 			start,
 			length,
 		)) {
-			deleteCount += entryLength;
 			this.tree.delete(key);
 			const lengthBefore = this.subtractKeys(start, key);
 			if (lengthBefore > 0) {
 				// A portion of this entry comes before the deletion range, so we reinsert that portion.
 				this.tree.set(key, { length: lengthBefore, value });
-				deleteCount -= lengthBefore;
 			}
 
 			const lastEntryKey = this.offsetKey(key, entryLength - 1);
@@ -226,10 +195,8 @@ export class RangeMap<K, V> {
 					length: lengthAfter,
 					value: this.offsetValue(value, difference),
 				});
-				deleteCount -= lengthAfter;
 			}
 		}
-		return deleteCount;
 	}
 
 	public clone(): RangeMap<K, V> {
@@ -238,14 +205,6 @@ 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.
 	 */
@@ -261,9 +220,9 @@ export class RangeMap<K, V> {
 
 		// TODO: Is there a good pattern that lets us make `tree` readonly?
 		merged.tree = a.tree.clone();
-		for (const entry of b.entries()) {
+		for (const [key, value] of b.tree.entries()) {
 			// TODO: Handle key collisions
-			merged.set(entry.start, entry.length, entry.value);
+			merged.tree.set(key, value);
 		}
 
 		return merged;
@@ -338,11 +297,17 @@ interface RangeEntry<V> {
 /**
  * Describes the result of a range query, including the value and length of the matching prefix.
  */
-export interface RangeQueryResult<V> {
+export interface RangeQueryResult<K, V> {
+	/**
+	 * The key for the first element in the range.
+	 */
+	readonly start: K;
+
 	/**
 	 * The value of the first key in the query range.
+	 * If no matching range is found, this will be undefined.
 	 */
-	readonly value: V;
+	readonly value: V | undefined;
 
 	/**
 	 * The length of the prefix of the query range which has the same value.
@@ -352,19 +317,8 @@ export interface RangeQueryResult<V> {
 	readonly length: number;
 }
 
-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;
+export interface RangeQueryEntry<K, V> extends RangeQueryResult<K, V> {
 	readonly value: V;
-	readonly length: number;
 }
 
 export function newIntegerRangeMap<V>(): RangeMap<number, V> {
@@ -382,11 +336,3 @@ function subtractIntegers(a: number, b: number): 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/src/util/utils.ts

@@ -165,27 +165,28 @@ export function compareSets<T>({
 	same?: (t: T) => boolean;
 }): boolean {
 	for (const item of a.keys()) {
-		if (!b.has(item)) {
-			if (aExtra !== undefined) {
-				if (!aExtra(item)) {
-					return false;
-				}
-			} else {
+		if (b.has(item)) {
+			if (same !== undefined && !same(item)) {
 				return false;
 			}
 		} else {
-			if (same !== undefined && !same(item)) {
+			if (aExtra === undefined) {
 				return false;
+			} else {
+				if (!aExtra(item)) {
+					return false;
+				}
 			}
 		}
 	}
 	for (const item of b.keys()) {
-		if (!a.has(item)) {
-			if (bExtra !== undefined) {
-				if (!bExtra(item)) {
-					return false;
-				}
-			} else {
+		if (a.has(item)) {
+			continue;
+		}
+		if (bExtra === undefined) {
+			return false;
+		} else {
+			if (!bExtra(item)) {
 				return false;
 			}
 		}

package/dist/feature-libraries/default-schema/locationBasedEditBuilder.d.ts

@@ -1,36 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import { type ChangeAtomId, type FieldKey, type FieldUpPath, type UpPath, type TreeChunk } from "../../core/index.js";
-import type { DetachedRootIds, DataEditor, OptionalFieldEditor, RequiredFieldEditor, SequenceFieldEditor } from "./defaultEditBuilder.js";
-export type DetachedRootLocation = FieldKey;
-export type DetachedRootsLocation = readonly DetachedRootRangeLocation[];
-export interface DetachedRootRangeLocation {
-    readonly field: FieldKey;
-    readonly count: number;
-}
-export interface Locator {
-    locationFromId(id: ChangeAtomId): DetachedRootLocation;
-    idFromLocation(id: DetachedRootLocation): ChangeAtomId;
-    locationsFromIdRanges(id: DetachedRootIds): DetachedRootsLocation;
-    idRangesFromLocations(id: DetachedRootsLocation): DetachedRootIds;
-}
-export type ILocationBasedDataEditor = DataEditor<TreeChunk, DetachedRootLocation, DetachedRootsLocation>;
-/**
- * Implementation of {@link DataEditor} based on the default set of supported field kinds.
- * @sealed
- */
-export declare class LocationBasedDataEditor implements DataEditor<TreeChunk, DetachedRootLocation, DetachedRootsLocation> {
-    private readonly idBasedEditor;
-    private readonly locator;
-    constructor(idBasedEditor: DataEditor<TreeChunk, ChangeAtomId, DetachedRootIds>, locator: Locator);
-    addNodeExistsConstraint(path: UpPath): void;
-    addNodeExistsConstraintOnRevert(path: UpPath): void;
-    buildRoots(content: TreeChunk): DetachedRootsLocation;
-    valueField(field: FieldUpPath): RequiredFieldEditor<TreeChunk, DetachedRootLocation>;
-    optionalField(field: FieldUpPath): OptionalFieldEditor<TreeChunk, DetachedRootLocation>;
-    move(sourceField: FieldUpPath, sourceIndex: number, count: number, destinationField: FieldUpPath, destIndex: number): void;
-    sequenceField(field: FieldUpPath): SequenceFieldEditor<TreeChunk, DetachedRootsLocation>;
-}
-//# sourceMappingURL=locationBasedEditBuilder.d.ts.map