@fluidframework/tree 2.70.0-361092 → 2.70.0-361248

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-361092";
+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/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

@@ -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/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.
  */