@fluidframework/tree 2.82.0 → 2.90.0-378676

package/docs/main/sequence-field/move-composition.md

@@ -1,46 +0,0 @@
-# Move Composition
-
-A move of a node in a sequence field is represented by a pair of marks:
-a MoveOut at the initial location of the node to be moved, and a MoveIn at the location the node will be moved to.
-Each of these move pairs is identified by a ChangeAtomId.
-
-For various reasons, we preserve the intermediate move steps when composing a series of moves of the same node.
-Note the cell IDs are changed at the intermediate locations, so it is necessary to record some information about the intermediate steps.
-The composition of move1, moving a node from A to B, with move2, moving the same node from B to C (where A, B, and C are distinct cells),
-is represented with MoveOut1 at A, MoveIn2 at C, and AttachAndDetach(MoveIn1, MoveOut2) at B.
-We say that the composite change in this example contains a single move chain which consists of move1 and move2 as its move atoms.
-Note that a move chain may have only a single move atom.
-Composition of move chains may lead to the creation of arbitrarily long move chains.
-
-To allow efficient processing a move chain without having to traverse all its elements,
-in a chain consisting of more than one atom each endpoint (the first MoveOut and last MoveIn of the chain)
-will have its `finalEndpoint` field set to the ID of the other endpoint.
-
-When composing a move chain which starts at A and ends at B with a move chain which starts at B and ends at C, we call cell B the pivot of the chains.
-Each of the chains will have a endpoint at B, which we call the inner endpoint. The other endpoint of each chain is called the outer endpoint.
-
-In the common case when composing chains we notice that the chains are moving the same node when we encounter the inner endpoints.
-Each inner endpoint stores the ID of the corresponding outer endpoint.
-We set `MoveEffect.endpoint` for each outer endpoint to be the other outer endpoint.
-When we encounter each outer endpoint we update its `finalEndpoint` to `MoveEffect.endpoint`,
-unless `MoveEffect.truncatedEndpoint` is also defined (see below), in which case we use that instead.
-
-A special case arises when the location outer endpoint of one of the move chains is the location of an intermediate move in the other move chain.
-For example, the first chain might consist of move1 from A to B, and the second chain consist of move2 from B to A and move3 from B to C.
-The endpoints of the composed move are at the locations of the outer endpoints (A and C) as usual,
-but the starting endpoint of the composed move will be the second chain's MoveOut (move3) at A instead of the first chain's outer endpoint at A (the MoveOut from move1).
-This follows from the rules for composing attach and detach marks at the same cell (A in this case).
-We can think of the composed move chain as truncating from `A -move1-> B -move2-> A -move3-> C` to `A -move3-> C`.
-We call the MoveOut from move3 the truncated endpoint and the MoveOut from move1 the redundant endpoint.
-We call the MoveIn from move3 the ordinary endpoint.
-
-We detect that we are in such a scenario when processing the location of the redundant and truncated endpoints.
-We set `MoveEffect.truncatedEndpointForInner` for the inner endpoint from the redundant move chain to the ID of the truncated endpoint.
-If we already know the ordinary endpoint (because we already processed the pivot and have `MoveEffect.endpoint` for the redundant endpoint)
-we also set `MoveEffect.truncatedEndpoint` for the ordinary endpoint.
-
-When processing the pivot, if `MoveEffect.truncatedEndpoint` is defined for an inner endpoint,
-we copy its value into `MoveEffect.truncatedEndpoint` for the corresponding outer endpoint (which will be the ordinary endpoint).
-
-Note that there are two places where we may set `truncatedEndpoint` on the ordinary endpoint.
-This is necessary for composition to complete with a single amend pass regardless of whether we happen to process the pivot or the truncation point first.

package/lib/extensibleSchemaUnion.d.ts

@@ -1,72 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import type { TreeNodeSchema, TreeNodeFromImplicitAllowedTypes, TreeFieldFromImplicitField, SchemaFactoryBeta } from "./simple-tree/index.js";
-/**
- * Utilities for creating extensible schema unions.
- * @remarks
- * Use {@link ExtensibleSchemaUnion.extensibleSchemaUnion} to create the union schema.
- *
- * Unlike a schema union created using {@link SchemaStaticsBeta.staged | staged} allowed types, this union allows for unknown future types to exist in addition to the known types.
- * This allows for faster roll-outs of new types without waiting for old clients to be updated to be aware of them.
- * This does mean however that old clients may see types they do not know about, which are simply exposed as `undefined` children.
- *
- * `staged` types are lower overhead, and might gain support for `unknown` types in the future, so prefer them when possible.
- * This is simply an alternative for when future compatibility with unknown types is required.
- * It is built on top of the existing {@link ObjectSchemaOptions.allowUnknownOptionalFields | allowUnknownOptionalFields} feature.
- *
- * @example
- * ```typescript
- * const sf = new SchemaFactoryBeta("extensibleSchemaUnionExample.items");
- * class ItemA extends sf.object("A", { x: sf.string }) {}
- * class ItemB extends sf.object("B", { x: sf.number }) {}
- *
- * class AnyItem extends ExtensibleSchemaUnion.extensibleSchemaUnion(
- * 	[ItemA, ItemB], // Future versions may add more members here
- * 	sf,
- * 	"ExtensibleUnion",
- * ) {}
- * // Instances of the union are created using `create`.
- * const anyItem = AnyItem.create(new ItemA({ x: "hello" }));
- * // Reading the content from the union is done via `child`,
- * // which can be `undefined` to handle the case where a future version of this schema allows a type unknown to the current version.
- * const childNode: ItemA | ItemB | undefined = anyItem.child;
- * // To determine which member of the union was present, its schema can be inspected:
- * const aSchema = Tree.schema(childNode ?? assert.fail("No child"));
- * assert.equal(aSchema, ItemA);
- * ```
- * @alpha
- */
-export declare namespace ExtensibleSchemaUnion {
-    /**
-     * Members for classes created by {@link ExtensibleSchemaUnion.extensibleSchemaUnion}.
-     * @alpha
-     */
-    interface Members<T> {
-        /**
-         * The child wrapped by this node, which is has one of the type allowed by the union,
-         * or `undefined` if the type is one which was added to the union by a future version of this schema.
-         */
-        readonly child: T | undefined;
-    }
-    /**
-     * Statics for classes created by {@link ExtensibleSchemaUnion.extensibleSchemaUnion}.
-     * @alpha
-     */
-    interface Statics<T extends readonly TreeNodeSchema[]> {
-        /**
-         * Create a {@link TreeNode} with `this` schema which wraps the provided child to create the union.
-         */
-        create<TThis extends TreeNodeSchema>(this: TThis, child: TreeNodeFromImplicitAllowedTypes<T>): TreeFieldFromImplicitField<TThis>;
-    }
-    /**
-     * Create an extensible schema union which currently supports the types in `types`,
-     * but tolerates collaboration with future versions that may include additional types.
-     * @remarks
-     * See {@link ExtensibleSchemaUnion} for an example use.
-     * @alpha
-     */
-    function extensibleSchemaUnion<const T extends readonly TreeNodeSchema[], const TScope extends string, const TName extends string>(types: T, inputSchemaFactory: SchemaFactoryBeta<TScope>, name: TName): Statics<T> & import("./simple-tree/index.js").TreeNodeSchemaCore<import("./simple-tree/index.js").ScopedSchemaName<`com.fluidframework.extensibleSchemaUnion<${TScope}>`, TName>, import("./simple-tree/index.js").NodeKind, false, unknown, never, unknown> & (new (data: import("./simple-tree/index.js").InternalTreeNode) => Members<TreeNodeFromImplicitAllowedTypes<T>> & import("./simple-tree/index.js").TreeNode & import("./simple-tree/index.js").WithType<import("./simple-tree/index.js").ScopedSchemaName<`com.fluidframework.extensibleSchemaUnion<${TScope}>`, TName>, import("./simple-tree/index.js").NodeKind, unknown>);
-}
-//# sourceMappingURL=extensibleSchemaUnion.d.ts.map

package/lib/extensibleSchemaUnion.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"extensibleSchemaUnion.d.ts","sourceRoot":"","sources":["../src/extensibleSchemaUnion.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EACX,cAAc,EACd,gCAAgC,EAChC,0BAA0B,EAG1B,iBAAiB,EACjB,MAAM,wBAAwB,CAAC;AAShC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,yBAAiB,qBAAqB,CAAC;IACtC;;;OAGG;IACH,UAAiB,OAAO,CAAC,CAAC;QACzB;;;WAGG;QACH,QAAQ,CAAC,KAAK,EAAE,CAAC,GAAG,SAAS,CAAC;KAC9B;IAED;;;OAGG;IACH,UAAiB,OAAO,CAAC,CAAC,SAAS,SAAS,cAAc,EAAE;QAC3D;;WAEG;QACH,MAAM,CAAC,KAAK,SAAS,cAAc,EAClC,IAAI,EAAE,KAAK,EACX,KAAK,EAAE,gCAAgC,CAAC,CAAC,CAAC,GACxC,0BAA0B,CAAC,KAAK,CAAC,CAAC;KACrC;IAED;;;;;;OAMG;IAEH,SAAgB,qBAAqB,CACpC,KAAK,CAAC,CAAC,SAAS,SAAS,cAAc,EAAE,EACzC,KAAK,CAAC,MAAM,SAAS,MAAM,EAC3B,KAAK,CAAC,KAAK,SAAS,MAAM,EACzB,KAAK,EAAE,CAAC,EAAE,kBAAkB,EAAE,iBAAiB,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,KAAK,+mBAqCrE;CACD"}

package/lib/extensibleSchemaUnion.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"extensibleSchemaUnion.js","sourceRoot":"","sources":["../src/extensibleSchemaUnion.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,wBAAwB,CAAC;AASzD,OAAO,EACN,2CAA2C,EAC3C,8BAA8B,EAC9B,aAAa,EACb,QAAQ,GACR,MAAM,wBAAwB,CAAC;AAGhC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,KAAW,qBAAqB,CA6ErC;AA7ED,WAAiB,qBAAqB;IA2BrC;;;;;;OAMG;IACH,4EAA4E;IAC5E,SAAgB,qBAAqB,CAInC,KAAQ,EAAE,kBAA6C,EAAE,IAAW;QACrE,MAAM,MAAM,GAAwC,EAAE,CAAC;QACvD,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;YAC1B,MAAM,CAAC,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC,GAAG,aAAa,CAAC,QAAQ,CAAC,IAAI,EAAE,EAAE,GAAG,EAAE,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC;QACxF,CAAC;QACD,MAAM,aAAa,GAAG,2CAA2C,CAChE,kBAAkB,EAClB,uBAAuB,CACvB,CAAC;QACF,MAAM,KACL,SAAQ,aAAa,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,0BAA0B,EAAE,IAAI,EAAE,CAAC;YAGhF,IAAW,KAAK;gBACf,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;oBACtD,OAAO,KAA4C,CAAC;gBACrD,CAAC;gBACD,OAAO,SAAS,CAAC;YAClB,CAAC;YAEM,MAAM,CAAC,MAAM,CAEnB,KAA0C;gBAE1C,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;gBAClC,OAAO,QAAQ,CAAC,MAAM,CAAC,IAAI,EAAE;oBAC5B,CAAC,IAAI,MAAM,CAAC,UAAU,EAAE,CAAC,EAAE,KAAK;iBAIhC,CAAC,CAAC;YACJ,CAAC;SACD;QACD,OAAO,8BAA8B,EAGlC,CAAC,KAAK,CAAC,CAAC;IACZ,CAAC;IAzCe,2CAAqB,wBAyCpC,CAAA;AACF,CAAC,EA7EgB,qBAAqB,KAArB,qBAAqB,QA6ErC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { TreeAlpha, Tree } from \"./shared-tree/index.js\";\nimport type {\n\tTreeNodeSchema,\n\tTreeNodeFromImplicitAllowedTypes,\n\tTreeFieldFromImplicitField,\n\tImplicitFieldSchema,\n\tInsertableTreeFieldFromImplicitField,\n\tSchemaFactoryBeta,\n} from \"./simple-tree/index.js\";\nimport {\n\tcreateCustomizedFluidFrameworkScopedFactory,\n\teraseSchemaDetailsSubclassable,\n\tSchemaFactory,\n\tTreeBeta,\n} from \"./simple-tree/index.js\";\nimport type { UnionToIntersection } from \"./util/index.js\";\n\n/**\n * Utilities for creating extensible schema unions.\n * @remarks\n * Use {@link ExtensibleSchemaUnion.extensibleSchemaUnion} to create the union schema.\n *\n * Unlike a schema union created using {@link SchemaStaticsBeta.staged | staged} allowed types, this union allows for unknown future types to exist in addition to the known types.\n * This allows for faster roll-outs of new types without waiting for old clients to be updated to be aware of them.\n * This does mean however that old clients may see types they do not know about, which are simply exposed as `undefined` children.\n *\n * `staged` types are lower overhead, and might gain support for `unknown` types in the future, so prefer them when possible.\n * This is simply an alternative for when future compatibility with unknown types is required.\n * It is built on top of the existing {@link ObjectSchemaOptions.allowUnknownOptionalFields | allowUnknownOptionalFields} feature.\n *\n * @example\n * ```typescript\n * const sf = new SchemaFactoryBeta(\"extensibleSchemaUnionExample.items\");\n * class ItemA extends sf.object(\"A\", { x: sf.string }) {}\n * class ItemB extends sf.object(\"B\", { x: sf.number }) {}\n *\n * class AnyItem extends ExtensibleSchemaUnion.extensibleSchemaUnion(\n * \t[ItemA, ItemB], // Future versions may add more members here\n * \tsf,\n * \t\"ExtensibleUnion\",\n * ) {}\n * // Instances of the union are created using `create`.\n * const anyItem = AnyItem.create(new ItemA({ x: \"hello\" }));\n * // Reading the content from the union is done via `child`,\n * // which can be `undefined` to handle the case where a future version of this schema allows a type unknown to the current version.\n * const childNode: ItemA | ItemB | undefined = anyItem.child;\n * // To determine which member of the union was present, its schema can be inspected:\n * const aSchema = Tree.schema(childNode ?? assert.fail(\"No child\"));\n * assert.equal(aSchema, ItemA);\n * ```\n * @alpha\n */\nexport namespace ExtensibleSchemaUnion {\n\t/**\n\t * Members for classes created by {@link ExtensibleSchemaUnion.extensibleSchemaUnion}.\n\t * @alpha\n\t */\n\texport interface Members<T> {\n\t\t/**\n\t\t * The child wrapped by this node, which is has one of the type allowed by the union,\n\t\t * or `undefined` if the type is one which was added to the union by a future version of this schema.\n\t\t */\n\t\treadonly child: T | undefined;\n\t}\n\n\t/**\n\t * Statics for classes created by {@link ExtensibleSchemaUnion.extensibleSchemaUnion}.\n\t * @alpha\n\t */\n\texport interface Statics<T extends readonly TreeNodeSchema[]> {\n\t\t/**\n\t\t * Create a {@link TreeNode} with `this` schema which wraps the provided child to create the union.\n\t\t */\n\t\tcreate<TThis extends TreeNodeSchema>(\n\t\t\tthis: TThis,\n\t\t\tchild: TreeNodeFromImplicitAllowedTypes<T>,\n\t\t): TreeFieldFromImplicitField<TThis>;\n\t}\n\n\t/**\n\t * Create an extensible schema union which currently supports the types in `types`,\n\t * but tolerates collaboration with future versions that may include additional types.\n\t * @remarks\n\t * See {@link ExtensibleSchemaUnion} for an example use.\n\t * @alpha\n\t */\n\t// eslint-disable-next-line @typescript-eslint/explicit-function-return-type\n\texport function extensibleSchemaUnion<\n\t\tconst T extends readonly TreeNodeSchema[],\n\t\tconst TScope extends string,\n\t\tconst TName extends string,\n\t>(types: T, inputSchemaFactory: SchemaFactoryBeta<TScope>, name: TName) {\n\t\tconst record: Record<string, ImplicitFieldSchema> = {};\n\t\tfor (const type of types) {\n\t\t\trecord[`_${type.identifier}`] = SchemaFactory.optional(type, { key: type.identifier });\n\t\t}\n\t\tconst schemaFactory = createCustomizedFluidFrameworkScopedFactory(\n\t\t\tinputSchemaFactory,\n\t\t\t\"extensibleSchemaUnion\",\n\t\t);\n\t\tclass Union\n\t\t\textends schemaFactory.object(name, record, { allowUnknownOptionalFields: true })\n\t\t\timplements Members<TreeNodeFromImplicitAllowedTypes<T>>\n\t\t{\n\t\t\tpublic get child(): TreeNodeFromImplicitAllowedTypes<T> | undefined {\n\t\t\t\tfor (const [_key, child] of TreeAlpha.children(this)) {\n\t\t\t\t\treturn child as TreeNodeFromImplicitAllowedTypes<T>;\n\t\t\t\t}\n\t\t\t\treturn undefined;\n\t\t\t}\n\n\t\t\tpublic static create<TThis extends TreeNodeSchema>(\n\t\t\t\tthis: TThis,\n\t\t\t\tchild: TreeNodeFromImplicitAllowedTypes<T>,\n\t\t\t): TreeFieldFromImplicitField<TThis> {\n\t\t\t\tconst schema = Tree.schema(child);\n\t\t\t\treturn TreeBeta.create(this, {\n\t\t\t\t\t[`_${schema.identifier}`]: child,\n\t\t\t\t} as unknown as InsertableTreeFieldFromImplicitField<\n\t\t\t\t\tTThis,\n\t\t\t\t\tUnionToIntersection<TThis>\n\t\t\t\t>);\n\t\t\t}\n\t\t}\n\t\treturn eraseSchemaDetailsSubclassable<\n\t\t\tMembers<TreeNodeFromImplicitAllowedTypes<T>>,\n\t\t\tStatics<T>\n\t\t>()(Union);\n\t}\n}\n"]}

package/lib/feature-libraries/sequence-field/relevantRemovedRoots.d.ts

@@ -1,9 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import { type DeltaDetachedNodeId } from "../../core/index.js";
-import type { RelevantRemovedRootsFromChild } from "../modular-schema/index.js";
-import type { Changeset } from "./types.js";
-export declare function relevantRemovedRoots(change: Changeset, relevantRemovedRootsFromChild: RelevantRemovedRootsFromChild): Iterable<DeltaDetachedNodeId>;
-//# sourceMappingURL=relevantRemovedRoots.d.ts.map

package/lib/feature-libraries/sequence-field/relevantRemovedRoots.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"relevantRemovedRoots.d.ts","sourceRoot":"","sources":["../../../src/feature-libraries/sequence-field/relevantRemovedRoots.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,EAAE,KAAK,mBAAmB,EAAkB,MAAM,qBAAqB,CAAC;AAE/E,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,4BAA4B,CAAC;AAEhF,OAAO,KAAK,EAAE,SAAS,EAAQ,MAAM,YAAY,CAAC;AAGlD,wBAAiB,oBAAoB,CACpC,MAAM,EAAE,SAAS,EACjB,6BAA6B,EAAE,6BAA6B,GAC1D,QAAQ,CAAC,mBAAmB,CAAC,CAgB/B"}

package/lib/feature-libraries/sequence-field/relevantRemovedRoots.js

@@ -1,46 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import { assert } from "@fluidframework/core-utils/internal";
-import { offsetDetachId } from "../../core/index.js";
-import { nodeIdFromChangeAtom } from "../deltaUtils.js";
-import { isAttachAndDetachEffect, isDetachOfRemovedNodes, isInsert } from "./utils.js";
-export function* relevantRemovedRoots(change, relevantRemovedRootsFromChild) {
-    for (const mark of change) {
-        if (refersToRelevantRemovedRoots(mark)) {
-            assert(mark.cellId !== undefined, 0x81d /* marks referring to removed trees must have an assigned cell ID */);
-            const nodeId = nodeIdFromChangeAtom(mark.cellId);
-            for (let i = 0; i < mark.count; i += 1) {
-                yield offsetDetachId(nodeId, i);
-            }
-        }
-        if (mark.changes !== undefined) {
-            yield* relevantRemovedRootsFromChild(mark.changes);
-        }
-    }
-}
-function refersToRelevantRemovedRoots(mark) {
-    if (mark.cellId !== undefined) {
-        const effect = isAttachAndDetachEffect(mark) ? mark.attach : mark;
-        if (isInsert(effect)) {
-            // This tree is being inserted or restored.
-            return true;
-        }
-        else if (isDetachOfRemovedNodes(mark)) {
-            // This removed tree is being restored as part of a detach.
-            return true;
-        }
-        if (mark.changes !== undefined) {
-            // This removed tree is being edited.
-            // Note: there is a possibility that the child changes only affect a distant descendant
-            // which may have been removed from this (removed) subtree. In such a case, this tree is not truly
-            // relevant, but including it is the conservative thing to do.
-            // In the future, we may represent changes to removed trees using the ID of the lowest removed
-            // ancestor, which would allow us to avoid including such trees when they truly are not needed.
-            return true;
-        }
-    }
-    return false;
-}
-//# sourceMappingURL=relevantRemovedRoots.js.map

package/lib/feature-libraries/sequence-field/relevantRemovedRoots.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"relevantRemovedRoots.js","sourceRoot":"","sources":["../../../src/feature-libraries/sequence-field/relevantRemovedRoots.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,qCAAqC,CAAC;AAE7D,OAAO,EAA4B,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC/E,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAIxD,OAAO,EAAE,uBAAuB,EAAE,sBAAsB,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEvF,MAAM,SAAS,CAAC,CAAC,oBAAoB,CACpC,MAAiB,EACjB,6BAA4D;IAE5D,KAAK,MAAM,IAAI,IAAI,MAAM,EAAE,CAAC;QAC3B,IAAI,4BAA4B,CAAC,IAAI,CAAC,EAAE,CAAC;YACxC,MAAM,CACL,IAAI,CAAC,MAAM,KAAK,SAAS,EACzB,KAAK,CAAC,oEAAoE,CAC1E,CAAC;YACF,MAAM,MAAM,GAAG,oBAAoB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YACjD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;gBACxC,MAAM,cAAc,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;YACjC,CAAC;QACF,CAAC;QACD,IAAI,IAAI,CAAC,OAAO,KAAK,SAAS,EAAE,CAAC;YAChC,KAAK,CAAC,CAAC,6BAA6B,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACpD,CAAC;IACF,CAAC;AACF,CAAC;AAED,SAAS,4BAA4B,CAAC,IAAU;IAC/C,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;QAC/B,MAAM,MAAM,GAAG,uBAAuB,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC;QAClE,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;YACtB,2CAA2C;YAC3C,OAAO,IAAI,CAAC;QACb,CAAC;aAAM,IAAI,sBAAsB,CAAC,IAAI,CAAC,EAAE,CAAC;YACzC,2DAA2D;YAC3D,OAAO,IAAI,CAAC;QACb,CAAC;QACD,IAAI,IAAI,CAAC,OAAO,KAAK,SAAS,EAAE,CAAC;YAChC,qCAAqC;YACrC,uFAAuF;YACvF,kGAAkG;YAClG,8DAA8D;YAC9D,8FAA8F;YAC9F,+FAA+F;YAC/F,OAAO,IAAI,CAAC;QACb,CAAC;IACF,CAAC;IACD,OAAO,KAAK,CAAC;AACd,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { assert } from \"@fluidframework/core-utils/internal\";\n\nimport { type DeltaDetachedNodeId, offsetDetachId } from \"../../core/index.js\";\nimport { nodeIdFromChangeAtom } from \"../deltaUtils.js\";\nimport type { RelevantRemovedRootsFromChild } from \"../modular-schema/index.js\";\n\nimport type { Changeset, Mark } from \"./types.js\";\nimport { isAttachAndDetachEffect, isDetachOfRemovedNodes, isInsert } from \"./utils.js\";\n\nexport function* relevantRemovedRoots(\n\tchange: Changeset,\n\trelevantRemovedRootsFromChild: RelevantRemovedRootsFromChild,\n): Iterable<DeltaDetachedNodeId> {\n\tfor (const mark of change) {\n\t\tif (refersToRelevantRemovedRoots(mark)) {\n\t\t\tassert(\n\t\t\t\tmark.cellId !== undefined,\n\t\t\t\t0x81d /* marks referring to removed trees must have an assigned cell ID */,\n\t\t\t);\n\t\t\tconst nodeId = nodeIdFromChangeAtom(mark.cellId);\n\t\t\tfor (let i = 0; i < mark.count; i += 1) {\n\t\t\t\tyield offsetDetachId(nodeId, i);\n\t\t\t}\n\t\t}\n\t\tif (mark.changes !== undefined) {\n\t\t\tyield* relevantRemovedRootsFromChild(mark.changes);\n\t\t}\n\t}\n}\n\nfunction refersToRelevantRemovedRoots(mark: Mark): boolean {\n\tif (mark.cellId !== undefined) {\n\t\tconst effect = isAttachAndDetachEffect(mark) ? mark.attach : mark;\n\t\tif (isInsert(effect)) {\n\t\t\t// This tree is being inserted or restored.\n\t\t\treturn true;\n\t\t} else if (isDetachOfRemovedNodes(mark)) {\n\t\t\t// This removed tree is being restored as part of a detach.\n\t\t\treturn true;\n\t\t}\n\t\tif (mark.changes !== undefined) {\n\t\t\t// This removed tree is being edited.\n\t\t\t// Note: there is a possibility that the child changes only affect a distant descendant\n\t\t\t// which may have been removed from this (removed) subtree. In such a case, this tree is not truly\n\t\t\t// relevant, but including it is the conservative thing to do.\n\t\t\t// In the future, we may represent changes to removed trees using the ID of the lowest removed\n\t\t\t// ancestor, which would allow us to avoid including such trees when they truly are not needed.\n\t\t\treturn true;\n\t\t}\n\t}\n\treturn false;\n}\n"]}

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

@@ -1,57 +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 DeltaDetachedNodeId, offsetDetachId } from "../../core/index.js";
-import { nodeIdFromChangeAtom } from "../deltaUtils.js";
-import type { RelevantRemovedRootsFromChild } from "../modular-schema/index.js";
-
-import type { Changeset, Mark } from "./types.js";
-import { isAttachAndDetachEffect, isDetachOfRemovedNodes, isInsert } from "./utils.js";
-
-export function* relevantRemovedRoots(
-	change: Changeset,
-	relevantRemovedRootsFromChild: RelevantRemovedRootsFromChild,
-): Iterable<DeltaDetachedNodeId> {
-	for (const mark of change) {
-		if (refersToRelevantRemovedRoots(mark)) {
-			assert(
-				mark.cellId !== undefined,
-				0x81d /* marks referring to removed trees must have an assigned cell ID */,
-			);
-			const nodeId = nodeIdFromChangeAtom(mark.cellId);
-			for (let i = 0; i < mark.count; i += 1) {
-				yield offsetDetachId(nodeId, i);
-			}
-		}
-		if (mark.changes !== undefined) {
-			yield* relevantRemovedRootsFromChild(mark.changes);
-		}
-	}
-}
-
-function refersToRelevantRemovedRoots(mark: Mark): boolean {
-	if (mark.cellId !== undefined) {
-		const effect = isAttachAndDetachEffect(mark) ? mark.attach : mark;
-		if (isInsert(effect)) {
-			// This tree is being inserted or restored.
-			return true;
-		} else if (isDetachOfRemovedNodes(mark)) {
-			// This removed tree is being restored as part of a detach.
-			return true;
-		}
-		if (mark.changes !== undefined) {
-			// This removed tree is being edited.
-			// Note: there is a possibility that the child changes only affect a distant descendant
-			// which may have been removed from this (removed) subtree. In such a case, this tree is not truly
-			// relevant, but including it is the conservative thing to do.
-			// In the future, we may represent changes to removed trees using the ID of the lowest removed
-			// ancestor, which would allow us to avoid including such trees when they truly are not needed.
-			return true;
-		}
-	}
-	return false;
-}