@fluidframework/tree 2.13.0 → 2.21.0

package/lib/feature-libraries/modular-schema/modularChangeFamily.js

@@ -4,14 +4,15 @@
  */
 import { assert } from "@fluidframework/core-utils/internal";
 import { BTree } from "@tylerbu/sorted-btree-es6";
-import { EditBuilder, isEmptyFieldChanges, makeDetachedNodeId, mapCursorField, replaceAtomRevisions, revisionMetadataSourceFromInfo, areEqualChangeAtomIds, areEqualChangeAtomIdOpts, tagChange, makeAnonChange, } from "../../core/index.js";
-import { brand, fail, idAllocatorFromMaxId, idAllocatorFromState, getOrAddInMapLazy, } from "../../util/index.js";
+import { EditBuilder, makeDetachedNodeId, mapCursorField, replaceAtomRevisions, revisionMetadataSourceFromInfo, areEqualChangeAtomIds, areEqualChangeAtomIdOpts, tagChange, makeAnonChange, newChangeAtomIdRangeMap, } from "../../core/index.js";
+import { brand, fail, idAllocatorFromMaxId, idAllocatorFromState, getOrAddInMapLazy, newTupleBTree, mergeTupleBTrees, RangeMap, } from "../../util/index.js";
 import { chunkFieldSingle, chunkTree, defaultChunkPolicy, } from "../chunked-forest/index.js";
 import { cursorForMapTreeNode, mapTreeFromCursor } from "../mapTreeCursor.js";
 import { CrossFieldTarget, getFirstFromCrossFieldMap, setInCrossFieldMap, } from "./crossFieldQueries.js";
 import { NodeAttachState, } from "./fieldChangeHandler.js";
 import { withEditor } from "./fieldKindWithEditor.js";
 import { convertGenericChange, genericFieldKind } from "./genericFieldKind.js";
+import { newCrossFieldKeyTable, } from "./modularChangeTypes.js";
 /**
  * Implementation of ChangeFamily which delegates work in a given field to the appropriate FieldKind
  * as determined by the schema.
@@ -101,7 +102,7 @@ export class ModularChangeFamily {
                 nodeChanges: newTupleBTree(),
                 nodeToParent: newTupleBTree(),
                 nodeAliases: newTupleBTree(),
-                crossFieldKeys: newTupleBTree(),
+                crossFieldKeys: newCrossFieldKeyTable(),
             };
         }
         else if (hasConflicts(change1)) {
@@ -120,20 +121,20 @@ export class ModularChangeFamily {
         // A collision for a node ID means that that node is referenced in both changesets
         // (since we assume that if two changesets use the same node ID they are referring to the same node),
         // therefore all collisions will be addressed when processing the intersection of the changesets.
-        const composedNodeChanges = brand(mergeBTrees(change1.nodeChanges, change2.nodeChanges));
-        const composedNodeToParent = brand(mergeBTrees(change1.nodeToParent, change2.nodeToParent));
-        const composedNodeAliases = brand(mergeBTrees(change1.nodeAliases, change2.nodeAliases));
+        const composedNodeChanges = brand(mergeTupleBTrees(change1.nodeChanges, change2.nodeChanges));
+        const composedNodeToParent = brand(mergeTupleBTrees(change1.nodeToParent, change2.nodeToParent));
+        const composedNodeAliases = brand(mergeTupleBTrees(change1.nodeAliases, change2.nodeAliases));
         const crossFieldTable = newComposeTable(change1, change2, composedNodeToParent);
         const composedFields = this.composeFieldMaps(change1.fieldChanges, change2.fieldChanges, undefined, genId, crossFieldTable, revisionMetadata);
         this.composeInvalidatedElements(crossFieldTable, composedFields, composedNodeChanges, composedNodeToParent, composedNodeAliases, genId, revisionMetadata);
         // Currently no field kinds require making changes to cross-field keys during composition, so we can just merge the two tables.
-        const composedCrossFieldKeys = mergeBTrees(change1.crossFieldKeys, change2.crossFieldKeys);
+        const composedCrossFieldKeys = RangeMap.union(change1.crossFieldKeys, change2.crossFieldKeys);
         return {
             fieldChanges: composedFields,
             nodeChanges: composedNodeChanges,
             nodeToParent: composedNodeToParent,
             nodeAliases: composedNodeAliases,
-            crossFieldKeys: brand(composedCrossFieldKeys),
+            crossFieldKeys: composedCrossFieldKeys,
         };
     }
     composeInvalidatedField(fieldChange, crossFieldTable, genId, revisionMetadata) {
@@ -436,7 +437,7 @@ export class ModularChangeFamily {
             baseToRebasedNodeId: newTupleBTree(),
             rebasedFields: new Set(),
             rebasedNodeToParent: brand(change.nodeToParent.clone()),
-            rebasedCrossFieldKeys: brand(change.crossFieldKeys.clone()),
+            rebasedCrossFieldKeys: change.crossFieldKeys.clone(),
             nodeIdPairs: [],
             affectedBaseFields: newTupleBTree(),
             fieldsWithUnattachedChild: new Set(),
@@ -821,8 +822,8 @@ export class ModularChangeFamily {
     populateCrossFieldKeyTableForFieldMap(table, fields, parent) {
         for (const [fieldKey, fieldChange] of fields) {
             const keys = getChangeHandler(this.fieldKinds, fieldChange.fieldKind).getCrossFieldKeys(fieldChange.change);
-            for (const key of keys) {
-                table.set(key, { nodeId: parent, field: fieldKey });
+            for (const { key, count } of keys) {
+                table.set(key, count, { nodeId: parent, field: fieldKey });
             }
         }
     }
@@ -861,7 +862,7 @@ export class ModularChangeFamily {
                 numChildren += 1;
             }
             for (const keyRange of handler.getCrossFieldKeys(fieldChange.change)) {
-                const fields = getFieldsForCrossFieldKey(change, keyRange);
+                const fields = getFieldsForCrossFieldKey(change, keyRange.key, keyRange.count);
                 assert(fields.length === 1 &&
                     fields[0] !== undefined &&
                     areEqualFieldIds(fields[0], fieldId), 0xa4f /* Inconsistent cross field keys */);
@@ -872,14 +873,15 @@ export class ModularChangeFamily {
 }
 ModularChangeFamily.emptyChange = makeModularChangeset();
 function replaceCrossFieldKeyTableRevisions(table, oldRevisions, newRevision, nodeAliases) {
-    const updated = newTupleBTree();
-    table.forEachPair(([target, revision, id, count], field) => {
-        const updatedKey = [
-            target,
-            replaceRevision(revision, oldRevisions, newRevision),
-            id,
-            count,
-        ];
+    const updated = newCrossFieldKeyTable();
+    for (const entry of table.entries()) {
+        const key = entry.start;
+        const updatedKey = {
+            target: key.target,
+            revision: replaceRevision(key.revision, oldRevisions, newRevision),
+            localId: key.localId,
+        };
+        const field = entry.value;
         const normalizedFieldId = normalizeFieldId(field, nodeAliases);
         const updatedNodeId = normalizedFieldId.nodeId !== undefined
             ? replaceAtomRevisions(normalizedFieldId.nodeId, oldRevisions, newRevision)
@@ -888,8 +890,8 @@ function replaceCrossFieldKeyTableRevisions(table, oldRevisions, newRevision, no
             ...normalizedFieldId,
             nodeId: updatedNodeId,
         };
-        updated.set(updatedKey, updatedValue);
-    });
+        updated.set(updatedKey, entry.length, updatedValue);
+    }
     return updated;
 }
 function replaceRevision(revision, oldRevisions, newRevision) {
@@ -913,9 +915,9 @@ function composeBuildsDestroysAndRefreshers(change1, change2) {
     // Note that it would in principle be possible to adopt the later build and exclude from the
     // composition all the changes already reflected on the tree, but that is not something we
     // care to support at this time.
-    const allBuilds = brand(mergeBTrees(change1.builds ?? newTupleBTree(), change2.builds ?? newTupleBTree(), true));
-    const allDestroys = brand(mergeBTrees(change1.destroys ?? newTupleBTree(), change2.destroys ?? newTupleBTree()));
-    const allRefreshers = brand(mergeBTrees(change1.refreshers ?? newTupleBTree(), change2.refreshers ?? newTupleBTree(), true));
+    const allBuilds = brand(mergeTupleBTrees(change1.builds ?? newTupleBTree(), change2.builds ?? newTupleBTree(), true));
+    const allDestroys = brand(mergeTupleBTrees(change1.destroys ?? newTupleBTree(), change2.destroys ?? newTupleBTree()));
+    const allRefreshers = brand(mergeTupleBTrees(change1.refreshers ?? newTupleBTree(), change2.refreshers ?? newTupleBTree(), true));
     if (change1.destroys !== undefined && change2.builds !== undefined) {
         for (const [key, chunk] of change2.builds.entries()) {
             const destroyCount = change1.destroys.get(key);
@@ -1034,18 +1036,28 @@ export function updateRefreshers(change, getDetachedNode, removedRoots, requireR
     });
 }
 /**
+ * Converts a change into the delta format.
+ *
  * @param change - The change to convert into a delta.
  * @param fieldKinds - The field kinds to delegate to.
  */
 export function intoDelta(taggedChange, fieldKinds) {
     const change = taggedChange.change;
     const rootDelta = {};
+    const global = [];
+    const rename = [];
     if (!hasConflicts(change)) {
         // If there are no constraint violations, then tree changes apply.
-        const fieldDeltas = intoDeltaImpl(change.fieldChanges, change.nodeChanges, fieldKinds);
+        const fieldDeltas = intoDeltaImpl(change.fieldChanges, change.nodeChanges, fieldKinds, global, rename);
         if (fieldDeltas.size > 0) {
             rootDelta.fields = fieldDeltas;
         }
+        if (global.length > 0) {
+            rootDelta.global = global;
+        }
+        if (rename.length > 0) {
+            rootDelta.rename = rename;
+        }
     }
     // Constraint violations should not prevent nodes from being built
     if (change.builds && change.builds.size > 0) {
@@ -1082,22 +1094,24 @@ function copyDetachedNodes(detachedNodes) {
 /**
  * @param change - The change to convert into a delta.
  */
-function intoDeltaImpl(change, nodeChanges, fieldKinds) {
+function intoDeltaImpl(change, nodeChanges, fieldKinds, global, rename) {
     const delta = new Map();
     for (const [field, fieldChange] of change) {
-        const deltaField = getChangeHandler(fieldKinds, fieldChange.fieldKind).intoDelta(fieldChange.change, (childChange) => {
+        const { local: fieldChanges, global: fieldGlobal, rename: fieldRename, } = getChangeHandler(fieldKinds, fieldChange.fieldKind).intoDelta(fieldChange.change, (childChange) => {
             const nodeChange = nodeChangeFromId(nodeChanges, childChange);
-            return deltaFromNodeChange(nodeChange, nodeChanges, fieldKinds);
+            return deltaFromNodeChange(nodeChange, nodeChanges, fieldKinds, global, rename);
         });
-        if (!isEmptyFieldChanges(deltaField)) {
-            delta.set(field, deltaField);
+        if (fieldChanges !== undefined && fieldChanges.length > 0) {
+            delta.set(field, fieldChanges);
         }
+        fieldGlobal?.forEach((c) => global.push(c));
+        fieldRename?.forEach((r) => rename.push(r));
     }
     return delta;
 }
-function deltaFromNodeChange(change, nodeChanges, fieldKinds) {
+function deltaFromNodeChange(change, nodeChanges, fieldKinds, global, rename) {
     if (change.fieldChanges !== undefined) {
-        return intoDeltaImpl(change.fieldChanges, nodeChanges, fieldKinds);
+        return intoDeltaImpl(change.fieldChanges, nodeChanges, fieldKinds, global, rename);
     }
     // TODO: update the API to allow undefined to be returned here
     return new Map();
@@ -1163,10 +1177,10 @@ function newComposeTable(baseChange, newChange, composedNodeToParent) {
 }
 function newCrossFieldTable() {
     return {
-        srcTable: new Map(),
-        dstTable: new Map(),
-        srcDependents: new Map(),
-        dstDependents: new Map(),
+        srcTable: newChangeAtomIdRangeMap(),
+        dstTable: newChangeAtomIdRangeMap(),
+        srcDependents: newChangeAtomIdRangeMap(),
+        dstDependents: newChangeAtomIdRangeMap(),
         invalidatedFields: new Set(),
     };
 }
@@ -1237,19 +1251,17 @@ class RebaseManager extends CrossFieldManagerI {
     }
     set(target, revision, id, count, newValue, invalidateDependents) {
         if (invalidateDependents && this.allowInval) {
-            const newFieldIds = getFieldsForCrossFieldKey(this.table.newChange, [
+            const newFieldIds = getFieldsForCrossFieldKey(this.table.newChange, {
                 target,
                 revision,
-                id,
-                count,
-            ]);
+                localId: id,
+            }, count);
             assert(newFieldIds.length === 0, 0x9c6 /* TODO: Modifying a cross-field key from the new changeset is currently unsupported */);
-            const baseFieldIds = getFieldsForCrossFieldKey(this.table.baseChange, [
+            const baseFieldIds = getFieldsForCrossFieldKey(this.table.baseChange, {
                 target,
                 revision,
-                id,
-                count,
-            ]);
+                localId: id,
+            }, count);
             assert(baseFieldIds.length > 0, 0x9c7 /* Cross field key not registered in base or new change */);
             for (const baseFieldId of baseFieldIds) {
                 this.table.affectedBaseFields.set([baseFieldId.nodeId?.revision, baseFieldId.nodeId?.localId, baseFieldId.field], true);
@@ -1261,7 +1273,7 @@ class RebaseManager extends CrossFieldManagerI {
         setInChangeAtomIdMap(this.table.rebasedNodeToParent, id, this.fieldId);
     }
     moveKey(target, revision, id, count) {
-        setInCrossFieldKeyTable(this.table.rebasedCrossFieldKeys, target, revision, id, count, this.fieldId);
+        this.table.rebasedCrossFieldKeys.set({ target, revision, localId: id }, count, this.fieldId);
     }
     get table() {
         return this.crossFieldTable;
@@ -1275,24 +1287,22 @@ class ComposeManager extends CrossFieldManagerI {
     }
     set(target, revision, id, count, newValue, invalidateDependents) {
         if (invalidateDependents && this.allowInval) {
-            const newFieldIds = getFieldsForCrossFieldKey(this.table.newChange, [
+            const newFieldIds = getFieldsForCrossFieldKey(this.table.newChange, {
                 target,
                 revision,
-                id,
-                count,
-            ]);
+                localId: id,
+            }, count);
             if (newFieldIds.length > 0) {
                 for (const newFieldId of newFieldIds) {
                     this.table.pendingCompositions.affectedNewFields.set([newFieldId.nodeId?.revision, newFieldId.nodeId?.localId, newFieldId.field], true);
                 }
             }
             else {
-                const baseFieldIds = getFieldsForCrossFieldKey(this.table.baseChange, [
+                const baseFieldIds = getFieldsForCrossFieldKey(this.table.baseChange, {
                     target,
                     revision,
-                    id,
-                    count,
-                ]);
+                    localId: id,
+                }, count);
                 assert(baseFieldIds.length > 0, 0x9c8 /* Cross field key not registered in base or new change */);
                 for (const baseFieldId of baseFieldIds) {
                     this.table.pendingCompositions.affectedBaseFields.set([baseFieldId.nodeId?.revision, baseFieldId.nodeId?.localId, baseFieldId.field], true);
@@ -1486,8 +1496,8 @@ function buildModularChangesetFromField(props) {
     const { path, fieldChange, nodeChanges, nodeToParent, crossFieldKeys, idAllocator = idAllocatorFromMaxId(), localCrossFieldKeys = [], childId, revision, } = props;
     const fieldChanges = new Map([[path.field, fieldChange]]);
     if (path.parent === undefined) {
-        for (const key of localCrossFieldKeys) {
-            crossFieldKeys.set(key, { nodeId: undefined, field: path.field });
+        for (const { key, count } of localCrossFieldKeys) {
+            crossFieldKeys.set(key, count, { nodeId: undefined, field: path.field });
         }
         if (childId !== undefined) {
             setInChangeAtomIdMap(nodeToParent, childId, {
@@ -1508,8 +1518,8 @@ function buildModularChangesetFromField(props) {
         fieldChanges,
     };
     const parentId = { localId: brand(idAllocator.allocate()), revision };
-    for (const key of localCrossFieldKeys) {
-        crossFieldKeys.set(key, { nodeId: parentId, field: path.field });
+    for (const { key, count } of localCrossFieldKeys) {
+        crossFieldKeys.set(key, count, { nodeId: parentId, field: path.field });
     }
     if (childId !== undefined) {
         setInChangeAtomIdMap(nodeToParent, childId, {
@@ -1582,19 +1592,6 @@ function revisionInfoFromTaggedChange(taggedChange) {
     }
     return revInfos;
 }
-function mergeBTrees(tree1, tree2, preferLeft = true) {
-    if (tree1 === undefined) {
-        return tree2 !== undefined ? brand(tree2.clone()) : newTupleBTree();
-    }
-    const result = brand(tree1.clone());
-    if (tree2 === undefined) {
-        return result;
-    }
-    for (const [key, value] of tree2.entries()) {
-        result.set(key, value, !preferLeft);
-    }
-    return result;
-}
 function fieldChangeFromId(fields, nodes, id) {
     const fieldMap = fieldMapFromNodeId(fields, nodes, id.nodeId);
     return fieldMap.get(id.field) ?? fail("No field exists for the given ID");
@@ -1645,72 +1642,13 @@ export function getParentFieldId(changeset, nodeId) {
     assert(parentId !== undefined, 0x9cb /* Parent field should be defined */);
     return normalizeFieldId(parentId, changeset.nodeAliases);
 }
-export function getFieldsForCrossFieldKey(changeset, [target, revision, id, count]) {
-    let firstLocalId = id;
-    const lastLocalId = id + count - 1;
-    const fields = [];
-    // eslint-disable-next-line no-constant-condition
-    while (true) {
-        const entry = getFirstIntersectingCrossFieldEntry(changeset.crossFieldKeys, [
-            target,
-            revision,
-            brand(firstLocalId),
-            count,
-        ]);
-        if (entry === undefined) {
-            return fields;
-        }
-        const [[_target, _revision, entryId, entryCount], fieldId] = entry;
-        fields.push(normalizeFieldId(fieldId, changeset.nodeAliases));
-        const entryLastId = entryId + entryCount - 1;
-        if (entryLastId >= lastLocalId) {
-            return fields;
-        }
-        firstLocalId = entryLastId + 1;
-    }
-}
-function getFirstIntersectingCrossFieldEntry(table, [target, revision, id, count]) {
-    const entry = table.nextLowerPair([target, revision, id, Number.POSITIVE_INFINITY]);
-    if (entry === undefined) {
-        return undefined;
-    }
-    const [entryTarget, entryRevision, entryId, entryCount] = entry[0];
-    if (entryTarget !== target || entryRevision !== revision) {
-        return undefined;
-    }
-    const lastQueryId = id + count - 1;
-    const entryLastId = entryId + entryCount - 1;
-    if (entryId > lastQueryId || entryLastId < id) {
-        return undefined;
-    }
-    return entry;
-}
-function setInCrossFieldKeyTable(table, target, revision, id, count, value) {
-    let entry = getFirstIntersectingCrossFieldEntry(table, [target, revision, id, count]);
-    const lastQueryId = id + count - 1;
-    while (entry !== undefined) {
-        const [entryKey, entryValue] = entry;
-        table.delete(entryKey);
-        const [_target, _revision, entryId, entryCount] = entryKey;
-        if (entryId < id) {
-            table.set([target, revision, entryId, id - entryId], entryValue);
-        }
-        const lastEntryId = entryId + entryCount - 1;
-        if (lastEntryId > lastQueryId) {
-            table.set([target, revision, brand(lastQueryId + 1), lastEntryId - lastQueryId], entryValue);
-            break;
-        }
-        const nextId = brand(lastEntryId + 1);
-        entry = getFirstIntersectingCrossFieldEntry(table, [
-            target,
-            revision,
-            nextId,
-            lastQueryId - nextId + 1,
-        ]);
-    }
-    table.set([target, revision, id, count], value);
+function getFieldsForCrossFieldKey(changeset, key, count) {
+    return changeset.crossFieldKeys
+        .getAll(key, count)
+        .map(({ value: fieldId }) => normalizeFieldId(fieldId, changeset.nodeAliases));
 }
-function normalizeFieldId(fieldId, nodeAliases) {
+// This is only exported for use in test utilities.
+export function normalizeFieldId(fieldId, nodeAliases) {
     return fieldId.nodeId !== undefined
         ? { ...fieldId, nodeId: normalizeNodeId(fieldId.nodeId, nodeAliases) }
         : fieldId;
@@ -1732,36 +1670,6 @@ function normalizeNodeId(nodeId, nodeAliases) {
 function hasConflicts(change) {
     return (change.constraintViolationCount ?? 0) > 0;
 }
-export function newCrossFieldKeyTable() {
-    return newTupleBTree();
-}
-export function newTupleBTree(entries) {
-    return brand(new BTree(entries, compareTuples));
-}
-// This assumes that the arrays are the same length.
-function compareTuples(arrayA, arrayB) {
-    for (let i = 0; i < arrayA.length; i++) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const a = arrayA[i];
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const b = arrayB[i];
-        // Less-than and greater-than always return false if either value is undefined,
-        // so we handle undefined separately, treating it as less than all other values.
-        if (a === undefined && b !== undefined) {
-            return -1;
-        }
-        else if (b === undefined && a !== undefined) {
-            return 1;
-        }
-        else if (a < b) {
-            return -1;
-        }
-        else if (a > b) {
-            return 1;
-        }
-    }
-    return 0;
-}
 function getFromChangeAtomIdMap(map, id) {
     return map.get([id.revision, id.localId]);
 }