@fluidframework/tree 2.70.0-360753 → 2.70.0-361248

package/src/feature-libraries/flex-tree/utilities.ts

@@ -31,7 +31,7 @@ export function treeStatusFromDetachedField(detachedField: DetachedField): TreeS
  *
  * @param anchors - the {@link AnchorSet} to compare your anchorNode cache to.
  * @param anchorNode - the {@link AnchorNode} to get the {@link TreeStatus} of.
- * @returns - the {@link TreeStatus} of the anchorNode provided.
+ * @returns the {@link TreeStatus} of the anchorNode provided.
  */
 export function treeStatusFromAnchorCache(anchorNode: AnchorNode): TreeStatus {
 	const cache = anchorNode.slots.get(detachedFieldSlot);

package/src/feature-libraries/incrementalSummarizationUtils.ts

@@ -13,7 +13,7 @@ export interface CollabWindow {
 	 * gives the sequenceNumber of the op currently being processed.
 	 * `undefined` if no message has been processed, e.g. for a detached document or document loaded
 	 * from summary without any subsequent ops.
-	 * @remarks - Most rebasing is built atop a revision system decoupled from message sequence number.
+	 * @remarks Most rebasing is built atop a revision system decoupled from message sequence number.
 	 * However, this is sometimes necessary to interop with Fluid runtime APIs, e.g. for incremental summarization.
 	 */
 	getCurrentSeq: () => number | undefined;

package/src/feature-libraries/modular-schema/modularChangeFamily.ts

@@ -2142,7 +2142,7 @@ function deltaFromNodeChange(
  * For example, when rebasing change B from a local branch [A, B, C] over a branch [X, Y], the `baseRevisions` must include
  * revisions [A⁻¹ X, Y, A] if rebasing over the composition of all those changes, or
  * revision [A⁻¹] for the first rebase, then [X], etc. if rebasing over edits individually.
- * @returns - RebaseRevisionMetadata to be passed to `FieldChangeRebaser.rebase`*
+ * @returns RebaseRevisionMetadata to be passed to `FieldChangeRebaser.rebase`*
  */
 export function rebaseRevisionMetadataFromInfo(
 	revInfos: readonly RevisionInfo[],

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

@@ -161,7 +161,7 @@ export const Changeset = <Schema extends TSchema>(tNodeChange: Schema) =>
 	Type.Array(Mark(tNodeChange));
 
 /**
- * @privateRemarks - Many of these names are currently used in the sequence-field types. Putting them in a namespace makes codec code more readable.
+ * @privateRemarks Many of these names are currently used in the sequence-field types. Putting them in a namespace makes codec code more readable.
  */
 export namespace Encoded {
 	export type CellCount = Static<typeof CellCount>;

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

@@ -110,7 +110,7 @@ export const Changeset = <Schema extends TSchema>(tNodeChange: Schema) =>
 	Type.Array(Mark(tNodeChange));
 
 /**
- * @privateRemarks - Many of these names are currently used in the sequence-field types. Putting them in a namespace makes codec code more readable.
+ * @privateRemarks Many of these names are currently used in the sequence-field types. Putting them in a namespace makes codec code more readable.
  */
 export namespace Encoded {
 	export type CellCount = Static<typeof CellCount>;

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

@@ -39,7 +39,7 @@ export const Changeset = <Schema extends TSchema>(tNodeChange: Schema) =>
 	Type.Array(Mark(tNodeChange));
 
 /**
- * @privateRemarks - Many of these names are currently used in the sequence-field types. Putting them in a namespace makes codec code more readable.
+ * @privateRemarks Many of these names are currently used in the sequence-field types. Putting them in a namespace makes codec code more readable.
  */
 export namespace Encoded {
 	export type CellCount = EncodedV2.CellCount;

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/tree";
-export const pkgVersion = "2.70.0-360753";
+export const pkgVersion = "2.70.0-361248";

package/src/shared-tree/sharedTree.ts

@@ -667,7 +667,7 @@ export const SharedTreeFormatVersion = {
 	/**
 	 * Requires \@fluidframework/tree \>= 2.0.0.
 	 *
-	 * @deprecated - FF does not currently plan on supporting this format long-term.
+	 * @deprecated FF does not currently plan on supporting this format long-term.
 	 * Do not write production documents using this format, as they may not be loadable in the future.
 	 */
 	v1: 1,

package/src/shared-tree/treeCheckout.ts

@@ -636,7 +636,7 @@ export class TreeCheckout implements ITreeCheckoutFork {
 	 * @param kind - The {@link CommitKind} that produced this revertible (e.g., Default, Undo, Redo).
 	 * @param checkout - The {@link TreeCheckout} instance this revertible belongs to.
 	 * @param onRevertibleDisposed - Callback function that will be called when the revertible is disposed.
-	 * @returns - {@link RevertibleAlpha}
+	 * @returns A {@link RevertibleAlpha} object.
 	 */
 	private createRevertible(
 		revision: RevisionTag,

package/src/shared-tree-core/transaction.ts

@@ -42,7 +42,7 @@ export interface Transactor {
 	 * If a transaction is already in progress when this new transaction starts, then this transaction will be "nested" inside of it,
 	 * i.e. the outer transaction will still be in progress after this new transaction is committed or aborted.
 	 *
-	 * @remarks - Asynchronous transactions are not supported on the root checkout,
+	 * @remarks Asynchronous transactions are not supported on the root checkout,
 	 * since it is always kept up-to-date with the latest remote edits and the results of this rebasing (which might invalidate
 	 * the transaction) is not visible to the application author.
 	 * Instead,
@@ -51,7 +51,7 @@ export interface Transactor {
 	 * 2. run the transaction on the fork
 	 * 3. merge the fork back into the root checkout
 	 *
-	 * @privateRemarks - There is currently no enforcement that asynchronous transactions don't happen on the root checkout.
+	 * @privateRemarks There is currently no enforcement that asynchronous transactions don't happen on the root checkout.
 	 * AB#6488 tracks adding some enforcement to make it more clear to application authors that this is not supported.
 	 */
 	start(): void;

package/src/simple-tree/core/allowedTypes.ts

@@ -253,32 +253,20 @@ export class AnnotatedAllowedTypesInternal<
 		return this.lazyEvaluate.value.identifiers;
 	}
 
-	public static override [Symbol.hasInstance]<
-		TThis extends
-			| (abstract new (
-					...args: unknown[]
-			  ) => object)
-			| typeof AnnotatedAllowedTypesInternal,
-	>(
+	public static override [Symbol.hasInstance]<TThis extends { prototype: object }>(
 		this: TThis,
-		value: ErasedBaseType | InstanceTypeRelaxed<TThis> | ImplicitAllowedTypes,
+		value: unknown,
 	): value is InstanceTypeRelaxed<TThis> & AnnotatedAllowedTypesInternal & AllowedTypesFull {
-		return Object.prototype.isPrototypeOf.call(this.prototype, value);
+		return ErasedTypeImplementation[Symbol.hasInstance].call(this, value);
 	}
 
-	public static override narrow<
-		TThis extends
-			| (abstract new (
-					...args: unknown[]
-			  ) => object)
-			| typeof AnnotatedAllowedTypesInternal,
-	>(
+	public static override narrow<TThis extends { prototype: object }>(
 		this: TThis,
 		value: ErasedBaseType | InstanceTypeRelaxed<TThis> | ImplicitAllowedTypes,
 	): asserts value is InstanceTypeRelaxed<TThis> &
 		AnnotatedAllowedTypesInternal &
 		AllowedTypesFull {
-		if (!Object.prototype.isPrototypeOf.call(this.prototype, value)) {
+		if (!ErasedTypeImplementation[Symbol.hasInstance].call(this, value)) {
 			throw new TypeError("Invalid AnnotatedAllowedTypes instance");
 		}
 	}

package/src/simple-tree/core/treeNodeSchema.ts

@@ -10,7 +10,7 @@ import type { SimpleNodeSchemaBase } from "./simpleNodeSchemaBase.js";
 import type { TreeNode } from "./treeNode.js";
 import type { InternalTreeNode, Unhydrated } from "./types.js";
 import type { UnionToIntersection } from "../../util/index.js";
-import type { ImplicitAllowedTypes, AllowedTypesFullEvaluated } from "./allowedTypes.js";
+import type { AllowedTypesFullEvaluated, AllowedTypesFull } from "./allowedTypes.js";
 import type { Context } from "./context.js";
 import type { FieldKey, NodeData, TreeNodeStoredSchema } from "../../core/index.js";
 import type { UnhydratedFlexTreeField } from "./unhydratedFlexTree.js";
@@ -379,16 +379,11 @@ export interface TreeNodeSchemaPrivateData {
 	 * In this case "field" includes anything that is a field in the internal (flex-tree) abstraction layer.
 	 * This includes the content field for arrays, and all the fields for map nodes.
 	 * If this node does not have fields (and thus is a leaf), the array will be empty.
-	 *
-	 * This set cannot be used before the schema in it have been defined:
-	 * more specifically, when using lazy schema references (for example to make foreword references to schema which have not yet been defined),
-	 * users must wait until after the schema are defined to access this array.
-	 *
 	 * @privateRemarks
 	 * If this is stabilized, it will live alongside the childTypes property on {@link TreeNodeSchemaCore}.
 	 * @system
 	 */
-	readonly childAnnotatedAllowedTypes: readonly ImplicitAllowedTypes[];
+	readonly childAllowedTypes: readonly AllowedTypesFull[];
 
 	/**
 	 * Idempotent initialization function that pre-caches data and can dereference lazy schema references.
@@ -422,7 +417,7 @@ export interface TreeNodeSchemaInitializedData {
 	 * If this is stabilized, it will live alongside the childTypes property on {@link TreeNodeSchemaCore}.
 	 * @system
 	 */
-	readonly childAnnotatedAllowedTypes: readonly AllowedTypesFullEvaluated[];
+	readonly childAllowedTypes: readonly AllowedTypesFullEvaluated[];
 
 	/**
 	 * A {@link Context} which can be used for unhydrated nodes of this schema.

package/src/simple-tree/core/treeNodeValid.ts

@@ -25,7 +25,7 @@ import {
 } from "./treeNodeKernel.js";
 import type { InternalTreeNode } from "./types.js";
 import { typeSchemaSymbol } from "./withType.js";
-import type { ImplicitAllowedTypes } from "./allowedTypes.js";
+import type { AllowedTypesFull } from "./allowedTypes.js";
 import type { SimpleNodeSchemaBase } from "./simpleNodeSchemaBase.js";
 
 /**
@@ -259,7 +259,7 @@ export function isClassBasedSchema(
  */
 export function createTreeNodeSchemaPrivateData(
 	schema: TreeNodeSchemaCore<string, NodeKind, boolean>,
-	childAnnotatedAllowedTypes: readonly ImplicitAllowedTypes[],
+	childAllowedTypes: readonly AllowedTypesFull[],
 	toStored: TreeNodeSchemaPrivateData["toStored"],
 ): TreeNodeSchemaPrivateData {
 	const schemaValid = schemaAsTreeNodeValid(schema);
@@ -269,7 +269,7 @@ export function createTreeNodeSchemaPrivateData(
 
 	return {
 		idempotentInitialize: () => schemaValid.oneTimeInitialize().oneTimeInitialized,
-		childAnnotatedAllowedTypes,
+		childAllowedTypes,
 		toStored,
 	};
 }

package/src/simple-tree/core/walkSchema.ts

@@ -28,8 +28,7 @@ export function walkNodeSchema(
 	// Since walkNodeSchema is used in the implementation of TreeNodeSchemaPrivateData.idempotentInitialize,
 	// Avoid depending on it here to avoid circular dependencies for recursive schema.
 	// Instead normalize/evaluate the allowed types as needed.
-	const annotatedAllowedTypes =
-		getTreeNodeSchemaPrivateData(schema).childAnnotatedAllowedTypes;
+	const annotatedAllowedTypes = getTreeNodeSchemaPrivateData(schema).childAllowedTypes;
 
 	for (const fieldAllowedTypes of annotatedAllowedTypes) {
 		walkAllowedTypes(

package/src/simple-tree/createContext.ts

@@ -9,7 +9,6 @@ import { getOrCreate } from "../util/index.js";
 import {
 	Context,
 	getTreeNodeSchemaPrivateData,
-	normalizeAndEvaluateAnnotatedAllowedTypes,
 	UnhydratedContext,
 	type TreeNodeSchema,
 	type TreeNodeSchemaInitializedData,
@@ -50,8 +49,6 @@ export function getTreeNodeSchemaInitializedData(
 	return {
 		...handler,
 		context: getUnhydratedContext(schema),
-		childAnnotatedAllowedTypes: data.childAnnotatedAllowedTypes.map(
-			normalizeAndEvaluateAnnotatedAllowedTypes,
-		),
+		childAllowedTypes: data.childAllowedTypes.map((t) => t.evaluate()),
 	};
 }

package/src/simple-tree/leafNodeSchema.ts

@@ -63,7 +63,7 @@ export class LeafNodeSchema<Name extends string, const T extends ValueSchema>
 					allowedTypes: ReadonlySet<TreeNodeSchema>,
 				): FlexContent => leafToFlexContent(data, this, allowedTypes),
 			})),
-		childAnnotatedAllowedTypes: [],
+		childAllowedTypes: [],
 		toStored: () => new LeafNodeStoredSchema(this.leafKind),
 	};
 	#initializedData: TreeNodeSchemaInitializedData | undefined;

package/src/simple-tree/node-kinds/array/arrayNode.ts

@@ -1273,8 +1273,11 @@ export function arraySchema<
 		}
 
 		public static get [privateDataSymbol](): TreeNodeSchemaPrivateData {
-			return (privateData ??= createTreeNodeSchemaPrivateData(this, [info], (storedOptions) =>
-				arrayNodeStoredSchema(convertAllowedTypes(info, storedOptions), persistedMetadata),
+			return (privateData ??= createTreeNodeSchemaPrivateData(
+				this,
+				[normalizedTypes],
+				(storedOptions) =>
+					arrayNodeStoredSchema(convertAllowedTypes(info, storedOptions), persistedMetadata),
 			));
 		}
 	}

package/src/simple-tree/node-kinds/map/mapNode.ts

@@ -336,7 +336,7 @@ export function mapSchema<
 		public static get [privateDataSymbol](): TreeNodeSchemaPrivateData {
 			return (privateData ??= createTreeNodeSchemaPrivateData(
 				this,
-				[info],
+				[normalizedTypes],
 				(storedOptions) =>
 					new MapNodeStoredSchema(
 						{

package/src/simple-tree/node-kinds/object/objectNode.ts

@@ -99,7 +99,7 @@ import type { ObjectSchemaOptionsAlpha } from "../../api/index.js";
  */
 export type ObjectFromSchemaRecord<T extends RestrictiveStringRecord<ImplicitFieldSchema>> =
 	RestrictiveStringRecord<ImplicitFieldSchema> extends T
-		? // eslint-disable-next-line @typescript-eslint/ban-types
+		? // eslint-disable-next-line @typescript-eslint/no-empty-object-type, @typescript-eslint/ban-types
 			{}
 		: {
 				-readonly [Property in keyof T]: Property extends string
@@ -577,10 +577,7 @@ export function objectSchema<
 		public static get [privateDataSymbol](): TreeNodeSchemaPrivateData {
 			return (privateData ??= createTreeNodeSchemaPrivateData(
 				this,
-				Array.from(
-					flexKeyMap.values(),
-					({ schema }) => normalizeFieldSchema(schema).allowedTypes,
-				),
+				Array.from(CustomObjectNode.fields.values(), (schema) => schema.allowedTypesFull),
 				(storedOptions) => {
 					const fields: Map<FieldKey, TreeFieldStoredSchema> = new Map();
 					for (const fieldSchema of flexKeyMap.values()) {

package/src/simple-tree/node-kinds/record/recordNode.ts

@@ -381,7 +381,7 @@ export function recordSchema<
 		public static get [privateDataSymbol](): TreeNodeSchemaPrivateData {
 			return (privateData ??= createTreeNodeSchemaPrivateData(
 				this,
-				[info],
+				[normalizedTypes],
 				(storedOptions) =>
 					new MapNodeStoredSchema(
 						{

package/src/util/breakable.ts

@@ -171,10 +171,10 @@ export function throwIfBroken<
 	return replacementMethod as Target;
 }
 
-// eslint-disable-next-line @typescript-eslint/ban-types
+// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type, @typescript-eslint/ban-types
 type PossiblyNamedFunction = Function & { displayName?: undefined | string };
 
-// eslint-disable-next-line @typescript-eslint/ban-types
+// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type, @typescript-eslint/ban-types
 function nameFunctionFrom(toName: Function, nameFrom: Function): void {
 	(toName as PossiblyNamedFunction).displayName =
 		(nameFrom as PossiblyNamedFunction).displayName ?? nameFrom.name;
@@ -183,13 +183,13 @@ function nameFunctionFrom(toName: Function, nameFrom: Function): void {
 const isBreakerSymbol: unique symbol = Symbol("isBreaker");
 
 // Accepting any function like value is desired and safe here as this does not call the provided function.
-// eslint-disable-next-line @typescript-eslint/ban-types
+// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type, @typescript-eslint/ban-types
 function markBreaker(f: Function): void {
 	(f as unknown as Record<typeof isBreakerSymbol, true>)[isBreakerSymbol] = true;
 }
 
 // Accepting any function like value is desired and safe here as this does not call the provided function.
-// eslint-disable-next-line @typescript-eslint/ban-types
+// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type, @typescript-eslint/ban-types
 function isBreaker(f: Function): boolean {
 	return isBreakerSymbol in (f as unknown as Record<typeof isBreakerSymbol, true>);
 }

package/src/util/index.ts

@@ -78,7 +78,7 @@ export {
 	assertNonNegativeSafeInteger,
 	objectToMap,
 	invertMap,
-	oneFromSet,
+	oneFromIterable,
 	type Named,
 	compareNamed,
 	disposeSymbol,

package/src/util/nestedMap.ts

@@ -49,7 +49,7 @@ export function tryAddToNestedMap<Key1, Key2, Value>(
  * @param destination - The map to copy data into. Both the outer and inner map may be mutated.
  * @param override - Whether existing entries in `destination` should be replaced by corresponding entries in `source`.
  *
- * @remarks - This function performs deep copying when necessary.
+ * @remarks This function performs deep copying when necessary.
  * This ensures that mutating `destination` after this call will not result in unexpected mutations to `source`.
  */
 export function populateNestedMap<Key1, Key2, Value>(

package/src/util/referenceCounting.ts

@@ -8,7 +8,7 @@ import { assert } from "@fluidframework/core-utils/internal";
 /**
  * An object which counts the number of users / references to it.
  * @remarks
- * This implements the [Reference counting](https://en.wikipedia.org/wiki/Reference_counting) pattern.
+ * This implements the {@link https://en.wikipedia.org/wiki/Reference_counting | Reference counting} pattern.
  * Getting the reference count correct is difficult in TypeScript and great care must be used.
  * Because of this, this interface should not be used in the public API.
  */

package/src/util/utils.ts

@@ -105,6 +105,28 @@ export function iterableHasSome<T>(iterable: Iterable<T>): boolean {
 	return iterable[Symbol.iterator]().next().done === false;
 }
 
+/**
+ * Returns the value from the given iterable if it contains exactly one item, otherwise `undefined`.
+ * @remarks
+ * Note that if the iterable itself may contain `undefined` values,
+ * it is not possible to use this to distinguish between an iterable that contains exactly one `undefined` value and an iterable that contains zero or multiple values.
+ */
+export function oneFromIterable<T>(items: Iterable<T>): T | undefined {
+	const iterator = items[Symbol.iterator]();
+	const first = iterator.next();
+	if (first.done === true) {
+		// Empty iterable case.
+		return undefined;
+	}
+	const second = iterator.next();
+	if (second.done === true) {
+		// Single item iterable case.
+		return first.value;
+	}
+	// Multiple item iterable case.
+	return undefined;
+}
+
 /**
  * Returns true if and only if the given array has exactly one element.
  * @param array - The array to check.
@@ -477,21 +499,6 @@ export function invertMap<Key, Value>(input: Map<Key, Value>): Map<Value, Key> {
 	return result;
 }
 
-/**
- * Returns the value from `set` if it contains exactly one item, otherwise `undefined`.
- */
-export function oneFromSet<T>(set: ReadonlySet<T> | undefined): T | undefined {
-	if (set === undefined) {
-		return undefined;
-	}
-	if (set.size !== 1) {
-		return undefined;
-	}
-	for (const item of set) {
-		return item;
-	}
-}
-
 /**
  * Type with a name describing what it is.
  * Typically used with values (like schema) that can be stored in a map, but in some representations have their name/key as a field.