@fluidframework/tree 2.73.0 → 2.74.0-365691

package/src/shared-tree/sharedTreeChangeFamily.ts

@@ -23,7 +23,7 @@ import {
 	ModularChangeFamily,
 	type ModularChangeset,
 	type TreeChunk,
-	type TreeCompressionStrategyPrivate,
+	type TreeCompressionStrategy,
 	fieldKindConfigurations,
 	fieldKinds,
 	makeModularChangeCodecFamily,
@@ -61,7 +61,7 @@ export class SharedTreeChangeFamily
 		revisionTagCodec: RevisionTagCodec,
 		fieldBatchCodec: FieldBatchCodec,
 		codecOptions: CodecWriteOptions,
-		chunkCompressionStrategy?: TreeCompressionStrategyPrivate,
+		chunkCompressionStrategy?: TreeCompressionStrategy,
 		private readonly idCompressor?: IIdCompressor,
 	) {
 		const modularChangeCodec = makeModularChangeCodecFamily(

package/src/shared-tree/treeCheckout.ts

@@ -51,7 +51,7 @@ import {
 } from "../core/index.js";
 import {
 	type FieldBatchCodec,
-	type TreeCompressionStrategyPrivate,
+	type TreeCompressionStrategy,
 	allowsRepoSuperset,
 	buildForest,
 	createNodeIdentifierManager,
@@ -287,7 +287,7 @@ export function createTreeCheckout(
 		forest?: IEditableForest;
 		fieldBatchCodec?: FieldBatchCodec;
 		removedRoots?: DetachedFieldIndex;
-		chunkCompressionStrategy?: TreeCompressionStrategyPrivate;
+		chunkCompressionStrategy?: TreeCompressionStrategy;
 		logger?: ITelemetryLoggerExt;
 		breaker?: Breakable;
 		disposeForksAfterTransaction?: boolean;

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

@@ -27,7 +27,7 @@ export {
 	type SummaryElementParser,
 	type SummaryElementStringifier,
 	type ClonableSchemaAndPolicy,
-	type SharedTreeCoreOptionsInternal as SharedTreCoreOptionsInternal,
+	type SharedTreeCoreOptionsInternal,
 } from "./sharedTreeCore.js";
 
 export type { ResubmitMachine } from "./resubmitMachine.js";

package/src/simple-tree/api/incrementalAllowedTypes.ts

@@ -3,21 +3,21 @@
  * Licensed under the MIT License.
  */
 
-import type { FieldKey, TreeNodeSchemaIdentifier } from "../../core/index.js";
 import { getTreeNodeSchemaPrivateData, type AllowedTypesFull } from "../core/index.js";
 import { isObjectNodeSchema } from "../node-kinds/index.js";
 import type { TreeSchema } from "./configuration.js";
 import type { IncrementalEncodingPolicy } from "../../feature-libraries/index.js";
 import { oneFromIterable } from "../../util/index.js";
 import { assert } from "@fluidframework/core-utils/internal";
+import type { FieldKey } from "../../core/index.js";
 
 /**
- * A symbol when present in the {@link AnnotatedAllowedTypes.metadata.custom} property as true, opts in the allowed
+ * A symbol when present in the {@link AnnotatedAllowedTypes.metadata}'s `custom` property as true, opts in the allowed
  * types to incremental summary optimization.
  * These allowed types will be optimized during summary such that if they don't change across summaries,
  * they will not be encoded and their content will not be included in the summary that is uploaded to the service.
  * @remarks
- * See {@link getShouldIncrementallySummarizeAllowedTypes} for more details.
+ * See {@link incrementalEncodingPolicyForAllowedTypes} for more details.
  *
  * Use {@link SchemaStaticsBeta.types} to add this metadata to allowed types in a schema.
  * @example
@@ -29,6 +29,7 @@ import { assert } from "@fluidframework/core-utils/internal";
  *   }),
  * }) {}
  * ```
+ * @alpha
  */
 export const incrementalSummaryHint: unique symbol = Symbol("IncrementalSummaryHint");
 
@@ -44,31 +45,30 @@ function isIncrementalSummaryHintInAllowedTypes(allowedTypes: AllowedTypesFull):
 }
 
 /**
- * This helper function {@link getShouldIncrementallySummarizeAllowedTypes} can be used to generate a callback function
- * of type {@link IncrementalEncodingPolicy}.
- * This callback can be passed as the value for {@link SharedTreeOptionsInternal.shouldEncodeFieldIncrementally} parameter
+ * This helper function {@link incrementalEncodingPolicyForAllowedTypes} can be used to generate a callback function
+ * of type {@link IncrementalEncodingPolicy}. It determines if each {@link AllowedTypes} in a schema should be
+ * incrementally summarized.
+ * This callback can be passed as the value for {@link SharedTreeOptions.shouldEncodeIncrementally} parameter
  * when creating the tree.
- * It will be called for each {@link AllowedTypes} in the schema to determine if it should be incrementally summarized.
  *
  * @param rootSchema - The schema for the root of the tree.
- * @returns A callback function of type {@link IncrementalEncodingPolicy} which can be used to determine if a field
- * should be incrementally summarized based on whether it is an allowed types with the
- * {@link incrementalAllowedTypesMetadata} metadata.
+ * @returns A callback function of type {@link IncrementalEncodingPolicy} which determines if allowed types should
+ * be incrementally summarized based on whether they have opted in via the {@link incrementalSummaryHint} metadata.
  *
  * @remarks
  * This only works for forest type {@link ForestTypeOptimized} and compression strategy
- * {@link TreeCompressionStrategyExtended.CompressedIncremental}.
+ * {@link TreeCompressionStrategy.CompressedIncremental}.
  *
- * The {@link incrementalAllowedTypesMetadata} will be replaced with a specialized metadata property once the
+ * @privateRemarks
+ * The {@link incrementalSummaryHint} will be replaced with a specialized metadata property once the
  * incremental summary feature and APIs are stabilized.
+ *
+ * @alpha
  */
-export function getShouldIncrementallySummarizeAllowedTypes(
+export function incrementalEncodingPolicyForAllowedTypes(
 	rootSchema: TreeSchema,
 ): IncrementalEncodingPolicy {
-	return (
-		targetNodeIdentifier: TreeNodeSchemaIdentifier | undefined,
-		targetFieldKey: FieldKey,
-	) => {
+	return (targetNodeIdentifier: string | undefined, targetFieldKey: string) => {
 		if (targetNodeIdentifier === undefined) {
 			// Root fields cannot be allowed types, so we don't incrementally summarize them.
 			return false;
@@ -85,7 +85,9 @@ export function getShouldIncrementallySummarizeAllowedTypes(
 		}
 
 		if (isObjectNodeSchema(targetNode)) {
-			const targetPropertyKey = targetNode.storedKeyToPropertyKey.get(targetFieldKey);
+			const targetPropertyKey = targetNode.storedKeyToPropertyKey.get(
+				targetFieldKey as FieldKey,
+			);
 			if (targetPropertyKey !== undefined) {
 				const fieldSchema = targetNode.fields.get(targetPropertyKey);
 				if (fieldSchema !== undefined) {

package/src/simple-tree/api/index.ts

@@ -164,7 +164,7 @@ export { generateSchemaFromSimpleSchema } from "./schemaFromSimple.js";
 export { toSimpleTreeSchema } from "./viewSchemaToSimpleSchema.js";
 export type { TreeChangeEvents } from "./treeChangeEvents.js";
 export {
-	getShouldIncrementallySummarizeAllowedTypes,
+	incrementalEncodingPolicyForAllowedTypes,
 	incrementalSummaryHint,
 } from "./incrementalAllowedTypes.js";
 export {

package/src/simple-tree/api/tree.ts

@@ -449,7 +449,7 @@ export interface SchemaCompatibilityStatus {
 	 *
 	 * In these cases `canUpgrade` and `isEquivalent` will be false.
 	 *
-	 * When the documents allowed by the view schema is a strict superset of those by the stored schema,
+	 * When the set of documents allowed by the view schema is a strict superset of those allowed by the stored schema,
 	 * `canView` is false because writes to the document using the view schema could make the document violate its stored schema.
 	 * In this case, the stored schema could be updated to match the provided view schema, allowing read-write access to the tree.
 	 * See {@link SchemaCompatibilityStatus.canUpgrade}.

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

@@ -294,6 +294,7 @@ export class TreeNodeKernel {
 	}
 }
 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
 const kernelEvents = ["childrenChangedAfterBatch", "subtreeChangedAfterBatch"] as const;
 
 type KernelEvents = Pick<AnchorEvents, (typeof kernelEvents)[number]>;

package/src/simple-tree/index.ts

@@ -186,7 +186,7 @@ export {
 	KeyEncodingOptions,
 	type TreeParsingOptions,
 	incrementalSummaryHint,
-	getShouldIncrementallySummarizeAllowedTypes,
+	incrementalEncodingPolicyForAllowedTypes,
 	type SchemaFactory_base,
 } from "./api/index.js";
 export type {

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

@@ -578,6 +578,7 @@ const TreeNodeWithArrayFeatures = (() => {
  */
 /* eslint-disable @typescript-eslint/explicit-member-accessibility, @typescript-eslint/no-explicit-any */
 // prettier-ignore
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
 declare abstract class NodeWithArrayFeatures<Input, T>
 	extends TreeNodeValid<Input>
 	implements Pick<readonly T[], (typeof arrayPrototypeKeys)[number]>
@@ -1326,6 +1327,7 @@ function arrayChildToFlexTree(
  */
 function arrayToFlexContent(data: FactoryContent, schema: ArrayNodeSchema): FlexContent {
 	if (!(typeof data === "object" && data !== null && Symbol.iterator in data)) {
+		// eslint-disable-next-line @typescript-eslint/no-base-to-string
 		throw new UsageError(`Input data is incompatible with Array schema: ${data}`);
 	}
 

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/no-empty-object-type, @typescript-eslint/ban-types
+		? // eslint-disable-next-line @typescript-eslint/no-empty-object-type
 			{}
 		: {
 				-readonly [Property in keyof T]: Property extends string
@@ -651,6 +651,7 @@ function objectToFlexContent(
 		Symbol.iterator in data ||
 		isFluidHandle(data)
 	) {
+		// eslint-disable-next-line @typescript-eslint/no-base-to-string
 		throw new UsageError(`Input data is incompatible with Object schema: ${data}`);
 	}
 

package/src/treeFactory.ts

@@ -148,6 +148,16 @@ export function configuredSharedTreeBetaLegacy(
 	return configuredSharedTree(options);
 }
 
+/**
+ * {@link configuredSharedTreeBeta} but including the alpha {@link SharedTreeOptions}.
+ * @alpha
+ */
+export function configuredSharedTreeAlpha(
+	options: SharedTreeOptions,
+): SharedObjectKind<ITree> {
+	return configuredSharedTree(options);
+}
+
 /**
  * {@link configuredSharedTreeBetaLegacy} but including `@alpha` options.
  *
@@ -195,10 +205,9 @@ export function resolveOptions(options: SharedTreeOptions): SharedTreeOptionsInt
 	const internal: SharedTreeOptionsInternal = {
 		...resolveSharedBranchesOptions(options.enableSharedBranches),
 	};
-	copyProperty(options, "forest", internal);
-	copyProperty(options, "jsonValidator", internal);
-	copyProperty(options, "minVersionForCollab", internal);
-	copyProperty(options, "treeEncodeType", internal);
+	for (const optionName of Object.keys(options)) {
+		copyProperty(options, optionName, internal);
+	}
 	return internal;
 }
 

package/src/util/breakable.ts

@@ -171,10 +171,10 @@ export function throwIfBroken<
 	return replacementMethod as Target;
 }
 
-// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type, @typescript-eslint/ban-types
+// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
 type PossiblyNamedFunction = Function & { displayName?: undefined | string };
 
-// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type, @typescript-eslint/ban-types
+// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
 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/no-unsafe-function-type, @typescript-eslint/ban-types
+// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
 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/no-unsafe-function-type, @typescript-eslint/ban-types
+// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
 function isBreaker(f: Function): boolean {
 	return isBreakerSymbol in (f as unknown as Record<typeof isBreakerSymbol, true>);
 }

package/src/util/typeCheckTests.ts

@@ -6,7 +6,6 @@
 // These tests include making sure some banned types (like `{}`) work correctly,
 // and are authored with awareness of the issues with these types.
 
-/* eslint-disable @typescript-eslint/ban-types */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-extraneous-class */