@fluidframework/tree 2.0.0-rc.2.0.2 → 2.0.0-rc.3.0.0

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

@@ -3,18 +3,20 @@
  * Licensed under the MIT License.
  */
 
-import { unreachableCase } from "@fluidframework/core-utils";
-import { TAnySchema, Type } from "@sinclair/typebox";
-import { JsonCompatibleReadOnly, Mutable, fail } from "../../util/index.js";
+import { unreachableCase } from "@fluidframework/core-utils/internal";
+import { TAnySchema } from "@sinclair/typebox";
+
 import { DiscriminatedUnionDispatcher, IJsonCodec, makeCodecFamily } from "../../codec/index.js";
 import { ChangeEncodingContext, EncodedRevisionTag, RevisionTag } from "../../core/index.js";
+import { JsonCompatibleReadOnly, Mutable, fail } from "../../util/index.js";
 import { makeChangeAtomIdCodec } from "../changeAtomIdCodec.js";
+
+import { Changeset as ChangesetSchema, Encoded } from "./format.js";
 import {
 	Attach,
 	AttachAndDetach,
 	CellId,
 	Changeset,
-	Remove,
 	Detach,
 	Insert,
 	Mark,
@@ -22,34 +24,22 @@ import {
 	MoveIn,
 	MoveOut,
 	NoopMarkType,
+	Remove,
 } from "./types.js";
-import { Changeset as ChangesetSchema, Encoded } from "./format.js";
 import { isNoopMark } from "./utils.js";
+import { FieldChangeEncodingContext } from "../index.js";
+import { EncodedNodeChangeset } from "../modular-schema/index.js";
 
-export const sequenceFieldChangeCodecFactory = <TNodeChange>(
-	childCodec: IJsonCodec<
-		TNodeChange,
-		JsonCompatibleReadOnly,
-		JsonCompatibleReadOnly,
-		ChangeEncodingContext
-	>,
+export const sequenceFieldChangeCodecFactory = (
 	revisionTagCodec: IJsonCodec<
 		RevisionTag,
 		EncodedRevisionTag,
 		EncodedRevisionTag,
 		ChangeEncodingContext
 	>,
-) =>
-	makeCodecFamily<Changeset<TNodeChange>, ChangeEncodingContext>([
-		[0, makeV0Codec(childCodec, revisionTagCodec)],
-	]);
-function makeV0Codec<TNodeChange>(
-	childCodec: IJsonCodec<
-		TNodeChange,
-		JsonCompatibleReadOnly,
-		JsonCompatibleReadOnly,
-		ChangeEncodingContext
-	>,
+) => makeCodecFamily<Changeset, FieldChangeEncodingContext>([[1, makeV1Codec(revisionTagCodec)]]);
+
+function makeV1Codec(
 	revisionTagCodec: IJsonCodec<
 		RevisionTag,
 		EncodedRevisionTag,
@@ -57,10 +47,10 @@ function makeV0Codec<TNodeChange>(
 		ChangeEncodingContext
 	>,
 ): IJsonCodec<
-	Changeset<TNodeChange>,
+	Changeset,
 	JsonCompatibleReadOnly,
 	JsonCompatibleReadOnly,
-	ChangeEncodingContext
+	FieldChangeEncodingContext
 > {
 	const changeAtomIdCodec = makeChangeAtomIdCodec(revisionTagCodec);
 	const markEffectCodec: IJsonCodec<
@@ -295,8 +285,8 @@ function makeV0Codec<TNodeChange>(
 
 	return {
 		encode: (
-			changeset: Changeset<TNodeChange>,
-			context: ChangeEncodingContext,
+			changeset: Changeset,
+			context: FieldChangeEncodingContext,
 		): JsonCompatibleReadOnly & Encoded.Changeset<NodeChangeSchema> => {
 			const jsonMarks: Encoded.Changeset<NodeChangeSchema> = [];
 			for (const mark of changeset) {
@@ -304,13 +294,13 @@ function makeV0Codec<TNodeChange>(
 					count: mark.count,
 				};
 				if (!isNoopMark(mark)) {
-					encodedMark.effect = markEffectCodec.encode(mark, context);
+					encodedMark.effect = markEffectCodec.encode(mark, context.baseContext);
 				}
 				if (mark.cellId !== undefined) {
-					encodedMark.cellId = cellIdCodec.encode(mark.cellId, context);
+					encodedMark.cellId = cellIdCodec.encode(mark.cellId, context.baseContext);
 				}
 				if (mark.changes !== undefined) {
-					encodedMark.changes = childCodec.encode(mark.changes, context);
+					encodedMark.changes = context.encodeNode(mark.changes);
 				}
 				jsonMarks.push(encodedMark);
 			}
@@ -318,27 +308,30 @@ function makeV0Codec<TNodeChange>(
 		},
 		decode: (
 			changeset: Encoded.Changeset<NodeChangeSchema>,
-			context: ChangeEncodingContext,
-		): Changeset<TNodeChange> => {
-			const marks: Changeset<TNodeChange> = [];
+			context: FieldChangeEncodingContext,
+		): Changeset => {
+			const marks: Changeset = [];
 			for (const mark of changeset) {
-				const decodedMark: Mark<TNodeChange> = {
+				const decodedMark: Mark = {
 					count: mark.count,
 				};
 
 				if (mark.effect !== undefined) {
-					Object.assign(decodedMark, markEffectCodec.decode(mark.effect, context));
+					Object.assign(
+						decodedMark,
+						markEffectCodec.decode(mark.effect, context.baseContext),
+					);
 				}
 				if (mark.cellId !== undefined) {
-					decodedMark.cellId = cellIdCodec.decode(mark.cellId, context);
+					decodedMark.cellId = cellIdCodec.decode(mark.cellId, context.baseContext);
 				}
 				if (mark.changes !== undefined) {
-					decodedMark.changes = childCodec.decode(mark.changes, context);
+					decodedMark.changes = context.decodeNode(mark.changes);
 				}
 				marks.push(decodedMark);
 			}
 			return marks;
 		},
-		encodedSchema: ChangesetSchema(childCodec.encodedSchema ?? Type.Any()),
+		encodedSchema: ChangesetSchema(EncodedNodeChangeset),
 	};
 }

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

@@ -3,29 +3,30 @@
  * Licensed under the MIT License.
  */
 
-import { assert } from "@fluidframework/core-utils";
+import { assert } from "@fluidframework/core-utils/internal";
+
 import { ChangesetLocalId } from "../../core/index.js";
-import { FieldEditor } from "../modular-schema/index.js";
 import { brand } from "../../util/index.js";
+import { FieldEditor, NodeId } from "../modular-schema/index.js";
+
+import { MarkListFactory } from "./markListFactory.js";
 import {
 	CellId,
 	CellMark,
 	Changeset,
 	Insert,
 	Mark,
+	MarkList,
 	MoveId,
-	NodeChangeType,
-	MoveOut,
 	MoveIn,
-	MarkList,
+	MoveOut,
 } from "./types.js";
-import { MarkListFactory } from "./markListFactory.js";
 import { splitMark } from "./utils.js";
 
 export interface SequenceFieldEditor extends FieldEditor<Changeset> {
-	insert(index: number, count: number, firstId: ChangesetLocalId): Changeset<never>;
-	remove(index: number, count: number, id: ChangesetLocalId): Changeset<never>;
-	revive(index: number, count: number, detachEvent: CellId, isIntention?: true): Changeset<never>;
+	insert(index: number, count: number, firstId: ChangesetLocalId): Changeset;
+	remove(index: number, count: number, id: ChangesetLocalId): Changeset;
+	revive(index: number, count: number, detachEvent: CellId, isIntention?: true): Changeset;
 
 	/**
 	 *
@@ -33,31 +34,19 @@ export interface SequenceFieldEditor extends FieldEditor<Changeset> {
 	 * @param count - The number of nodes to move
 	 * @param destIndex - The index the nodes should be moved to, interpreted before detaching the moved nodes
 	 */
-	move(
-		sourceIndex: number,
-		count: number,
-		destIndex: number,
-		id: ChangesetLocalId,
-	): Changeset<never>;
-
-	moveOut(sourceIndex: number, count: number, id: ChangesetLocalId): Changeset<never>;
-	moveIn(destIndex: number, count: number, id: ChangesetLocalId): Changeset<never>;
-
-	return(
-		sourceIndex: number,
-		count: number,
-		destIndex: number,
-		detachEvent: CellId,
-	): Changeset<never>;
+	move(sourceIndex: number, count: number, destIndex: number, id: ChangesetLocalId): Changeset;
+
+	moveOut(sourceIndex: number, count: number, id: ChangesetLocalId): Changeset;
+	moveIn(destIndex: number, count: number, id: ChangesetLocalId): Changeset;
+
+	return(sourceIndex: number, count: number, destIndex: number, detachEvent: CellId): Changeset;
 }
 
 export const sequenceFieldEditor = {
-	buildChildChange: <TNodeChange = NodeChangeType>(
-		index: number,
-		change: TNodeChange,
-	): Changeset<TNodeChange> => markAtIndex(index, { count: 1, changes: change }),
-	insert: (index: number, count: number, firstId: ChangesetLocalId): Changeset<never> => {
-		const mark: CellMark<Insert, never> = {
+	buildChildChange: (index: number, change: NodeId): Changeset =>
+		markAtIndex(index, { count: 1, changes: change }),
+	insert: (index: number, count: number, firstId: ChangesetLocalId): Changeset => {
+		const mark: CellMark<Insert> = {
 			type: "Insert",
 			id: firstId,
 			count,
@@ -65,12 +54,12 @@ export const sequenceFieldEditor = {
 		};
 		return markAtIndex(index, mark);
 	},
-	remove: (index: number, count: number, id: ChangesetLocalId): Changeset<never> =>
+	remove: (index: number, count: number, id: ChangesetLocalId): Changeset =>
 		count === 0 ? [] : markAtIndex(index, { type: "Remove", count, id }),
 
-	revive: (index: number, count: number, detachEvent: CellId): Changeset<never> => {
+	revive: (index: number, count: number, detachEvent: CellId): Changeset => {
 		assert(detachEvent.revision !== undefined, 0x724 /* Detach event must have a revision */);
-		const mark: CellMark<Insert, never> = {
+		const mark: CellMark<Insert> = {
 			type: "Insert",
 			id: detachEvent.localId,
 			count,
@@ -79,19 +68,14 @@ export const sequenceFieldEditor = {
 		return count === 0 ? [] : markAtIndex(index, mark);
 	},
 
-	move(
-		sourceIndex: number,
-		count: number,
-		destIndex: number,
-		id: ChangesetLocalId,
-	): Changeset<never> {
-		const moveIn: Mark<never> = {
+	move(sourceIndex: number, count: number, destIndex: number, id: ChangesetLocalId): Changeset {
+		const moveIn: Mark = {
 			type: "MoveIn",
 			id,
 			count,
 			cellId: { localId: id },
 		};
-		const moveOut: Mark<never> = {
+		const moveOut: Mark = {
 			type: "MoveOut",
 			id,
 			count,
@@ -99,8 +83,8 @@ export const sequenceFieldEditor = {
 		return moveMarksToMarkList(sourceIndex, count, destIndex, moveOut, moveIn);
 	},
 
-	moveOut(sourceIndex: number, count: number, id: ChangesetLocalId): Changeset<never> {
-		const moveOut: Mark<never> = {
+	moveOut(sourceIndex: number, count: number, id: ChangesetLocalId): Changeset {
+		const moveOut: Mark = {
 			type: "MoveOut",
 			id,
 			count,
@@ -108,8 +92,8 @@ export const sequenceFieldEditor = {
 		return markAtIndex(sourceIndex, moveOut);
 	},
 
-	moveIn(destIndex: number, count: number, id: ChangesetLocalId): Changeset<never> {
-		const moveIn: Mark<never> = {
+	moveIn(destIndex: number, count: number, id: ChangesetLocalId): Changeset {
+		const moveIn: Mark = {
 			type: "MoveIn",
 			id,
 			count,
@@ -118,20 +102,15 @@ export const sequenceFieldEditor = {
 		return markAtIndex(destIndex, moveIn);
 	},
 
-	return(
-		sourceIndex: number,
-		count: number,
-		destIndex: number,
-		detachEvent: CellId,
-	): Changeset<never> {
+	return(sourceIndex: number, count: number, destIndex: number, detachEvent: CellId): Changeset {
 		const id = brand<MoveId>(0);
-		const moveOut: CellMark<MoveOut, never> = {
+		const moveOut: CellMark<MoveOut> = {
 			type: "MoveOut",
 			id,
 			count,
 		};
 
-		const returnTo: CellMark<MoveIn, never> = {
+		const returnTo: CellMark<MoveIn> = {
 			type: "MoveIn",
 			id,
 			count,
@@ -146,14 +125,14 @@ function moveMarksToMarkList(
 	sourceIndex: number,
 	count: number,
 	destIndex: number,
-	detach: CellMark<MoveOut, never>,
-	attach: CellMark<MoveIn, never>,
-): MarkList<never> {
+	detach: CellMark<MoveOut>,
+	attach: CellMark<MoveIn>,
+): MarkList {
 	if (count === 0) {
 		return [];
 	}
 	const firstIndexBeyondMoveOut = sourceIndex + count;
-	const marks = new MarkListFactory<never>();
+	const marks = new MarkListFactory();
 	marks.pushOffset(Math.min(sourceIndex, destIndex));
 	if (destIndex <= sourceIndex) {
 		// The destination is fully before the source
@@ -176,6 +155,6 @@ function moveMarksToMarkList(
 	return marks.list;
 }
 
-function markAtIndex<TNodeChange>(index: number, mark: Mark<TNodeChange>): Changeset<TNodeChange> {
+function markAtIndex(index: number, mark: Mark): Changeset {
 	return index === 0 ? [mark] : [{ count: index }, mark];
 }

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

@@ -3,36 +3,34 @@
  * Licensed under the MIT License.
  */
 
-import { assert, unreachableCase } from "@fluidframework/core-utils";
-import { Mutable } from "../../util/index.js";
+import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
+
 import {
 	DeltaDetachedNodeChanges,
 	DeltaDetachedNodeRename,
 	DeltaFieldChanges,
-	DeltaFieldMap,
 	DeltaMark,
 	TaggedChange,
 	areEqualChangeAtomIds,
-	makeDetachedNodeId,
 } from "../../core/index.js";
+import { Mutable } from "../../util/index.js";
 import { nodeIdFromChangeAtom } from "../deltaUtils.js";
+
+import { isMoveIn, isMoveOut } from "./moveEffectTable.js";
 import { MarkList, NoopMarkType } from "./types.js";
 import {
 	areInputCellsEmpty,
 	areOutputCellsEmpty,
+	getDetachedNodeId,
 	getEndpoint,
 	getInputCellId,
-	getOutputCellId,
 	isAttachAndDetachEffect,
-	getDetachOutputId,
 } from "./utils.js";
-import { isMoveIn, isMoveOut } from "./moveEffectTable.js";
+import { ToDelta } from "../modular-schema/index.js";
 
-export type ToDelta<TNodeChange> = (child: TNodeChange) => DeltaFieldMap;
-
-export function sequenceFieldToDelta<TNodeChange>(
-	{ change, revision }: TaggedChange<MarkList<TNodeChange>>,
-	deltaFromChild: ToDelta<TNodeChange>,
+export function sequenceFieldToDelta(
+	{ change, revision }: TaggedChange<MarkList>,
+	deltaFromChild: ToDelta,
 ): DeltaFieldChanges {
 	const local: DeltaMark[] = [];
 	const global: DeltaDetachedNodeChanges[] = [];
@@ -74,7 +72,7 @@ export function sequenceFieldToDelta<TNodeChange>(
 				continue;
 			}
 
-			const outputId = getOutputCellId(mark, revision, undefined);
+			const outputId = getDetachedNodeId(mark.detach, revision, undefined);
 			assert(
 				outputId !== undefined,
 				0x820 /* AttachAndDetach mark should have defined output cell ID */,
@@ -107,7 +105,7 @@ export function sequenceFieldToDelta<TNodeChange>(
 					break;
 				}
 				case "Remove": {
-					const newDetachId = getDetachOutputId(mark, revision, undefined);
+					const newDetachId = getDetachedNodeId(mark, revision, undefined);
 					if (inputCellId === undefined) {
 						deltaMark.detach = nodeIdFromChangeAtom(newDetachId);
 						local.push(deltaMark);
@@ -133,7 +131,9 @@ export function sequenceFieldToDelta<TNodeChange>(
 				}
 				case "MoveOut": {
 					// The move destination will look for the detach ID of the source, so we can ignore `finalEndpoint`.
-					const detachId = makeDetachedNodeId(mark.revision ?? revision, mark.id);
+					const detachId = nodeIdFromChangeAtom(
+						getDetachedNodeId(mark, revision, undefined),
+					);
 					if (inputCellId === undefined) {
 						deltaMark.detach = detachId;
 						local.push(deltaMark);

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

@@ -4,7 +4,7 @@
  */
 
 import { ChangeAtomId, ChangesetLocalId, RevisionTag } from "../../core/index.js";
-import { NodeChangeset } from "../modular-schema/index.js";
+import { NodeId } from "../index.js";
 import { DetachIdOverrideType } from "./format.js";
 
 export type CellCount = number;
@@ -25,8 +25,6 @@ export interface HasMoveId {
 	id: MoveId;
 }
 
-export type NodeChangeType = NodeChangeset;
-
 /**
  * Represents a position within a contiguous range of nodes detached by a single changeset.
  * Note that `LineageEvent`s with the same revision are not necessarily referring to the same detach.
@@ -75,7 +73,7 @@ export interface CellId extends ChangeAtomId, HasLineage {
 /**
  * Mark which targets a range of existing cells instead of creating new cells.
  */
-export interface HasMarkFields<TNodeChange = never> {
+export interface HasMarkFields {
 	/**
 	 * Describes the detach which last emptied the target cells,
 	 * or the attach which allocated the cells if the cells have never been filled.
@@ -83,7 +81,7 @@ export interface HasMarkFields<TNodeChange = never> {
 	 */
 	cellId?: CellId;
 
-	changes?: TNodeChange;
+	changes?: NodeId;
 
 	count: CellCount;
 }
@@ -205,10 +203,10 @@ export interface AttachAndDetach {
 
 export type MarkEffect = NoopMark | Attach | Detach | AttachAndDetach;
 
-export type CellMark<TMark, TNodeChange> = TMark & HasMarkFields<TNodeChange>;
+export type CellMark<TMark> = TMark & HasMarkFields;
 
-export type Mark<TNodeChange = NodeChangeType> = CellMark<MarkEffect, TNodeChange>;
+export type Mark = CellMark<MarkEffect>;
 
-export type MarkList<TNodeChange = NodeChangeType> = Mark<TNodeChange>[];
+export type MarkList = Mark[];
 
-export type Changeset<TNodeChange = NodeChangeType> = MarkList<TNodeChange>;
+export type Changeset = MarkList;