@fluidframework/tree 2.53.0-350190 → 2.53.1

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

@@ -850,19 +850,19 @@ type Insertable<T extends ImplicitAllowedTypes> = readonly (
 	| IterableTreeArrayContent<InsertableTreeNodeFromImplicitAllowedTypes<T>>
 )[];
 
-abstract class CustomArrayNodeBase<const T extends ImplicitAnnotatedAllowedTypes>
+abstract class CustomArrayNodeBase<const T extends ImplicitAllowedTypes>
 	extends TreeNodeWithArrayFeatures<
-		Iterable<InsertableTreeNodeFromImplicitAllowedTypes<UnannotateImplicitAllowedTypes<T>>>,
-		TreeNodeFromImplicitAllowedTypes<UnannotateImplicitAllowedTypes<T>>
+		Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T>>,
+		TreeNodeFromImplicitAllowedTypes<T>
 	>
-	implements TreeArrayNode<UnannotateImplicitAllowedTypes<T>>
+	implements TreeArrayNode<T>
 {
 	// Indexing must be provided by subclass.
-	[k: number]: TreeNodeFromImplicitAllowedTypes<UnannotateImplicitAllowedTypes<T>>;
+	[k: number]: TreeNodeFromImplicitAllowedTypes<T>;
 
 	public static readonly kind = NodeKind.Array;
 
-	protected abstract get simpleSchema(): T;
+	protected abstract get childSchema(): ImplicitAnnotatedAllowedTypes;
 	protected abstract get allowedTypes(): ReadonlySet<TreeNodeSchema>;
 
 	public abstract override get [typeSchemaSymbol](): TreeNodeSchemaClass<
@@ -871,16 +871,12 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAnnotatedAllowedTypes
 	>;
 
 	public constructor(
-		input?:
-			| Iterable<InsertableTreeNodeFromImplicitAllowedTypes<UnannotateImplicitAllowedTypes<T>>>
-			| InternalTreeNode,
+		input?: Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T>> | InternalTreeNode,
 	) {
 		super(input ?? []);
 	}
 
-	#mapTreesFromFieldData(
-		value: Insertable<UnannotateImplicitAllowedTypes<T>>,
-	): FlexibleFieldContent {
+	#mapTreesFromFieldData(value: Insertable<T>): FlexibleFieldContent {
 		const sequenceField = getSequenceField(this);
 		const content = value as readonly (
 			| InsertableContent
@@ -893,16 +889,22 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAnnotatedAllowedTypes
 
 		const kernel = getKernel(this);
 		const flexContext = kernel.getOrCreateInnerNode().context;
-		assert(flexContext === kernel.context.flexContext, "Expected flexContext to match");
+		assert(
+			flexContext === kernel.context.flexContext,
+			0xc14 /* Expected flexContext to match */,
+		);
 		const innerSchema = kernel.context.flexContext.schema.nodeSchema.get(
 			brand(kernel.schema.identifier),
 		);
-		assert(innerSchema instanceof ObjectNodeStoredSchema, "Expected ObjectNodeStoredSchema");
+		assert(
+			innerSchema instanceof ObjectNodeStoredSchema,
+			0xc15 /* Expected ObjectNodeStoredSchema */,
+		);
 		const fieldSchema = innerSchema.getFieldSchema(EmptyKey);
 
 		const mapTrees = prepareArrayContentForInsertion(
 			contentArray,
-			this.simpleSchema,
+			this.childSchema,
 			sequenceField.context,
 			fieldSchema.types,
 		);
@@ -923,9 +925,7 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAnnotatedAllowedTypes
 		return fail(0xadb /* Proxy should intercept length */);
 	}
 
-	public [Symbol.iterator](): IterableIterator<
-		TreeNodeFromImplicitAllowedTypes<UnannotateImplicitAllowedTypes<T>>
-	> {
+	public [Symbol.iterator](): IterableIterator<TreeNodeFromImplicitAllowedTypes<T>> {
 		return this.values();
 	}
 
@@ -937,9 +937,9 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAnnotatedAllowedTypes
 	}
 
 	public at(
-		this: TreeArrayNode<UnannotateImplicitAllowedTypes<T>>,
+		this: TreeArrayNode<T>,
 		index: number,
-	): TreeNodeFromImplicitAllowedTypes<UnannotateImplicitAllowedTypes<T>> | undefined {
+	): TreeNodeFromImplicitAllowedTypes<T> | undefined {
 		const field = getSequenceField(this);
 		const val = field.boxedAt(index);
 
@@ -947,23 +947,18 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAnnotatedAllowedTypes
 			return val;
 		}
 
-		return getOrCreateNodeFromInnerNode(val) as TreeNodeFromImplicitAllowedTypes<
-			UnannotateImplicitAllowedTypes<T>
-		>;
+		return getOrCreateNodeFromInnerNode(val) as TreeNodeFromImplicitAllowedTypes<T>;
 	}
-	public insertAt(
-		index: number,
-		...value: Insertable<UnannotateImplicitAllowedTypes<T>>
-	): void {
+	public insertAt(index: number, ...value: Insertable<T>): void {
 		const field = getSequenceField(this);
 		validateIndex(index, field, "insertAt", true);
 		const content = this.#mapTreesFromFieldData(value);
 		field.editor.insert(index, content);
 	}
-	public insertAtStart(...value: Insertable<UnannotateImplicitAllowedTypes<T>>): void {
+	public insertAtStart(...value: Insertable<T>): void {
 		this.insertAt(0, ...value);
 	}
-	public insertAtEnd(...value: Insertable<UnannotateImplicitAllowedTypes<T>>): void {
+	public insertAtEnd(...value: Insertable<T>): void {
 		this.insertAt(this.length, ...value);
 	}
 	public removeAt(index: number): void {
@@ -1045,7 +1040,7 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAnnotatedAllowedTypes
 		const kernel = getKernel(this);
 		const destinationStored = (
 			kernel.context.flexContext.schema.nodeSchema.get(brand(kernel.schema.identifier)) ??
-			fail("missing schema for array node")
+			fail(0xc16 /* missing schema for array node */)
 		).getFieldSchema(EmptyKey).types;
 		const sourceField = source !== undefined ? getSequenceField(source) : destinationField;
 
@@ -1116,14 +1111,12 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAnnotatedAllowedTypes
 		}
 	}
 
-	public values(): IterableIterator<
-		TreeNodeFromImplicitAllowedTypes<UnannotateImplicitAllowedTypes<T>>
-	> {
+	public values(): IterableIterator<TreeNodeFromImplicitAllowedTypes<T>> {
 		return this.generateValues(getKernel(this).generationNumber);
 	}
 	private *generateValues(
 		initialLastUpdatedStamp: number,
-	): Generator<TreeNodeFromImplicitAllowedTypes<UnannotateImplicitAllowedTypes<T>>> {
+	): Generator<TreeNodeFromImplicitAllowedTypes<T>> {
 		const kernel = getKernel(this);
 		if (initialLastUpdatedStamp !== kernel.generationNumber) {
 			throw new UsageError(`Concurrent editing and iteration is not allowed.`);
@@ -1177,7 +1170,7 @@ export function arraySchema<
 
 	// This class returns a proxy from its constructor to handle numeric indexing.
 	// Alternatively it could extend a normal class which gets tons of numeric properties added.
-	class Schema extends CustomArrayNodeBase<T> {
+	class Schema extends CustomArrayNodeBase<UnannotateImplicitAllowedTypes<T>> {
 		public static override prepareInstance<T2>(
 			this: typeof TreeNodeValid<T2>,
 			instance: TreeNodeValid<T2>,
@@ -1268,7 +1261,7 @@ export function arraySchema<
 			return Schema.constructorCached?.constructor as unknown as Output;
 		}
 
-		protected get simpleSchema(): T {
+		protected get childSchema(): T {
 			return info;
 		}
 		protected get allowedTypes(): ReadonlySet<TreeNodeSchema> {

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

@@ -215,7 +215,10 @@ abstract class CustomMapNodeBase<const T extends ImplicitAllowedTypes> extends T
 		const innerSchema = this.innerNode.context.schema.nodeSchema.get(
 			brand(kernel.schema.identifier),
 		);
-		assert(innerSchema instanceof MapNodeStoredSchema, "Expected MapNodeStoredSchema");
+		assert(
+			innerSchema instanceof MapNodeStoredSchema,
+			0xc17 /* Expected MapNodeStoredSchema */,
+		);
 
 		const mapTree = prepareForInsertion(
 			value as InsertableContent | undefined,

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

@@ -295,7 +295,10 @@ function createProxyHandler(
 			const innerNode = getOrCreateInnerNode(proxy);
 
 			const innerSchema = innerNode.context.schema.nodeSchema.get(brand(schema.identifier));
-			assert(innerSchema instanceof ObjectNodeStoredSchema, "Expected ObjectNodeStoredSchema");
+			assert(
+				innerSchema instanceof ObjectNodeStoredSchema,
+				0xc18 /* Expected ObjectNodeStoredSchema */,
+			);
 
 			setField(
 				innerNode.getBoxed(fieldInfo.storedKey),
@@ -606,7 +609,7 @@ export function objectSchema<
 					for (const fieldSchema of flexKeyMap.values()) {
 						assert(
 							fieldSchema.schema instanceof FieldSchemaAlpha,
-							"Expected FieldSchemaAlpha",
+							0xc19 /* Expected FieldSchemaAlpha */,
 						);
 						fields.set(
 							brand(fieldSchema.storedKey),

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

@@ -126,7 +126,10 @@ function createRecordNodeProxy(
 			const field = innerNode.getBoxed(brand(key)) as FlexTreeOptionalField;
 			const kernel = getKernel(receiver);
 			const innerSchema = innerNode.context.schema.nodeSchema.get(brand(schema.identifier));
-			assert(innerSchema instanceof MapNodeStoredSchema, "Expected MapNodeStoredSchema");
+			assert(
+				innerSchema instanceof MapNodeStoredSchema,
+				0xc1a /* Expected MapNodeStoredSchema */,
+			);
 
 			const mapTree = prepareForInsertion(
 				value,

package/src/tableSchema.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { oob } from "@fluidframework/core-utils/internal";
+import { assert, oob } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
 import { Tree, TreeAlpha } from "./shared-tree/index.js";
@@ -780,8 +780,20 @@ export namespace System_TableSchema {
 						`Specified column with ID "${columnId}" does not exist in the table.`,
 					);
 				}
-				this.columns.removeAt(index);
-				return column as ColumnValueType;
+				assert(column !== undefined, 0xc10 /* column should not be undefined */);
+
+				Tree.runTransaction(this, () => {
+					// Remove the corresponding cell from all rows.
+					for (const row of this.rows) {
+						// TypeScript is unable to narrow the row type correctly here, hence the cast.
+						// See: https://github.com/microsoft/TypeScript/issues/52144
+						(row as RowValueType).removeCell(column);
+					}
+
+					this.columns.removeAt(index);
+				});
+
+				return column;
 			}
 
 			public removeAllColumns(): ColumnValueType[] {
@@ -1081,29 +1093,6 @@ export namespace System_TableSchema {
  * });
  * ```
  *
- * @example Removing column and cells in a transaction
- *
- * When removing a column, if you wish to ensure that all of its corresponding cells are also removed (and not
- * orphaned), you can remove the column and all of the relevant cells in a transaction.
- * Note that there are performance implications to this.
- *
- * ```typescript
- * // Remove column1 and all of its cells.
- * // The "transaction" method will ensure that all changes are applied atomically.
- * Tree.runTransaction(table, () => {
- * 	// Remove column1.
- * 	table.removeColumn(column1);
- *
- * 	// Remove the cell at column1 for each row.
- * 	for (const row of table.rows) {
- * 		table.removeCell({
- * 			column: column1,
- * 			row,
- * 		});
- * 	}
- * });
- * ```
- *
  * @privateRemarks
  * The above examples are backed by tests in `tableSchema.spec.ts`.
  * Those tests and these examples should be kept in-sync to ensure that the examples are correct.
@@ -1530,14 +1519,16 @@ export namespace TableSchema {
 
 		/**
 		 * Removes the specified column from the table.
-		 *
 		 * @remarks
-		 * Note: this does not remove any cells from the table's rows.
-		 * To remove the corresponding cells, use {@link TableSchema.Table.removeCell}.
+		 * Also removes any corresponding cells from the table's rows.
+		 *
+		 * Note: this operation can be slow for tables with many rows.
+		 * We are actively working on improving the performance of this operation, but for now it may have a negative
+		 * impact on performance.
 		 *
 		 * @param column - The {@link TableSchema.Column | column} or {@link TableSchema.Column.id | column ID} to remove.
 		 * @throws Throws an error if the column is not in the table.
-		 * @privateRemarks TODO (future): Actually remove corresponding cells from table rows.
+		 * In this case, no columns are removed.
 		 */
 		removeColumn(
 			column: string | TreeNodeFromImplicitAllowedTypes<TColumn>,
@@ -1545,10 +1536,12 @@ export namespace TableSchema {
 
 		/**
 		 * Removes 0 or more columns from the table.
-		 *
 		 * @remarks
-		 * Note: this does not remove any cells from the table's rows.
-		 * To remove the corresponding cells, use {@link TableSchema.Table.removeCell}.
+		 * Also removes any corresponding cells from the table's rows.
+		 *
+		 * Note: this operation can be slow for tables with many rows.
+		 * We are actively working on improving the performance of this operation, but for now it may have a negative
+		 * impact on performance.
 		 *
 		 * @param columns - The columns to remove.
 		 * @throws Throws an error if any of the columns are not in the table.
@@ -1561,8 +1554,11 @@ export namespace TableSchema {
 		 * Removes 0 or more columns from the table.
 		 *
 		 * @remarks
-		 * Note: this does not remove any cells from the table's rows.
-		 * To remove the corresponding cells, use {@link TableSchema.Table.removeCell}.
+		 * Also removes any corresponding cells from the table's rows.
+		 *
+		 * Note: this operation can be slow for tables with many rows.
+		 * We are actively working on improving the performance of this operation, but for now it may have a negative
+		 * impact on performance.
 		 *
 		 * @param columns - The columns to remove, specified by their {@link TableSchema.Column.id}.
 		 * @throws Throws an error if any of the columns are not in the table.
@@ -1572,6 +1568,14 @@ export namespace TableSchema {
 
 		/**
 		 * Removes all columns from the table.
+		 *
+		 * @remarks
+		 * Also removes any corresponding cells from the table's rows.
+		 *
+		 * Note: this operation can be slow for tables with many rows.
+		 * We are actively working on improving the performance of this operation, but for now it may have a negative
+		 * impact on performance.
+		 *
 		 * @returns The removed columns.
 		 */
 		removeAllColumns(): TreeNodeFromImplicitAllowedTypes<TColumn>[];
@@ -1580,6 +1584,7 @@ export namespace TableSchema {
 		 * Removes the specified row from the table.
 		 * @param row - The {@link TableSchema.Row | row} or {@link TableSchema.Row.id | row ID} to remove.
 		 * @throws Throws an error if the row is not in the table.
+		 * In this case, no rows are removed.
 		 */
 		removeRow(
 			row: string | TreeNodeFromImplicitAllowedTypes<TRow>,