@fluidframework/tree 2.71.0 → 2.73.0

package/src/feature-libraries/optional-field/optionalFieldCodecV1.ts

@@ -1,208 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-
-import { assert } from "@fluidframework/core-utils/internal";
-import type { TAnySchema } from "@sinclair/typebox";
-
-import type { IJsonCodec } from "../../codec/index.js";
-import type {
-	ChangeEncodingContext,
-	EncodedRevisionTag,
-	RevisionTag,
-} from "../../core/index.js";
-import type { Mutable } from "../../util/index.js";
-import { makeChangeAtomIdCodec } from "../changeAtomIdCodec.js";
-import {
-	EncodedNodeChangeset,
-	type FieldChangeEncodingContext,
-} from "../modular-schema/index.js";
-
-import { EncodedOptionalChangeset, EncodedRegisterId } from "./optionalFieldChangeFormatV1.js";
-import type { Move, OptionalChangeset, RegisterId } from "./optionalFieldChangeTypes.js";
-
-function makeRegisterIdCodec(
-	revisionTagCodec: IJsonCodec<
-		RevisionTag,
-		EncodedRevisionTag,
-		EncodedRevisionTag,
-		ChangeEncodingContext
-	>,
-): IJsonCodec<RegisterId, EncodedRegisterId, EncodedRegisterId, ChangeEncodingContext> {
-	const changeAtomIdCodec = makeChangeAtomIdCodec(revisionTagCodec);
-	return {
-		encode: (registerId: RegisterId, context: ChangeEncodingContext) => {
-			if (registerId === "self") {
-				return null;
-			}
-			return changeAtomIdCodec.encode(registerId, context);
-		},
-		decode: (registerId: EncodedRegisterId, context: ChangeEncodingContext) => {
-			if (registerId === null) {
-				return "self";
-			}
-			return changeAtomIdCodec.decode(registerId, context);
-		},
-		encodedSchema: EncodedRegisterId,
-	};
-}
-
-export function makeOptionalFieldCodec(
-	revisionTagCodec: IJsonCodec<
-		RevisionTag,
-		EncodedRevisionTag,
-		EncodedRevisionTag,
-		ChangeEncodingContext
-	>,
-): IJsonCodec<
-	OptionalChangeset,
-	EncodedOptionalChangeset<TAnySchema>,
-	EncodedOptionalChangeset<TAnySchema>,
-	FieldChangeEncodingContext
-> {
-	const registerIdCodec = makeRegisterIdCodec(revisionTagCodec);
-
-	return {
-		encode: (change: OptionalChangeset, context: FieldChangeEncodingContext) => {
-			const encoded: EncodedOptionalChangeset<TAnySchema> = {};
-			encoded.m = [];
-
-			if (change.valueReplace !== undefined) {
-				if (change.valueReplace.src !== undefined) {
-					encoded.m.push([
-						registerIdCodec.encode(change.valueReplace.src, context.baseContext),
-						registerIdCodec.encode("self", context.baseContext),
-						true,
-					]);
-				}
-
-				// When the source of the replace is "self", the destination is a reserved ID that will only be used if
-				// the tree in the field is concurrently replaced.
-				if (change.valueReplace.isEmpty || change.valueReplace.src === "self") {
-					encoded.d = registerIdCodec.encode(change.valueReplace.dst, context.baseContext);
-				} else {
-					encoded.m.push([
-						registerIdCodec.encode("self", context.baseContext),
-						registerIdCodec.encode(change.valueReplace.dst, context.baseContext),
-						false,
-					]);
-				}
-			}
-
-			for (const [src, dst] of change.moves) {
-				encoded.m.push([
-					registerIdCodec.encode(src, context.baseContext),
-					registerIdCodec.encode(dst, context.baseContext),
-					true,
-				]);
-			}
-
-			if (encoded.m.length === 0) {
-				delete encoded.m;
-			}
-
-			if (change.childChanges.length > 0) {
-				encoded.c = [];
-				for (const [id, childChange] of change.childChanges) {
-					encoded.c.push([
-						registerIdCodec.encode(id, context.baseContext),
-						context.encodeNode(childChange),
-					]);
-				}
-			}
-
-			return encoded;
-		},
-
-		decode: (
-			encoded: EncodedOptionalChangeset<TAnySchema>,
-			context: FieldChangeEncodingContext,
-		) => {
-			// The register that the node in the optional field is moved to upon detach
-			let detached: RegisterId | undefined;
-			// The register that the node is moved from to upon attaching that node in the optional field
-			let attached: RegisterId | undefined;
-			const moves: Move[] = [];
-			if (encoded.m !== undefined) {
-				for (const [encodedSrc, encodedDst] of encoded.m) {
-					const src = registerIdCodec.decode(encodedSrc, context.baseContext);
-					const dst = registerIdCodec.decode(encodedDst, context.baseContext);
-					if (src === "self" || dst === "self") {
-						if (src === "self") {
-							assert(detached === undefined, 0x8d0 /* Multiple detached nodes */);
-							detached = dst;
-						}
-						if (dst === "self") {
-							assert(attached === undefined, 0x8d1 /* Multiple attached nodes */);
-							attached = src;
-						}
-					} else {
-						moves.push([src, dst]);
-					}
-				}
-			}
-			const decoded: Mutable<OptionalChangeset> = {
-				moves,
-				childChanges:
-					encoded.c?.map(([id, encodedChange]) => [
-						registerIdCodec.decode(id, context.baseContext),
-						context.decodeNode(encodedChange),
-					]) ?? [],
-			};
-
-			if (detached !== undefined && attached !== undefined) {
-				if (detached === "self" || attached === "self") {
-					assert(
-						encoded.d !== undefined,
-						0x8d2 /* Invalid change: pin must have a reserved detach ID */,
-					);
-					const reserved = registerIdCodec.decode(encoded.d, context.baseContext);
-					assert(reserved !== "self", 0x8d3 /* Invalid reserved detach ID */);
-					decoded.valueReplace = { isEmpty: false, dst: reserved, src: "self" };
-				} else {
-					assert(
-						encoded.d === undefined,
-						0x8d4 /* Invalid change: unexpected reserved detach ID on a change that detaches a node from the field */,
-					);
-					decoded.valueReplace = {
-						isEmpty: false,
-						dst: detached,
-						src: attached,
-					};
-				}
-			} else if (attached !== undefined) {
-				assert(
-					encoded.d !== undefined,
-					0x8d5 /* Invalid change: attach must have a reserved detach ID */,
-				);
-				const reserved = registerIdCodec.decode(encoded.d, context.baseContext);
-				assert(reserved !== "self", 0x8d6 /* Invalid reserved detach ID */);
-				decoded.valueReplace = {
-					isEmpty: true,
-					dst: reserved,
-					src: attached,
-				};
-			} else if (detached !== undefined) {
-				assert(
-					encoded.d === undefined,
-					0x8d7 /* Invalid change: unexpected reserved detach ID on a change that detaches a node from the field */,
-				);
-				assert(detached !== "self", 0x8d8 /* Invalid detach ID */);
-				decoded.valueReplace = {
-					isEmpty: false,
-					dst: detached,
-				};
-			} else if (encoded.d !== undefined) {
-				const detachId = registerIdCodec.decode(encoded.d, context.baseContext);
-				assert(detachId !== "self", 0x8d9 /* Invalid detach ID */);
-				decoded.valueReplace = {
-					isEmpty: true,
-					dst: detachId,
-				};
-			}
-			return decoded;
-		},
-		encodedSchema: EncodedOptionalChangeset(EncodedNodeChangeset),
-	};
-}

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

@@ -1,344 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-
-import { assert, unreachableCase, fail } from "@fluidframework/core-utils/internal";
-import type { TAnySchema } from "@sinclair/typebox";
-
-import { DiscriminatedUnionDispatcher, type IJsonCodec } from "../../codec/index.js";
-import type {
-	ChangeEncodingContext,
-	ChangesetLocalId,
-	EncodedRevisionTag,
-	RevisionTag,
-} from "../../core/index.js";
-import { type JsonCompatibleReadOnly, type Mutable, brand } from "../../util/index.js";
-import { makeChangeAtomIdCodec } from "../changeAtomIdCodec.js";
-import {
-	EncodedNodeChangeset,
-	type FieldChangeEncodingContext,
-} from "../modular-schema/index.js";
-
-import {
-	Changeset as ChangesetSchema,
-	DetachIdOverrideType,
-	type Encoded,
-} from "./formatV1.js";
-import {
-	type Attach,
-	type AttachAndDetach,
-	type CellId,
-	type Changeset,
-	type Detach,
-	type Insert,
-	type Mark,
-	type MarkEffect,
-	type MoveIn,
-	type MoveOut,
-	NoopMarkType,
-	type Remove,
-	type Rename,
-} from "./types.js";
-import { isNoopMark, normalizeCellRename } from "./utils.js";
-
-export function makeV1Codec(
-	revisionTagCodec: IJsonCodec<
-		RevisionTag,
-		EncodedRevisionTag,
-		EncodedRevisionTag,
-		ChangeEncodingContext
-	>,
-): IJsonCodec<
-	Changeset,
-	JsonCompatibleReadOnly,
-	JsonCompatibleReadOnly,
-	FieldChangeEncodingContext
-> {
-	const changeAtomIdCodec = makeChangeAtomIdCodec(revisionTagCodec);
-	const markEffectCodec: IJsonCodec<
-		MarkEffect,
-		Encoded.MarkEffect,
-		Encoded.MarkEffect,
-		ChangeEncodingContext
-	> = {
-		encode(effect: MarkEffect, context: ChangeEncodingContext): Encoded.MarkEffect {
-			function encodeRevision(
-				revision: RevisionTag | undefined,
-			): EncodedRevisionTag | undefined {
-				if (revision === undefined || revision === context.revision) {
-					return undefined;
-				}
-
-				return revisionTagCodec.encode(revision, context);
-			}
-
-			const type = effect.type;
-			switch (type) {
-				case "MoveIn":
-					return {
-						moveIn: {
-							revision: encodeRevision(effect.revision),
-							finalEndpoint:
-								effect.finalEndpoint === undefined
-									? undefined
-									: changeAtomIdCodec.encode(effect.finalEndpoint, context),
-							id: effect.id,
-						},
-					};
-				case "Insert":
-					return {
-						insert: {
-							revision: encodeRevision(effect.revision),
-							id: effect.id,
-						},
-					};
-				case "Remove":
-					return {
-						delete: {
-							revision: encodeRevision(effect.revision),
-							idOverride:
-								effect.idOverride === undefined
-									? undefined
-									: {
-											// An arbitrary override type is chosen here. It only had an impact on lineage logic which was not enabled in V1.
-											type: DetachIdOverrideType.Unattach,
-											id: cellIdCodec.encode(effect.idOverride, context),
-										},
-							id: effect.id,
-						},
-					};
-				case "MoveOut":
-					return {
-						moveOut: {
-							revision: encodeRevision(effect.revision),
-							finalEndpoint:
-								effect.finalEndpoint === undefined
-									? undefined
-									: changeAtomIdCodec.encode(effect.finalEndpoint, context),
-							idOverride:
-								effect.idOverride === undefined
-									? undefined
-									: {
-											// An arbitrary override type is chosen here. It only had an impact on lineage logic which was not enabled in V1.
-											type: DetachIdOverrideType.Unattach,
-											id: cellIdCodec.encode(effect.idOverride, context),
-										},
-							id: effect.id,
-						},
-					};
-				case "AttachAndDetach":
-					return {
-						attachAndDetach: {
-							attach: markEffectCodec.encode(effect.attach, context) as Encoded.Attach,
-							detach: markEffectCodec.encode(effect.detach, context) as Encoded.Detach,
-						},
-					};
-				case "Rename":
-					// In documents generated by clients on release >=2.2 (i.e., running the code from the PR that added this comment),
-					// renames are encoded as AttachAndDetach with a special id.
-					// This ensures forward-compatibility of clients on release <=2.1 with documents/ops generated by clients on release >=2.2.
-					return markEffectCodec.encode(
-						{
-							type: "AttachAndDetach",
-							attach: { type: "MoveIn", id: renameLocalId },
-							detach: { type: "MoveOut", id: renameLocalId, idOverride: effect.idOverride },
-						},
-						context,
-					);
-				case NoopMarkType:
-					fail(0xb2b /* Mark type: NoopMarkType should not be encoded. */);
-				default:
-					unreachableCase(type);
-			}
-		},
-		decode(encoded: Encoded.MarkEffect, context: ChangeEncodingContext): MarkEffect {
-			return decoderLibrary.dispatch(encoded, context);
-		},
-	};
-
-	function decodeRevision(
-		encodedRevision: EncodedRevisionTag | undefined,
-		context: ChangeEncodingContext,
-	): RevisionTag {
-		if (encodedRevision === undefined) {
-			assert(context.revision !== undefined, 0x965 /* Implicit revision should be provided */);
-			return context.revision;
-		}
-
-		return revisionTagCodec.decode(encodedRevision, context);
-	}
-
-	const decoderLibrary = new DiscriminatedUnionDispatcher<
-		Encoded.MarkEffect,
-		/* args */ [context: ChangeEncodingContext],
-		MarkEffect
-	>({
-		moveIn(encoded: Encoded.MoveIn, context: ChangeEncodingContext): MoveIn {
-			const { id, finalEndpoint, revision } = encoded;
-			const mark: MoveIn = {
-				type: "MoveIn",
-				id,
-			};
-
-			mark.revision = decodeRevision(revision, context);
-			if (finalEndpoint !== undefined) {
-				mark.finalEndpoint = changeAtomIdCodec.decode(finalEndpoint, context);
-			}
-			return mark;
-		},
-		insert(encoded: Encoded.Insert, context: ChangeEncodingContext): Insert {
-			const { id, revision } = encoded;
-			const mark: Insert = {
-				type: "Insert",
-				id,
-			};
-
-			mark.revision = decodeRevision(revision, context);
-			return mark;
-		},
-		delete(encoded: Encoded.Remove, context: ChangeEncodingContext): Remove {
-			const { id, revision, idOverride } = encoded;
-			const mark: Mutable<Remove> = {
-				type: "Remove",
-				id,
-			};
-
-			mark.revision = decodeRevision(revision, context);
-			if (idOverride !== undefined) {
-				mark.idOverride = cellIdCodec.decode(idOverride.id, context);
-			}
-			return mark;
-		},
-		moveOut(encoded: Encoded.MoveOut, context: ChangeEncodingContext): MoveOut {
-			const { id, finalEndpoint, idOverride, revision } = encoded;
-			const mark: Mutable<MoveOut> = {
-				type: "MoveOut",
-				id,
-			};
-
-			mark.revision = decodeRevision(revision, context);
-			if (finalEndpoint !== undefined) {
-				mark.finalEndpoint = changeAtomIdCodec.decode(finalEndpoint, context);
-			}
-			if (idOverride !== undefined) {
-				mark.idOverride = cellIdCodec.decode(idOverride.id, context);
-			}
-
-			return mark;
-		},
-		attachAndDetach(
-			encoded: Encoded.AttachAndDetach,
-			context: ChangeEncodingContext,
-		): AttachAndDetach | Rename {
-			const attach = decoderLibrary.dispatch(encoded.attach, context) as Attach;
-			const detach = decoderLibrary.dispatch(encoded.detach, context) as Detach;
-			// In documents generated by clients on release >=2.2 (i.e., running the code from the PR that added this comment),
-			// renames are encoded as AttachAndDetach with a special id.
-			// This ensures forward-compatibility of clients on release <=2.1 with documents/ops generated by clients on release >=2.2.
-			if (attach.id === renameLocalId) {
-				assert(detach.idOverride !== undefined, 0x9f7 /* Rename must have idOverride */);
-				return {
-					type: "Rename",
-					idOverride: detach.idOverride,
-				};
-			}
-			return {
-				type: "AttachAndDetach",
-				attach,
-				detach,
-			};
-		},
-	});
-
-	const cellIdCodec: IJsonCodec<
-		CellId,
-		Encoded.CellId,
-		Encoded.CellId,
-		ChangeEncodingContext
-	> = {
-		encode: (cellId: CellId, context: ChangeEncodingContext): Encoded.CellId => {
-			const encoded: Encoded.CellId = {
-				atom: changeAtomIdCodec.encode(cellId, context),
-			};
-			return encoded;
-		},
-		decode: ({ atom }: Encoded.CellId, context: ChangeEncodingContext): CellId => {
-			return changeAtomIdCodec.decode(atom, context);
-		},
-	};
-
-	/**
-	 * If we want to make the node change aspect of this codec more type-safe, we could adjust generics
-	 * to be in terms of the schema rather than the concrete type of the node change.
-	 */
-	type NodeChangeSchema = TAnySchema;
-
-	return {
-		encode: (
-			changeset: Changeset,
-			context: FieldChangeEncodingContext,
-		): JsonCompatibleReadOnly & Encoded.Changeset<NodeChangeSchema> => {
-			const jsonMarks: Encoded.Changeset<NodeChangeSchema> = [];
-			for (const mark of changeset) {
-				const encodedMark: Encoded.Mark<NodeChangeSchema> = {
-					count: mark.count,
-				};
-				if (!isNoopMark(mark)) {
-					encodedMark.effect = markEffectCodec.encode(mark, context.baseContext);
-				}
-				if (mark.cellId !== undefined) {
-					encodedMark.cellId = cellIdCodec.encode(mark.cellId, context.baseContext);
-				}
-				if (mark.changes !== undefined) {
-					encodedMark.changes = context.encodeNode(mark.changes);
-				}
-				jsonMarks.push(encodedMark);
-			}
-			return jsonMarks;
-		},
-		decode: (
-			changeset: Encoded.Changeset<NodeChangeSchema>,
-			context: FieldChangeEncodingContext,
-		): Changeset => {
-			const marks: Changeset = [];
-			for (const mark of changeset) {
-				const decodedMark: Mark = {
-					count: mark.count,
-				};
-
-				if (mark.effect !== undefined) {
-					Object.assign(decodedMark, markEffectCodec.decode(mark.effect, context.baseContext));
-				}
-				if (mark.cellId !== undefined) {
-					decodedMark.cellId = cellIdCodec.decode(mark.cellId, context.baseContext);
-				}
-				// Type deduction wrongly narrows the type of `decodedMark` to `NoopMark & HasMarkFields`.
-				// We declare a new casted copy of `decodedMark` to recover the correct type.
-				let decodedMark2 = decodedMark as Mark;
-				if (decodedMark2.cellId !== undefined && decodedMark2.type === "AttachAndDetach") {
-					// In documents generated by clients on release <=2.1 (i.e., not running the code from the PR that added this comment),
-					// rename-like AttachAndDetach marks are not normalized to Rename marks thus requiring this normalization step.
-					// This ensures backward compatibility with documents generated by clients on release <=2.1.
-					decodedMark2 = normalizeCellRename(
-						decodedMark2.cellId,
-						decodedMark2.count,
-						decodedMark2.attach,
-						decodedMark2.detach,
-					);
-				}
-				if (mark.changes !== undefined) {
-					decodedMark2.changes = context.decodeNode(mark.changes);
-				}
-				marks.push(decodedMark2);
-			}
-			return marks;
-		},
-		encodedSchema: ChangesetSchema(EncodedNodeChangeset),
-	};
-}
-
-/**
- * Arbitrary ID that is used to indicate a Rename effect.
- */
-const renameLocalId: ChangesetLocalId = brand(-1);