@lionweb/class-core 0.7.0-beta.9 → 0.7.1

package/dist/deltas/appliers.js

@@ -14,16 +14,17 @@
 //
 // SPDX-FileCopyrightText: 2025 TRUMPF Laser SE and other contributors
 // SPDX-License-Identifier: Apache-2.0
-import { AnnotationAddedDelta, AnnotationDeletedDelta, AnnotationMovedFromOtherParentDelta, AnnotationMovedInSameParentDelta, AnnotationReplacedDelta, ChildAddedDelta, ChildDeletedDelta, ChildMovedDelta, ChildMovedInSameContainmentDelta, ChildReplacedDelta, NoOpDelta, PropertyAddedDelta, PropertyChangedDelta, PropertyDeletedDelta, ReferenceAddedDelta, ReferenceDeletedDelta, ReferenceMovedDelta, ReferenceMovedInSameReferenceDelta, ReferenceReplacedDelta } from "./types.g.js";
+import { AnnotationAddedDelta, AnnotationDeletedDelta, AnnotationMovedAndReplacedFromOtherParentDelta, AnnotationMovedAndReplacedInSameParentDelta, AnnotationMovedFromOtherParentDelta, AnnotationMovedInSameParentDelta, AnnotationReplacedDelta, ChildAddedDelta, ChildDeletedDelta, ChildMovedAndReplacedFromOtherContainmentDelta, ChildMovedAndReplacedFromOtherContainmentInSameParentDelta, ChildMovedAndReplacedInSameContainmentDelta, ChildMovedFromOtherContainmentDelta, ChildMovedFromOtherContainmentInSameParentDelta, ChildMovedInSameContainmentDelta, ChildReplacedDelta, CompositeDelta, EntryMovedAndReplacedFromOtherReferenceDelta, EntryMovedAndReplacedFromOtherReferenceInSameParentDelta, EntryMovedAndReplacedInSameReferenceDelta, EntryMovedFromOtherReferenceDelta, EntryMovedFromOtherReferenceInSameParentDelta, EntryMovedInSameReferenceDelta, NoOpDelta, PartitionAddedDelta, PartitionDeletedDelta, PropertyAddedDelta, PropertyChangedDelta, PropertyDeletedDelta, ReferenceAddedDelta, ReferenceChangedDelta, ReferenceDeletedDelta } from "./types.g.js";
 import { unresolved } from "@lionweb/core";
 /**
  * @return a function that applies a given {@link Delta}, given an optional {@link IdMapping ID mapping}.
  * If an {@link IdMapping} is provided, the {@link INodeBase nodes} relevant for the delta are looked up from that;
  * otherwise, the delta is applied directly to (object-)referenced nodes.
  *
- * This is an internal function, solely meant to DRY the delta application with and without lookup in
+ * This is an internal function, solely meant to DRY the delta application
+ * with and without lookup in an {@link IdMapping ID mapping object}.
  */
-const deltaApplier = (idMapping) => (delta) => {
+const deltaApplier = (idMapping, updatablePartitions) => (delta) => {
     const lookupNodeFrom = (node) => {
         if (idMapping === undefined) {
             return node;
@@ -45,177 +46,379 @@ const deltaApplier = (idMapping) => (delta) => {
             ? unresolved
             : lookupNodeFrom(nodeRef);
     };
-    if (delta instanceof NoOpDelta) {
-        return;
-    }
-    if (delta instanceof PropertyAddedDelta) {
-        lookupNodeFrom(delta.container).getPropertyValueManager(delta.property).setDirectly(delta.value);
-        return;
-    }
-    if (delta instanceof PropertyChangedDelta) {
-        lookupNodeFrom(delta.container).getPropertyValueManager(delta.property).setDirectly(delta.newValue);
-        return;
-    }
-    if (delta instanceof PropertyDeletedDelta) {
-        lookupNodeFrom(delta.container).getPropertyValueManager(delta.property).setDirectly(undefined);
-        return;
-    }
-    if (delta instanceof ChildAddedDelta) {
-        const valueManager = lookupNodeFrom(delta.parent).getContainmentValueManager(delta.containment);
-        const newChild = lookupNodeFrom(delta.newChild);
-        if (delta.containment.multiple) {
-            valueManager.insertAtIndexDirectly(newChild, delta.index);
+    const applyDelta = (delta) => {
+        if (delta instanceof PartitionAddedDelta) {
+            if (updatablePartitions !== undefined) {
+                const partitions = updatablePartitions();
+                const { newPartition } = delta;
+                if (partitions.indexOf(newPartition) === -1) {
+                    updatablePartitions().push(newPartition);
+                }
+                idMapping?.updateWith(newPartition);
+            }
+            return;
         }
-        else {
-            valueManager.setDirectly(newChild);
+        if (delta instanceof PartitionDeletedDelta) {
+            if (updatablePartitions !== undefined) {
+                const partitions = updatablePartitions();
+                const index = partitions.indexOf(delta.deletedPartition);
+                if (index > -1) {
+                    partitions.splice(index, 1);
+                }
+            }
+            return;
         }
-        newChild.attachTo(delta.parent, delta.containment);
-        return;
-    }
-    if (delta instanceof ChildReplacedDelta) {
-        const valueManager = lookupNodeFrom(delta.parent).getContainmentValueManager(delta.containment);
-        const replacedChild = lookupNodeFrom(delta.replacedChild);
-        const newChild = lookupNodeFrom(delta.newChild);
-        if (delta.containment.multiple) {
-            const multiValueManager = valueManager;
-            multiValueManager.removeDirectly(replacedChild); // should be at index delta.index
-            multiValueManager.insertAtIndexDirectly(newChild, delta.index);
-        }
-        else {
-            valueManager.setDirectly(newChild);
-        }
-        replacedChild.detach();
-        newChild.attachTo(delta.parent, delta.containment);
-        return;
-    }
-    if (delta instanceof ChildMovedDelta) {
-        const oldValueManager = delta.oldParent.getContainmentValueManager(delta.oldContainment);
-        const child = lookupNodeFrom(delta.child);
-        if (delta.oldContainment.multiple) {
-            oldValueManager.removeDirectly(child); // should be at index delta.oldIndex
+        if (delta instanceof PropertyAddedDelta) {
+            lookupNodeFrom(delta.node).getPropertyValueManager(delta.property).setDirectly(delta.value);
+            return;
         }
-        else {
-            oldValueManager.setDirectly(undefined);
+        if (delta instanceof PropertyDeletedDelta) {
+            lookupNodeFrom(delta.node).getPropertyValueManager(delta.property).setDirectly(undefined);
+            return;
         }
-        const newValueManager = delta.newParent.getContainmentValueManager(delta.newContainment);
-        if (delta.newContainment.multiple) {
-            newValueManager.insertAtIndexDirectly(child, delta.newIndex);
+        if (delta instanceof PropertyChangedDelta) {
+            lookupNodeFrom(delta.node).getPropertyValueManager(delta.property).setDirectly(delta.newValue);
+            return;
         }
-        else {
-            newValueManager.setDirectly(child);
+        if (delta instanceof ChildAddedDelta) {
+            const parent = lookupNodeFrom(delta.parent);
+            const valueManager = parent.getContainmentValueManager(delta.containment);
+            const newChild = lookupNodeFrom(delta.newChild);
+            if (delta.containment.multiple) {
+                valueManager.insertAtIndexDirectly(newChild, delta.index);
+            }
+            else {
+                valueManager.setDirectly(newChild);
+            }
+            newChild.attachTo(parent, delta.containment);
+            return;
         }
-        child.detach();
-        child.attachTo(delta.newParent, delta.newContainment);
-        return;
-    }
-    if (delta instanceof ChildMovedInSameContainmentDelta) {
-        const valueManager = lookupNodeFrom(delta.parent).getContainmentValueManager(delta.containment);
-        valueManager.moveDirectly(delta.oldIndex, delta.newIndex);
-        return;
-    }
-    if (delta instanceof ChildDeletedDelta) {
-        const valueManager = lookupNodeFrom(delta.parent).getContainmentValueManager(delta.containment);
-        if (delta.containment.multiple) {
-            const multiValueManager = valueManager;
-            multiValueManager.removeDirectly(lookupNodeFrom(delta.deletedChild));
+        if (delta instanceof ChildDeletedDelta) {
+            const valueManager = lookupNodeFrom(delta.parent).getContainmentValueManager(delta.containment);
+            if (delta.containment.multiple) {
+                valueManager.removeDirectly(lookupNodeFrom(delta.deletedChild));
+            }
+            else {
+                valueManager.setDirectly(undefined);
+            }
+            delta.deletedChild.detach();
+            return;
         }
-        else {
-            valueManager.setDirectly(undefined);
+        if (delta instanceof ChildReplacedDelta) {
+            const parent = lookupNodeFrom(delta.parent);
+            const valueManager = parent.getContainmentValueManager(delta.containment);
+            const replacedChild = lookupNodeFrom(delta.replacedChild);
+            const newChild = lookupNodeFrom(delta.newChild);
+            if (delta.containment.multiple) {
+                const multiValueManager = valueManager;
+                multiValueManager.removeDirectly(replacedChild); // should be at index delta.index
+                multiValueManager.insertAtIndexDirectly(newChild, delta.index);
+            }
+            else {
+                valueManager.setDirectly(newChild);
+            }
+            replacedChild.detach();
+            newChild.attachTo(parent, delta.containment);
+            return;
         }
-        delta.deletedChild.detach();
-        return;
-    }
-    if (delta instanceof ReferenceAddedDelta) {
-        const valueManager = lookupNodeFrom(delta.container).getReferenceValueManager(delta.reference);
-        const newTarget = lookupNodeRefFrom(delta.newTarget);
-        if (delta.reference.multiple) {
-            valueManager.insertAtIndexDirectly(newTarget, delta.index);
+        if (delta instanceof ChildMovedFromOtherContainmentDelta) {
+            const oldValueManager = lookupNodeFrom(delta.oldParent).getContainmentValueManager(delta.oldContainment);
+            const movedChild = lookupNodeFrom(delta.movedChild);
+            if (delta.oldContainment.multiple) {
+                oldValueManager.removeDirectly(movedChild); // should be at index delta.oldIndex
+            }
+            else {
+                oldValueManager.setDirectly(undefined);
+            }
+            const newParent = lookupNodeFrom(delta.newParent);
+            const newValueManager = newParent.getContainmentValueManager(delta.newContainment);
+            if (delta.newContainment.multiple) {
+                newValueManager.insertAtIndexDirectly(movedChild, delta.newIndex);
+            }
+            else {
+                newValueManager.setDirectly(movedChild);
+            }
+            movedChild.detach();
+            movedChild.attachTo(newParent, delta.newContainment);
+            return;
         }
-        else {
-            valueManager.setDirectly(newTarget);
+        if (delta instanceof ChildMovedFromOtherContainmentInSameParentDelta) {
+            const parent = lookupNodeFrom(delta.parent);
+            const oldValueManager = parent.getContainmentValueManager(delta.oldContainment);
+            const movedChild = lookupNodeFrom(delta.movedChild);
+            if (delta.oldContainment.multiple) {
+                oldValueManager.removeDirectly(movedChild); // should be at index delta.oldIndex
+            }
+            else {
+                oldValueManager.setDirectly(undefined);
+            }
+            const newValueManager = parent.getContainmentValueManager(delta.newContainment);
+            if (delta.newContainment.multiple) {
+                newValueManager.insertAtIndexDirectly(movedChild, delta.newIndex);
+            }
+            else {
+                newValueManager.setDirectly(movedChild);
+            }
+            return;
         }
-        return;
-    }
-    if (delta instanceof ReferenceReplacedDelta) {
-        const valueManager = lookupNodeFrom(delta.container).getReferenceValueManager(delta.reference);
-        const replacedTarget = lookupNodeRefFrom(delta.replacedTarget);
-        const newTarget = lookupNodeRefFrom(delta.newTarget);
-        if (delta.reference.multiple) {
-            const multiValueManager = valueManager;
-            multiValueManager.removeDirectly(replacedTarget); // should be at index delta.index
-            multiValueManager.insertAtIndexDirectly(newTarget, delta.index);
-        }
-        else {
-            valueManager.setDirectly(newTarget);
-        }
-        return;
-    }
-    if (delta instanceof ReferenceMovedDelta) {
-        const oldValueManager = lookupNodeFrom(delta.oldContainer).getReferenceValueManager(delta.oldReference);
-        const target = lookupNodeRefFrom(delta.target);
-        if (delta.oldReference.multiple) {
-            oldValueManager.removeDirectly(target); // should be at index delta.oldIndex
+        if (delta instanceof ChildMovedInSameContainmentDelta) {
+            const valueManager = lookupNodeFrom(delta.parent).getContainmentValueManager(delta.containment);
+            valueManager.moveDirectly(delta.oldIndex, delta.newIndex);
+            return;
         }
-        else {
-            oldValueManager.setDirectly(undefined);
+        if (delta instanceof ChildMovedAndReplacedFromOtherContainmentDelta) {
+            const oldValueManager = delta.oldParent.getContainmentValueManager(delta.oldContainment);
+            const movedChild = lookupNodeFrom(delta.movedChild);
+            if (delta.oldContainment.multiple) {
+                oldValueManager.removeDirectly(movedChild); // should be at index delta.oldIndex
+            }
+            else {
+                oldValueManager.setDirectly(undefined);
+            }
+            const newParent = lookupNodeFrom(delta.newParent);
+            const newValueManager = newParent.getContainmentValueManager(delta.newContainment);
+            if (delta.newContainment.multiple) {
+                const valueManager = newValueManager;
+                valueManager.removeAtIndexDirectly(delta.newIndex);
+                valueManager.insertAtIndexDirectly(movedChild, delta.newIndex);
+                // TODO  make separate API for this?
+            }
+            else {
+                newValueManager.setDirectly(movedChild);
+            }
+            movedChild.detach();
+            movedChild.attachTo(newParent, delta.newContainment);
+            return;
         }
-        const newValueManager = lookupNodeFrom(delta.newContainer).getReferenceValueManager(delta.newReference);
-        if (delta.newReference.multiple) {
-            newValueManager.insertAtIndexDirectly(target, delta.newIndex);
+        if (delta instanceof ChildMovedAndReplacedFromOtherContainmentInSameParentDelta) {
+            const oldValueManager = delta.parent.getContainmentValueManager(delta.oldContainment);
+            const movedChild = lookupNodeFrom(delta.movedChild);
+            if (delta.oldContainment.multiple) {
+                oldValueManager.removeDirectly(movedChild); // should be at index delta.oldIndex
+            }
+            else {
+                oldValueManager.setDirectly(undefined);
+            }
+            const newValueManager = delta.parent.getContainmentValueManager(delta.newContainment);
+            if (delta.newContainment.multiple) {
+                const valueManager = newValueManager;
+                valueManager.removeAtIndexDirectly(delta.newIndex); // should be delta.replacedChild
+                valueManager.insertAtIndexDirectly(movedChild, delta.newIndex);
+                // TODO  make separate API for this?
+            }
+            else {
+                newValueManager.setDirectly(movedChild);
+            }
+            return;
         }
-        else {
-            newValueManager.setDirectly(target);
+        if (delta instanceof ChildMovedAndReplacedInSameContainmentDelta) {
+            const valueManager = delta.parent.getContainmentValueManager(delta.containment);
+            const movedChild = lookupNodeFrom(delta.movedChild);
+            const replacedChild = lookupNodeFrom(delta.replacedChild);
+            if (delta.containment.multiple) {
+                valueManager.removeDirectly(replacedChild); // should be at index delta.oldIndex
+            }
+            else {
+                valueManager.setDirectly(undefined);
+            }
+            if (delta.containment.multiple) {
+                valueManager.insertAtIndexDirectly(movedChild, delta.newIndex);
+            }
+            else {
+                valueManager.setDirectly(movedChild);
+            }
+            return;
         }
-        return;
-    }
-    if (delta instanceof ReferenceMovedInSameReferenceDelta) {
-        const valueManager = lookupNodeFrom(delta.container).getReferenceValueManager(delta.reference);
-        valueManager.moveDirectly(delta.oldIndex, delta.newIndex);
-        return;
-    }
-    if (delta instanceof ReferenceDeletedDelta) {
-        const valueManager = lookupNodeFrom(delta.container).getReferenceValueManager(delta.reference);
-        const deletedTarget = lookupNodeRefFrom(delta.deletedTarget);
-        if (delta.reference.multiple) {
-            const multiValueManager = valueManager;
-            multiValueManager.removeDirectly(deletedTarget);
+        if (delta instanceof AnnotationAddedDelta) {
+            const parent = lookupNodeFrom(delta.parent);
+            parent.annotationsValueManager.insertAtIndexDirectly(delta.newAnnotation, delta.index);
+            delta.newAnnotation.attachTo(parent, null);
+            return;
         }
-        else {
-            valueManager.setDirectly(undefined);
+        if (delta instanceof AnnotationDeletedDelta) {
+            lookupNodeFrom(delta.parent).annotationsValueManager.removeDirectly(delta.deletedAnnotation); // should be at index delta.index
+            delta.deletedAnnotation.detach();
+            return;
         }
-        return;
-    }
-    if (delta instanceof AnnotationAddedDelta) {
-        lookupNodeFrom(delta.parent).annotationsValueManager.insertAtIndexDirectly(delta.newAnnotation, delta.index);
-        delta.newAnnotation.attachTo(delta.parent, null);
-        return;
-    }
-    if (delta instanceof AnnotationDeletedDelta) {
-        lookupNodeFrom(delta.parent).annotationsValueManager.removeDirectly(delta.deletedAnnotation); // should be at index delta.index
-        delta.deletedAnnotation.detach();
-        return;
-    }
-    if (delta instanceof AnnotationReplacedDelta) {
-        const valueManager = lookupNodeFrom(delta.parent).annotationsValueManager;
-        valueManager.removeDirectly(delta.replacedAnnotation); // should be at index delta.index
-        delta.replacedAnnotation.detach();
-        valueManager.insertAtIndexDirectly(delta.newAnnotation, delta.index);
-        delta.newAnnotation.attachTo(delta.parent, null);
-        return;
-    }
-    if (delta instanceof AnnotationMovedFromOtherParentDelta) {
-        lookupNodeFrom(delta.oldParent).annotationsValueManager.removeDirectly(delta.movedAnnotation); // should be at index delta.index
-        delta.movedAnnotation.detach();
-        lookupNodeFrom(delta.newParent).annotationsValueManager.insertAtIndexDirectly(delta.movedAnnotation, delta.newIndex);
-        delta.movedAnnotation.attachTo(delta.newParent, null);
-        return;
-    }
-    if (delta instanceof AnnotationMovedInSameParentDelta) {
-        const valueManager = lookupNodeFrom(delta.parent).annotationsValueManager;
-        valueManager.moveDirectly(delta.oldIndex, delta.newIndex);
-        return;
-    }
-    throw new Error(`application of delta of class ${delta.constructor.name} not implemented`);
+        if (delta instanceof AnnotationReplacedDelta) {
+            const parent = lookupNodeFrom(delta.parent);
+            const valueManager = parent.annotationsValueManager;
+            valueManager.removeDirectly(delta.replacedAnnotation); // should be at index delta.index
+            delta.replacedAnnotation.detach();
+            valueManager.insertAtIndexDirectly(delta.newAnnotation, delta.index);
+            delta.newAnnotation.attachTo(parent, null);
+            return;
+        }
+        if (delta instanceof AnnotationMovedFromOtherParentDelta) {
+            const movedAnnotation = lookupNodeFrom(delta.movedAnnotation);
+            lookupNodeFrom(delta.oldParent).annotationsValueManager.removeDirectly(movedAnnotation); // should be at index delta.index
+            movedAnnotation.detach();
+            const newParent = lookupNodeFrom(delta.newParent);
+            newParent.annotationsValueManager.insertAtIndexDirectly(delta.movedAnnotation, delta.newIndex);
+            movedAnnotation.attachTo(newParent, null);
+            return;
+        }
+        if (delta instanceof AnnotationMovedInSameParentDelta) {
+            const valueManager = lookupNodeFrom(delta.parent).annotationsValueManager;
+            valueManager.moveDirectly(delta.oldIndex, delta.newIndex);
+            return;
+        }
+        if (delta instanceof AnnotationMovedAndReplacedFromOtherParentDelta) {
+            const movedAnnotation = lookupNodeFrom(delta.movedAnnotation);
+            lookupNodeFrom(delta.oldParent).annotationsValueManager.removeDirectly(delta.movedAnnotation); // should be at index delta.index
+            delta.movedAnnotation.detach();
+            const newParent = lookupNodeFrom(delta.newParent);
+            const newValueManager = newParent.annotationsValueManager;
+            newValueManager.removeDirectly(delta.replacedAnnotation);
+            delta.replacedAnnotation.detach();
+            newValueManager.insertAtIndexDirectly(movedAnnotation, delta.newIndex);
+            movedAnnotation.attachTo(newParent, null);
+            return;
+        }
+        if (delta instanceof AnnotationMovedAndReplacedInSameParentDelta) {
+            const valueManager = lookupNodeFrom(delta.parent).annotationsValueManager;
+            valueManager.moveAndReplaceAtIndexDirectly(delta.oldIndex, delta.newIndex);
+            return;
+        }
+        if (delta instanceof ReferenceAddedDelta) {
+            const valueManager = lookupNodeFrom(delta.parent).getReferenceValueManager(delta.reference);
+            const newTarget = lookupNodeRefFrom(delta.newTarget);
+            if (delta.reference.multiple) {
+                valueManager.insertAtIndexDirectly(newTarget, delta.index);
+            }
+            else {
+                valueManager.setDirectly(newTarget);
+            }
+            return;
+        }
+        if (delta instanceof ReferenceDeletedDelta) {
+            const valueManager = lookupNodeFrom(delta.parent).getReferenceValueManager(delta.reference);
+            if (delta.reference.multiple) {
+                valueManager.removeAtIndexDirectly(delta.index); // should be delta.deletedTarget
+            }
+            else {
+                valueManager.setDirectly(undefined);
+            }
+            return;
+        }
+        if (delta instanceof ReferenceChangedDelta) {
+            const valueManager = lookupNodeFrom(delta.parent).getReferenceValueManager(delta.reference);
+            const newTarget = lookupNodeRefFrom(delta.newTarget);
+            if (delta.reference.multiple) {
+                const multiValueManager = valueManager;
+                multiValueManager.removeAtIndexDirectly(delta.index); // should be delta.oldTarget
+                multiValueManager.insertAtIndexDirectly(newTarget, delta.index);
+            }
+            else {
+                valueManager.setDirectly(newTarget);
+            }
+            return;
+        }
+        if (delta instanceof EntryMovedFromOtherReferenceDelta) {
+            const oldValueManager = lookupNodeFrom(delta.oldParent).getReferenceValueManager(delta.oldReference);
+            const movedTarget = lookupNodeRefFrom(delta.movedTarget);
+            if (delta.oldReference.multiple) {
+                oldValueManager.removeAtIndexDirectly(delta.oldIndex); // should be delta.movedTarget
+            }
+            else {
+                oldValueManager.setDirectly(undefined);
+            }
+            const newValueManager = lookupNodeFrom(delta.newParent).getReferenceValueManager(delta.newReference);
+            if (delta.newReference.multiple) {
+                newValueManager.insertAtIndexDirectly(movedTarget, delta.newIndex);
+            }
+            else {
+                newValueManager.setDirectly(movedTarget);
+            }
+            return;
+        }
+        if (delta instanceof EntryMovedFromOtherReferenceInSameParentDelta) {
+            const parent = lookupNodeFrom(delta.parent);
+            const oldValueManager = parent.getReferenceValueManager(delta.oldReference);
+            const movedTarget = lookupNodeRefFrom(delta.movedTarget);
+            if (delta.oldReference.multiple) {
+                oldValueManager.removeAtIndexDirectly(delta.oldIndex); // should be delta.movedTarget
+            }
+            else {
+                oldValueManager.setDirectly(undefined);
+            }
+            const newValueManager = parent.getReferenceValueManager(delta.newReference);
+            if (delta.newReference.multiple) {
+                newValueManager.insertAtIndexDirectly(movedTarget, delta.newIndex);
+            }
+            else {
+                newValueManager.setDirectly(movedTarget);
+            }
+            return;
+        }
+        if (delta instanceof EntryMovedInSameReferenceDelta) {
+            const valueManager = lookupNodeFrom(delta.parent).getReferenceValueManager(delta.reference);
+            valueManager.moveDirectly(delta.oldIndex, delta.newIndex);
+            return;
+        }
+        if (delta instanceof EntryMovedAndReplacedFromOtherReferenceDelta) {
+            const oldParent = lookupNodeFrom(delta.oldParent);
+            const oldValueManager = oldParent.getReferenceValueManager(delta.oldReference);
+            const movedTarget = lookupNodeRefFrom(delta.movedTarget);
+            if (delta.oldReference.multiple) {
+                oldValueManager.removeAtIndexDirectly(delta.oldIndex); // should be delta.movedTarget
+            }
+            else {
+                oldValueManager.setDirectly(undefined);
+            }
+            const newParent = lookupNodeFrom(delta.newParent);
+            const newValueManager = newParent.getReferenceValueManager(delta.newReference);
+            if (delta.newReference.multiple) {
+                const valueManager = newValueManager;
+                valueManager.removeAtIndexDirectly(delta.oldIndex); // should be delta.replacedTarget
+                valueManager.insertAtIndexDirectly(movedTarget, delta.newIndex);
+            }
+            else {
+                newValueManager.setDirectly(movedTarget);
+            }
+            return;
+        }
+        if (delta instanceof EntryMovedAndReplacedFromOtherReferenceInSameParentDelta) {
+            const parent = lookupNodeFrom(delta.parent);
+            const oldValueManager = parent.getReferenceValueManager(delta.oldReference);
+            const movedTarget = lookupNodeRefFrom(delta.movedTarget);
+            if (delta.oldReference.multiple) {
+                oldValueManager.removeAtIndexDirectly(delta.oldIndex); // should be delta.movedTarget
+            }
+            else {
+                oldValueManager.setDirectly(undefined);
+            }
+            const newValueManager = parent.getReferenceValueManager(delta.newReference);
+            if (delta.newReference.multiple) {
+                const valueManager = newValueManager;
+                valueManager.removeAtIndexDirectly(delta.newIndex); // should be delta.replacedTarget
+                valueManager.insertAtIndexDirectly(movedTarget, delta.newIndex);
+            }
+            else {
+                newValueManager.setDirectly(movedTarget);
+            }
+            return;
+        }
+        if (delta instanceof EntryMovedAndReplacedInSameReferenceDelta) {
+            const parent = lookupNodeFrom(delta.parent);
+            const valueManager = parent.getReferenceValueManager(delta.reference);
+            if (delta.reference.multiple) {
+                valueManager.moveAndReplaceDirectly(delta.oldIndex, delta.newIndex);
+            }
+            else {
+                // (do nothing)
+            }
+            return;
+        }
+        if (delta instanceof CompositeDelta) {
+            delta.parts.forEach(applyDelta);
+        }
+        if (delta instanceof NoOpDelta) {
+            return;
+        }
+        throw new Error(`application of delta of class ${delta.constructor.name} not implemented`);
+    };
+    return applyDelta(delta);
 };
 /**
  * Applies the given {@link Delta deltas} to the {@link INodeBase nodes} (object-)referenced in the deltas.
@@ -235,12 +438,12 @@ export const applyDelta = deltaApplier();
  * @usage should look as follows.
  *
  * ```typescript
- * const {roots, idMapping} = deserializeAsLDMModelWithMapping(serializationChunk, handleDelta);
+ * const {roots, idMapping} = deserializeAsLDMModelWithMapping(serializationChunk, receiveDelta);
  * applyDeltasWithLookup(idMapping, deltas);
  * ```
  */
-export const applyDeltasWithLookup = (idMapping, deltas) => {
-    deltas.forEach((delta) => applyDeltaWithLookup(idMapping, delta));
+export const applyDeltasWithLookup = (idMapping, deltas, updatablePartitions) => {
+    deltas.forEach((delta) => applyDeltaWithLookup(idMapping, delta, updatablePartitions));
 };
 /**
  * Applies the given {@link Delta delta} to {@link nodes INodeBase} given as the values of a {@link IdMapping ID mapping id → node}.
@@ -249,11 +452,11 @@ export const applyDeltasWithLookup = (idMapping, deltas) => {
  * @usage should look as follows.
  *
  * ```typescript
- * const {roots, idMapping} = deserializeAsLDMModelWithMapping(serializationChunk, handleDelta);
+ * const {roots, idMapping} = deserializeAsLDMModelWithMapping(serializationChunk, receiveDelta);
  * applyDeltaWithLookup(idMapping, delta);
  * ```
  */
-export const applyDeltaWithLookup = (idMapping, delta) => deltaApplier(idMapping)(delta);
+export const applyDeltaWithLookup = (idMapping, delta, updatablePartitions) => deltaApplier(idMapping, updatablePartitions)(delta);
 /**
  * Updates the given {@link IdMapping ID mapping} with the given {@link IDelta delta}.
  * This is important if the delta adds a newly-created node to the model.
@@ -269,6 +472,9 @@ export const updateIdMappingWithDelta = (idMapping, delta) => {
     if (delta instanceof AnnotationAddedDelta) {
         idMapping.updateWith(delta.newAnnotation);
     }
+    if (delta instanceof PartitionAddedDelta) {
+        idMapping.updateWith(delta.newPartition);
+    }
     // (nothing to be done: no need –yet?- to take deleted child nodes out of the ID mapping)
 };
 //# sourceMappingURL=appliers.js.map