@lionweb/class-core 0.7.0-beta.12 → 0.7.0-beta.14

package/src/LionCore_builtins.g.ts

@@ -42,7 +42,7 @@ import {
 } from "@lionweb/json";
 
 import {
-    DeltaHandler,
+    DeltaReceiver,
     ILanguageBase,
     INodeBase,
     NodeBase,
@@ -110,7 +110,7 @@ export class LionCore_builtinsBase implements ILanguageBase {
         this._wiredUp = true;
     }
 
-    factory(_handleDelta?: DeltaHandler): NodeBaseFactory {
+    factory(_receiveDelta?: DeltaReceiver): NodeBaseFactory {
         return (classifier: Classifier, _id: LionWebId) => {
             const {language} = classifier;
             throw new Error(`can't instantiate ${classifier.name} (key=${classifier.key}): classifier is not known in language ${language.name} (key=${language.key}, version=${language.version})`);

package/src/base-types.ts

@@ -35,7 +35,7 @@ import { makeObservable } from "mobx"
 import {
     AnnotationsValueManager,
     ContainmentValueManager,
-    DeltaHandler,
+    DeltaReceiver,
     FeatureValueManager,
     MultiContainmentValueManager,
     MultiReferenceValueManager,
@@ -178,9 +178,9 @@ export interface INodeBase extends Node {
     get referenceTargets(): INodeBase[];
 
     /**
-     * An optionally-installed {@link DeltaHandler}.
+     * An optionally-installed {@link DeltaReceiver}.
      */
-    handleDelta?: DeltaHandler;
+    receiveDelta?: DeltaReceiver;
 
 
     /**
@@ -194,7 +194,7 @@ export interface INodeBase extends Node {
 /**
  * The base type for any node that's managed by a, potentially delta-emitting, API.
  *
- * It receives a {@link DeltaHandler} to pass {@link IDelta deltas} to
+ * It receives a {@link DeltaReceiver} to pass {@link IDelta deltas} to
  * that occur due to changes to values of its features,
  * as well as moving among parents and deletion.
  *
@@ -225,7 +225,7 @@ export abstract class NodeBase implements INodeBase {
     }
 
 
-    protected constructor(readonly classifier: Classifier, readonly id: LionWebId, readonly handleDelta?: DeltaHandler, parentage?: Parentage) {
+    protected constructor(readonly classifier: Classifier, readonly id: LionWebId, readonly receiveDelta?: DeltaReceiver, parentage?: Parentage) {
         this.classifier = classifier;
         this.id = id;
         if (parentage) {
@@ -347,32 +347,7 @@ export type NodeBaseFactory = (classifier: Classifier, id: LionWebId) => INodeBa
  */
 export interface ILanguageBase {
     language: Language;
-    factory(handleDelta?: DeltaHandler): NodeBaseFactory;
+    factory(receiveDelta?: DeltaReceiver): NodeBaseFactory;
     enumLiteralFrom<T>(enumerationLiteral: EnumerationLiteral): T;
 }
 
-
-/**
- * Removes the given child node from its parent, and returns its containment index.
- */
-export const removeFromParent = (parent: INodeBase | undefined, child: INodeBase): number => {
-    if (parent === undefined) {
-        throw new Error(`can't remove an orphan from its parent`);
-    }
-    if (child.containment instanceof Containment) {
-        const valueManager = parent.getContainmentValueManager(child.containment);
-        if (valueManager instanceof SingleContainmentValueManager) {
-            valueManager.setDirectly(undefined);
-            return 0;
-        } else if (valueManager instanceof MultiContainmentValueManager) {
-            return valueManager.removeDirectly(child);
-        } else {
-            throw new Error(`don't know how to remove a child that's contained through a value manager of type ${valueManager.constructor.name}`);
-        }
-    }
-    if (child.containment === null) {
-        return parent.annotationsValueManager.removeDirectly(child);
-    }
-    throw new Error(`not going to remove a child from its parent without knowing how it's contained`);
-}
-

package/src/convenience.ts

@@ -18,7 +18,7 @@
 import { incomingReferences as lwIncomingReferences, ReferenceValue } from "@lionweb/core"
 import { LionWebId } from "@lionweb/json"
 import { NodeDuplicator } from "./duplicator.js"
-import { deepDuplicateWith, DeltaHandler, IdMapping, ILanguageBase, INodeBase } from "./index.js"
+import { deepDuplicateWith, DeltaReceiver, IdMapping, ILanguageBase, INodeBase } from "./index.js"
 import { nodeBaseReader } from "./serializer.js"
 
 
@@ -57,10 +57,10 @@ export const incomingReferences = (targetNodeOrNodes: INodeBase | INodeBase[], r
  * *without* generating new IDs.
  * @param languageBases the {@link ILanguageBase language bases} of the languages that the nodes might come from
  *  — these are necessary for their factories
- * @param handleDelta an optional {@link DeltaHandler} that gets installed on the deep-cloned nodes
+ * @param receiveDelta an optional {@link DeltaReceiver} that gets installed on the deep-cloned nodes
  */
-export const deepClonerFor = (languageBases: ILanguageBase[], handleDelta?: DeltaHandler) =>
-    deepDuplicatorFor(languageBases, (originalNode) => originalNode.id, handleDelta);
+export const deepClonerFor = (languageBases: ILanguageBase[], receiveDelta?: DeltaReceiver) =>
+    deepDuplicatorFor(languageBases, (originalNode) => originalNode.id, receiveDelta);
 
 
 /**
@@ -73,13 +73,13 @@ export type NewIdFunction = (originalNode: INodeBase) => LionWebId;
  * @return a {@link NodeDuplicator} function that does the “obvious” thing, given the parameters:
  * @param languageBases an array of languages in the form of {@link ILanguageBase}s
  * @param newIdFunc a function that computes a – not necessarily new – ID from a given original {@link INodeBase node}
- * @param handleDelta an optional {@link DeltaHandler}
+ * @param receiveDelta an optional {@link DeltaReceiver}
  * @param idMapping an optional {@link IdMapping}
  */
-export const defaultNodeDuplicatorFor = (languageBases: ILanguageBase[], newIdFunc: NewIdFunction, handleDelta?: DeltaHandler, idMapping?: IdMapping): NodeDuplicator =>
+export const defaultNodeDuplicatorFor = (languageBases: ILanguageBase[], newIdFunc: NewIdFunction, receiveDelta?: DeltaReceiver, idMapping?: IdMapping): NodeDuplicator =>
     (originalNode: INodeBase) => {
         const languageBase = languageBases.find((languageBase) => languageBase.language === originalNode.classifier.language)!;
-        const duplicatedNode = languageBase.factory(handleDelta)(originalNode.classifier, newIdFunc(originalNode));
+        const duplicatedNode = languageBase.factory(receiveDelta)(originalNode.classifier, newIdFunc(originalNode));
         idMapping?.updateWith(duplicatedNode);
         return [duplicatedNode, originalNode.setFeatures];
     };
@@ -91,8 +91,8 @@ export const defaultNodeDuplicatorFor = (languageBases: ILanguageBase[], newIdFu
  * @param languageBases the {@link ILanguageBase language bases} of the languages that the nodes might come from
  *  — these are necessary for their factories
  * @param newIdFunc a function that computes a – not necessarily new – ID from a given original {@link INodeBase node}
- * @param handleDelta an optional {@link DeltaHandler} that gets installed on the deep-cloned nodes
+ * @param receiveDelta an optional {@link DeltaReceiver} that gets installed on the deep-cloned nodes
  */
-export const deepDuplicatorFor = (languageBases: ILanguageBase[], newIdFunc: NewIdFunction, handleDelta?: DeltaHandler, idMapping?: IdMapping) =>
-    deepDuplicateWith(defaultNodeDuplicatorFor(languageBases, newIdFunc, handleDelta, idMapping));
+export const deepDuplicatorFor = (languageBases: ILanguageBase[], newIdFunc: NewIdFunction, receiveDelta?: DeltaReceiver, idMapping?: IdMapping) =>
+    deepDuplicateWith(defaultNodeDuplicatorFor(languageBases, newIdFunc, receiveDelta, idMapping));
 

package/src/deltas/appliers.ts

@@ -469,7 +469,7 @@ 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);
  * ```
  */
@@ -485,7 +485,7 @@ export const applyDeltasWithLookup = (idMapping: IdMapping, deltas: IDelta[], up
  * @usage should look as follows.
  *
  * ```typescript
- * const {roots, idMapping} = deserializeAsLDMModelWithMapping(serializationChunk, handleDelta);
+ * const {roots, idMapping} = deserializeAsLDMModelWithMapping(serializationChunk, receiveDelta);
  * applyDeltaWithLookup(idMapping, delta);
  * ```
  */
@@ -508,6 +508,9 @@ export const updateIdMappingWithDelta = (idMapping: IdMapping, delta: IDelta) =>
     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)
 };
 

package/src/deltas/compositor.ts

@@ -0,0 +1,107 @@
+// Copyright 2025 TRUMPF Laser SE and other contributors
+//
+// Licensed under the Apache License, Version 2.0 (the "License")
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// SPDX-FileCopyrightText: 2025 TRUMPF Laser SE and other contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { CompositeDelta, DeltaReceiver, IDelta } from "../index.js"
+
+
+/**
+ * A <em>delta compositor</em> is used to <em>aggregate</em> deltas as {@link CompositeDelta composite deltas}.
+ *
+ * Usage:
+ * ```typescript
+ * const compositor = new Compositor(downstreamReceiveDelta);
+ * compositor.openComposite();
+ * // ...
+ * compositor.upstreamReceiveDelta(<delta>);
+ * // ...
+ * compositor.closeComposite();
+ * ```
+ */
+export class DeltaCompositor {
+
+    /**
+     * The {@link DeltaReceiver} implementation that either forwards to the given downstream delta handle
+     * or gathers deltas into composite deltas to forward to the downstream delta receiver later.
+     */
+    readonly upstreamReceiveDelta: DeltaReceiver;
+
+    /**
+     * An array of arrays of {@link IDelta deltas}, comprising a “stack”.
+     *
+     * Invariants:
+     *  - (I1) composite has been opened &hArr; `this.deltasInComposite !== undefined` / `Array.isArray(this.deltasInComposite)`
+     *  - (I2) this.deltasStack is either undefined or an array containing at least one array
+     */
+    private deltasStack: IDelta[][] | undefined = undefined;
+
+    /**
+     * @param downstreamReceiveDelta the {@link DeltaReceiver} that deltas get passed to.
+     * @param maximumNestingDepth the maximum depth that composites can be nested.
+     *  A maximum depth of e.g. 1 means that at most 1 composite can be open at any time.
+     */
+    constructor(private readonly downstreamReceiveDelta: DeltaReceiver, private readonly maximumNestingDepth: number = Infinity) {
+        if (maximumNestingDepth !== Infinity && (!Number.isInteger(maximumNestingDepth) || maximumNestingDepth < 0)) {
+            throw new Error(`maximum nesting depth must be a non-negative integer`);
+        }
+        this.upstreamReceiveDelta = (delta) => {
+            if (this.deltasStack === undefined) {
+                // pass on immediately:
+                this.downstreamReceiveDelta(delta);
+            } else {
+                // store for later:
+                this.deltasStack[this.deltasStack.length - 1].push(delta);  // (I2)
+            }
+        };
+    }
+
+    /**
+     * Opens a composite, meaning that all deltas passed to the {@link upstreamReceiveDelta} are gathered into a composite delta
+     * that gets forwarded to the downstream delta receiver as soon as the composite is closed.
+     *
+     * Composites can be nested, to the maximum depth configured through this class’ constructor,
+     * beyond which an error gets thrown.
+     */
+    openComposite = (): void => {
+        if (this.deltasStack === undefined) {
+            this.deltasStack = [];  // ==> (I1) + 1st half of (I2)
+        }
+        if (this.deltasStack.length >= this.maximumNestingDepth) {
+            throw new Error(`attempt occurred to start a nested composition exceeding the maximum nesting depth`)
+        }
+        this.deltasStack.push([]);  // ==> 2nd half of (I2)
+    }
+
+    /**
+     * Closes the current composite, producing the deltas gathered for this composite into a composite delta.
+     * Composites can be nested, and deltas only get forwarded to the downstream delta receiver after the top-level composite has been closed.
+     */
+    closeComposite = (): void => {
+        if (this.deltasStack === undefined) {
+            throw new Error(`attempt occurred to finish a composite without one being started`);
+        }
+
+        const parts = this.deltasStack.pop()!;  // is an array because of (I2)
+        if (this.deltasStack.length === 0) {    // last array popped from stack
+            this.deltasStack = undefined;   // maintain (I2)
+        }
+        if (parts.length > 0) {
+            this.upstreamReceiveDelta(new CompositeDelta(parts));
+        }
+    }
+
+}
+

package/src/deltas/index.ts

@@ -17,7 +17,9 @@
 
 export * from "./appliers.js";
 export * from "./base.js";
-export * from "./handlers.js";
+export * from "./compositor.js";
 export * from "./inverters.js";
+export * from "./receivers.js";
 export * from "./types.g.js";
 export * from "./serialization/index.js";
+

package/src/deltas/inverters.ts

@@ -91,13 +91,22 @@ export const invertDelta = (delta: IDelta): IDelta => {
         return new ChildMovedInSameContainmentDelta(delta.parent, delta.containment, delta.newIndex, delta.oldIndex, delta.movedChild);
     }
     if (delta instanceof ChildMovedAndReplacedFromOtherContainmentDelta) {
-        // TODO  implement
+        return new CompositeDelta([
+            new ChildMovedFromOtherContainmentDelta(delta.newParent, delta.newContainment, delta.newIndex, delta.oldParent, delta.oldContainment, delta.oldIndex, delta.movedChild),
+            new ChildAddedDelta(delta.newParent, delta.newContainment, delta.newIndex, delta.replacedChild)
+        ]);
     }
     if (delta instanceof ChildMovedAndReplacedFromOtherContainmentInSameParentDelta) {
-        // TODO  implement
+        return new CompositeDelta([
+            new ChildMovedFromOtherContainmentInSameParentDelta(delta.parent, delta.newContainment, delta.newIndex, delta.movedChild, delta.oldContainment, delta.oldIndex),
+            new ChildAddedDelta(delta.parent, delta.newContainment, delta.newIndex, delta.replacedChild)
+        ]);
     }
     if (delta instanceof ChildMovedAndReplacedInSameContainmentDelta) {
-        // TODO  implement
+        return new CompositeDelta([
+            new ChildMovedInSameContainmentDelta(delta.parent, delta.containment, delta.newIndex, delta.oldIndex, delta.movedChild),
+            new ChildAddedDelta(delta.parent, delta.containment, delta.newIndex, delta.replacedChild)
+        ]);
     }
     if (delta instanceof AnnotationAddedDelta) {
         return new AnnotationDeletedDelta(delta.parent, delta.index, delta.newAnnotation);
@@ -115,10 +124,16 @@ export const invertDelta = (delta: IDelta): IDelta => {
         return new AnnotationMovedInSameParentDelta(delta.parent, delta.newIndex, delta.oldIndex, delta.movedAnnotation);
     }
     if (delta instanceof AnnotationMovedAndReplacedFromOtherParentDelta) {
-        // TODO  implement
+        return new CompositeDelta([
+            new AnnotationMovedFromOtherParentDelta(delta.newParent, delta.newIndex, delta.oldParent, delta.oldIndex, delta.movedAnnotation),
+            new AnnotationAddedDelta(delta.newParent, delta.newIndex, delta.replacedAnnotation)
+        ]);
     }
     if (delta instanceof AnnotationMovedAndReplacedInSameParentDelta) {
-        // TODO  implement
+        return new CompositeDelta([
+            new AnnotationMovedInSameParentDelta(delta.parent, delta.newIndex, delta.oldIndex, delta.movedAnnotation),
+            new AnnotationAddedDelta(delta.parent, delta.newIndex, delta.replacedAnnotation)
+        ]);
     }
     if (delta instanceof ReferenceAddedDelta) {
         return new ReferenceDeletedDelta(delta.parent, delta.reference, delta.index, delta.newTarget);
@@ -133,19 +148,28 @@ export const invertDelta = (delta: IDelta): IDelta => {
         return new EntryMovedFromOtherReferenceDelta(delta.newParent, delta.newReference, delta.newIndex, delta.oldParent, delta.oldReference, delta.oldIndex, delta.movedTarget);
     }
     if (delta instanceof EntryMovedFromOtherReferenceInSameParentDelta) {
-        // TODO  implement
+        return new EntryMovedFromOtherReferenceInSameParentDelta(delta.parent, delta.newReference, delta.newIndex, delta.oldReference, delta.oldIndex, delta.movedTarget);
     }
     if (delta instanceof EntryMovedInSameReferenceDelta) {
         return new EntryMovedInSameReferenceDelta(delta.parent, delta.reference, delta.newIndex, delta.oldIndex, delta.movedTarget);
     }
     if (delta instanceof EntryMovedAndReplacedFromOtherReferenceDelta) {
-        // TODO  implement
+        return new CompositeDelta([
+            new EntryMovedFromOtherReferenceDelta(delta.newParent, delta.newReference, delta.newIndex, delta.oldParent, delta.oldReference, delta.oldIndex, delta.movedTarget),
+            new ReferenceAddedDelta(delta.newParent, delta.newReference, delta.newIndex, delta.replacedTarget)
+        ]);
     }
     if (delta instanceof EntryMovedAndReplacedFromOtherReferenceInSameParentDelta) {
-        return new EntryMovedAndReplacedFromOtherReferenceInSameParentDelta(delta.parent, delta.newReference, delta.newIndex, delta.oldReference, delta.oldIndex, delta.replacedTarget, delta.movedTarget);
+        return new CompositeDelta([
+            new EntryMovedFromOtherReferenceInSameParentDelta(delta.parent, delta.newReference, delta.newIndex, delta.oldReference, delta.oldIndex, delta.movedTarget),
+            new ReferenceAddedDelta(delta.parent, delta.newReference, delta.newIndex, delta.replacedTarget)
+        ]);
     }
     if (delta instanceof EntryMovedAndReplacedInSameReferenceDelta) {
-        // TODO  implement
+        return new CompositeDelta([
+            new EntryMovedInSameReferenceDelta(delta.parent, delta.reference, delta.newIndex, delta.oldIndex, delta.movedTarget),
+            new ReferenceAddedDelta(delta.parent, delta.reference, delta.newIndex, delta.replacedTarget)
+        ]);
     }
     if (delta instanceof CompositeDelta) {
         return new CompositeDelta(delta.parts.map(invertDelta));

package/src/deltas/receivers.ts

@@ -0,0 +1,92 @@
+// Copyright 2025 TRUMPF Laser SE and other contributors
+//
+// Licensed under the Apache License, Version 2.0 (the "License")
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// SPDX-FileCopyrightText: 2025 TRUMPF Laser SE and other contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { asPrettyJsonString } from "@lionweb/ts-utils"
+import { IDelta } from "./base.js"
+import { serializeDelta } from "./serialization/index.js"
+
+/**
+ * A type for functions that receive deltas.
+ */
+export type DeltaReceiver = (delta: IDelta) => void;
+
+/**
+ * Legacy alias for {@link DeltaReceiver}.
+ */
+export type DeltaHandler = (delta: IDelta) => void;
+
+/**
+ * @return a tuple consisting of a {@link DeltaReceiver} implementation (as 1st member) that pushes any received delta unto the tuple's 2nd member: an array of {@link IDelta deltas}.
+ * @param printSerializations determines whether the deltas are serialized as JSON and printed to the JavaScript console.
+ */
+export const collectingDeltaReceiver = (printSerializations = false): [DeltaReceiver, IDelta[]] => {
+    const deltas: IDelta[] = [];
+    const receiveDelta: DeltaReceiver = (delta) => {
+        deltas.push(delta);
+        if (printSerializations) {
+            console.log(asPrettyJsonString(serializeDelta(delta)));
+        }
+    };
+    return [receiveDelta, deltas];
+};
+
+/**
+ * Legacy alias for {@link collectingDeltaReceiver}.
+ */
+export const collectingDeltaHandler = collectingDeltaReceiver;
+
+/**
+ * An interface for {@link DeltaReceiver delta receivers} that can be switched on and off — “latchingDeltaReceiverFrom”.
+ */
+export interface LatchingDeltaReceiver extends DeltaReceiver {
+    latch(emitDeltas: boolean): void;
+}
+
+/**
+ * Legacy alias for {@link LatchingDeltaReceiver}.
+ */
+export interface LatchingDeltaHandler extends LatchingDeltaReceiver {};
+
+/**
+ * @return a latching version of the given {@link DeltaReceiver delta receiver}.
+ */
+export const latchingDeltaReceiverFrom = (receiveDelta: DeltaReceiver): LatchingDeltaReceiver => {
+    let emitDeltas = false;
+    return Object.assign(
+        (delta: IDelta) => {
+            if (emitDeltas) {
+                receiveDelta(delta);
+            }
+        },
+        {
+            latch(emitDeltas_: boolean) {
+                emitDeltas = emitDeltas_;
+            },
+        },
+    );
+};
+
+
+/**
+ * @return a {@link DeltaReceiver delta receiver} implementation that forwards received deltas to the given {@link DeltaReceiver delta receivers}.
+ * This is necessary e.g. for combining using the delta protocol with an undo mechanism.
+ */
+export const deltaReceiverForwardingTo = (...deltaReceivers: DeltaReceiver[]): DeltaReceiver =>
+    (delta) => {
+        deltaReceivers.forEach((receiveDelta) => receiveDelta(delta));
+    };
+

package/src/deserializer.ts

@@ -21,7 +21,6 @@ import {
     Containment,
     defaultSimplisticHandler,
     Enumeration,
-    Language,
     MemoisingSymbolTable,
     PrimitiveType,
     Property,
@@ -33,7 +32,8 @@ import {
 import { LionWebId, LionWebJsonChunk, LionWebJsonNode } from "@lionweb/json"
 import { byIdMap, keepDefineds } from "@lionweb/ts-utils"
 
-import { DeltaHandler, IdMapping, ILanguageBase, INodeBase } from "./index.js"
+import { DeltaReceiver, IdMapping, ILanguageBase, INodeBase } from "./index.js"
+import { combinedLanguageBaseLookupFor } from "./factory.js"
 import { NodesToInstall } from "./linking.js"
 
 
@@ -48,21 +48,6 @@ export type Deserializer<T> = (
 ) => T;
 
 
-const languageBaseLookupFor = (languageBases: ILanguageBase[]) =>
-    (language: Language) => {
-        const languageBase = languageBases.find((languageBase) => languageBase.language === language);
-        if (languageBase === undefined) {
-            throw new Error(`language ${language.name} (with key=${language.key} and version=${language.version}) not known`);
-        }
-        return languageBase;
-    };
-
-const factoryLookupFor = (languageBases: ILanguageBase[], handleDelta?: DeltaHandler) => {
-    const lookup = languageBaseLookupFor(languageBases);
-    return (language: Language) => lookup(language).factory(handleDelta);
-}
-
-
 /**
  * A quasi-tuple of the roots (of type {@link INodeBase}) of a model,
  * and its {@link IdMapping} instance.
@@ -73,13 +58,12 @@ export type RootsWithIdMapping = { roots: INodeBase[], idMapping: IdMapping };
 /**
  * @return a {@link Deserializer} function for the given languages (given as {@link ILanguageBase}s) that returns a {@link RootsWithIdMapping}.
  * @param languageBases the {@link ILanguageBase}s for (at least) all the languages used in the {@link LionWebJsonChunk} to deserialize, minus LionCore M3 and built-ins.
- * @param handleDelta an optional {@link DeltaHandler} that will be injected in all {@link INodeBase nodes} created.
+ * @param receiveDelta an optional {@link DeltaReceiver} that will be injected in all {@link INodeBase nodes} created.
  */
-export const nodeBaseDeserializerWithIdMapping = (languageBases: ILanguageBase[], handleDelta?: DeltaHandler): Deserializer<RootsWithIdMapping> => {
+export const nodeBaseDeserializerWithIdMapping = (languageBases: ILanguageBase[], receiveDelta?: DeltaReceiver): Deserializer<RootsWithIdMapping> => {
 
     const symbolTable = new MemoisingSymbolTable(languageBases.map(({language}) => language));
-    const languageBaseFor = languageBaseLookupFor(languageBases);
-    const factoryFor = factoryLookupFor(languageBases, handleDelta);
+    const languageBaseFor = combinedLanguageBaseLookupFor(languageBases);
 
     return (
         serializationChunk: LionWebJsonChunk,
@@ -98,7 +82,7 @@ export const nodeBaseDeserializerWithIdMapping = (languageBases: ILanguageBase[]
                 return undefined;
             }
 
-            const node = factoryFor(classifier.language)(classifier, id);
+            const node = languageBaseFor(classifier.language).factory(receiveDelta)(classifier, id);
 
             properties.forEach(({property: propertyMetaPointer, value}) => {
                 const feature = symbolTable.featureMatching(classifierMetaPointer, propertyMetaPointer);
@@ -219,10 +203,10 @@ export const nodeBaseDeserializerWithIdMapping = (languageBases: ILanguageBase[]
 /**
  * @return a {@link Deserializer} function for the languages (given as {@link ILanguageBase}s) that returns the roots (of type {@link INodeBase}) of the deserialized model.
  * @param languageBases the {@link ILanguageBase}s for (at least) all the languages used in the {@link LionWebJsonChunk} to deserialize, minus LionCore M3 and built-ins.
- * @param handleDelta an optional {@link DeltaHandler} that will be injected in all {@link INodeBase nodes} created.
+ * @param receiveDelta an optional {@link DeltaReceiver} that will be injected in all {@link INodeBase nodes} created.
  */
-export const nodeBaseDeserializer = (languageBases: ILanguageBase[], handleDelta?: DeltaHandler): Deserializer<INodeBase[]> => {
-    const deserializerWithIdMapping = nodeBaseDeserializerWithIdMapping(languageBases, handleDelta);
+export const nodeBaseDeserializer = (languageBases: ILanguageBase[], receiveDelta?: DeltaReceiver): Deserializer<INodeBase[]> => {
+    const deserializerWithIdMapping = nodeBaseDeserializerWithIdMapping(languageBases, receiveDelta);
     return (
         serializationChunk: LionWebJsonChunk,
         dependentNodes: INodeBase[] = [],

package/src/factory.ts

@@ -15,35 +15,49 @@
 // SPDX-FileCopyrightText: 2025 TRUMPF Laser SE and other contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import { Language } from "@lionweb/core"
 import { lazyMapGet } from "@lionweb/ts-utils"
 import { ILanguageBase, NodeBaseFactory } from "./base-types.js"
-import { DeltaHandler } from "./deltas/index.js"
+import { DeltaReceiver } from "./deltas/index.js"
+
 
 /**
- * @return a {@link NodeBaseFactory factory function} that works for all given {@link ILanguageBase language bases}.
+ * @return a function that looks up the {@link ILanguageBase language base} for the {@link Language language} passed to it,
+ * from among the given language bases.
+ * The returned function throws when the language wasn't among the languages the given bases were for.
+ * The lookup is hashmap-backed, so efficient.
  */
-export const combinedFactoryFor = (languageBases: ILanguageBase[], handleDelta?: DeltaHandler): NodeBaseFactory => {
+export const combinedLanguageBaseLookupFor = (languageBases: ILanguageBase[]): ((language: Language) => ILanguageBase) => {
     // create lookup map:
-    const languageKey2version2factory: { [key: string]: { [version: string]: NodeBaseFactory } } = {}
+    const languageKey2version2base: { [key: string]: { [version: string]: ILanguageBase } } = {}
     languageBases.forEach((languageBase) => {
         const {key, version} = languageBase.language
-        const version2factory = lazyMapGet(languageKey2version2factory, key, () => ({}))
-        lazyMapGet(version2factory, version, () => languageBase.factory(handleDelta))
-            // (Note: don't destructure factory from languageBase, as that will unbind it as "this"!)
+        const version2base = lazyMapGet(languageKey2version2base, key, () => ({}))
+        lazyMapGet(version2base, version, () => languageBase)
     })
 
-    return (classifier, id) => {
-        const {key, version, name} = classifier.language
-        const version2factory = languageKey2version2factory[key]
-        if (version2factory === undefined) {
-            throw new Error(`language ${name} with key=${key} not known`)
+    return (language) => {
+        const {key, version, name} = language
+        const version2base = languageKey2version2base[key]
+        if (version2base === undefined) {
+            throw new Error(`language ${name} with key=${key} not registered`)
         }
-        const factory = version2factory[version]
-        if (factory === undefined) {
-            const candidateVersions = Object.keys(version2factory)
-            throw new Error(`language ${name} with key=${key} and version=${version} not known${candidateVersions.length > 0 ? `- candidate version${candidateVersions.length > 1 ? `s` : ``}: ${candidateVersions.join(", ")}` : ``}`)
+        const base = version2base[version]
+        if (base === undefined) {
+            const candidateVersions = Object.keys(version2base)
+            throw new Error(`language ${name} with key=${key} and version=${version} not registered${candidateVersions.length > 0 ? `- candidate version${candidateVersions.length > 1 ? `s` : ``}: ${candidateVersions.join(", ")}` : ``}`)
         }
-        return factory(classifier, id)
+        return base
     }
 }
 
+
+/**
+ * @return a {@link NodeBaseFactory factory function} that works for all given {@link ILanguageBase language bases}.
+ */
+export const combinedFactoryFor = (languageBases: ILanguageBase[], receiveDelta?: DeltaReceiver): NodeBaseFactory => {
+    const baseOf = combinedLanguageBaseLookupFor(languageBases)
+    return (classifier, id) =>
+        baseOf(classifier.language).factory(receiveDelta)(classifier, id)
+}
+