@lionweb/class-core 0.7.0-beta.1 → 0.7.0-beta.11

package/src/factory.ts

@@ -0,0 +1,49 @@
+// 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 { lazyMapGet } from "@lionweb/ts-utils"
+import { ILanguageBase, NodeBaseFactory } from "./base-types.js"
+import { DeltaHandler } from "./deltas/index.js"
+
+/**
+ * @return a {@link NodeBaseFactory factory function} that works for all given {@link ILanguageBase language bases}.
+ */
+export const combinedFactoryFor = (languageBases: ILanguageBase[], handleDelta?: DeltaHandler): NodeBaseFactory => {
+    // create lookup map:
+    const languageKey2version2factory: { [key: string]: { [version: string]: NodeBaseFactory } } = {}
+    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"!)
+    })
+
+    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`)
+        }
+        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(", ")}` : ``}`)
+        }
+        return factory(classifier, id)
+    }
+}
+

package/src/id-mapping.ts

@@ -51,6 +51,9 @@ export class IdMapping {
             ? null
             : (this.nodesById[idOrUnresolved] ?? unresolved);
 
+    /**
+     * Updates this {@link IdMapping} with the given `node` *and all its descendants* (recursively).
+     */
     updateWith(node: INodeBase) {
         this.nodesById[node.id] = node;
         node.children   // recurse into all children

package/src/index.ts

@@ -21,6 +21,7 @@ export * from "./deltas/index.js";
 export * from "./deserializer.js";
 export { deepDuplicateWith } from "./duplicator.js";
 export * from "./id-mapping.js";
+export { combinedFactoryFor } from "./factory.js";
 // skip linking.js: see comment there
 export * from "./LionCore_builtins.g.js";
 export {serializeNodeBases} from "./serializer.js";

package/src/value-managers/annotations.ts

@@ -18,14 +18,15 @@
 import { action, observable } from "mobx"
 
 import { INodeBase, removeFromParent } from "../base-types.js"
+import { checkIndex, ValueManager } from "./base.js"
 import {
     AnnotationAddedDelta,
     AnnotationDeletedDelta,
+    AnnotationMovedAndReplacedInSameParentDelta,
     AnnotationMovedFromOtherParentDelta,
     AnnotationMovedInSameParentDelta,
     AnnotationReplacedDelta
 } from "../deltas/index.js"
-import { checkIndex, ValueManager } from "./base.js"
 
 
 /**
@@ -119,6 +120,31 @@ export class AnnotationsValueManager extends ValueManager {
         this.emitDelta(() => new AnnotationReplacedDelta(this.container, index, replacedAnnotation, newAnnotation));
     }
 
+    /**
+     * @return the moved and replaced annotations, as an array tuple.
+     */
+    @action moveAndReplaceAtIndexDirectly(oldIndex: number, newIndex: number): [INodeBase, INodeBase] | undefined {
+        checkIndex(oldIndex, this.annotations.length, false);
+        checkIndex(newIndex, this.annotations.length, false);
+        if (oldIndex !== newIndex) {
+            const movedAnnotation = this.annotations[oldIndex];
+            const replacedAnnotation = this.annotations[newIndex];
+            this.annotations[newIndex] = movedAnnotation;
+            this.annotations.splice(oldIndex, 1);
+            replacedAnnotation.detach();
+            return [movedAnnotation, replacedAnnotation];
+        }
+        return undefined;
+    }
+
+    @action moveAndReplaceAtIndex(oldIndex: number, newIndex: number) {
+        const participants = this.moveAndReplaceAtIndexDirectly(oldIndex, newIndex);
+        if (participants !== undefined) {
+            const [movedAnnotation, replacedAnnotation] = participants;
+            this.emitDelta(() => new AnnotationMovedAndReplacedInSameParentDelta(this.container, oldIndex, newIndex, replacedAnnotation, movedAnnotation));
+        }
+    }
+
     @action removeDirectly(annotationToRemove: INodeBase): number {
         const index = this.annotations.indexOf(annotationToRemove);
         if (index > -1) {

package/src/value-managers/containments.ts

@@ -19,7 +19,14 @@ import { Containment } from "@lionweb/core"
 import { action, observable } from "mobx"
 
 import { INodeBase, removeFromParent } from "../base-types.js"
-import { ChildAddedDelta, ChildDeletedDelta, ChildMovedDelta, ChildMovedInSameContainmentDelta, ChildReplacedDelta } from "../deltas/index.js"
+import {
+    ChildAddedDelta,
+    ChildDeletedDelta,
+    ChildMovedAndReplacedFromOtherContainmentInSameParentDelta, ChildMovedAndReplacedInSameContainmentDelta,
+    ChildMovedFromOtherContainmentDelta,
+    ChildMovedInSameContainmentDelta,
+    ChildReplacedDelta
+} from "../deltas/index.js"
 import { checkIndex, FeatureValueManager } from "./base.js"
 
 
@@ -68,11 +75,33 @@ export abstract class SingleContainmentValueManager<T extends INodeBase> extends
     @action addDirectly(newChild: T) {
         const oldChild = this.getDirectly();
         if (oldChild !== undefined) {
-            throw new Error(`replacing a child using addDirectly on a value manager for a single-valued containment isn't allowed`);    // FIXME  unit test this
+            throw new Error(`replacing a child using addDirectly on a value manager for a single-valued containment isn't allowed`);    // TODO  unit test this
         }
         this.child.set(newChild);
     }
 
+    @action replaceWith(newChild: T) {
+        const oldChild = this.getDirectly();
+        if (oldChild === undefined) {
+            // not a proper replace, but an add-set => delegate to regular setter (— unfortunately, through necessarily “unfolding the hierarchy”):
+            if (this instanceof OptionalSingleContainmentValueManager) {
+                this.set(newChild);
+            }
+            if (this instanceof RequiredSingleContainmentValueManager) {
+                this.set(newChild);
+            }
+        } else {
+            if (oldChild === newChild) {
+                // do nothing: nothing's changed
+            } else {
+                oldChild.detach();
+                this.setDirectly(newChild);
+                newChild.attachTo(this.container, this.feature);
+                this.emitDelta(() => new ChildReplacedDelta(this.container, this.feature, 0, oldChild, newChild));
+            }
+        }
+    }
+
 }
 
 
@@ -96,7 +125,7 @@ export class OptionalSingleContainmentValueManager<T extends INodeBase> extends
                 if (newChild.parent && newChild.containment) {
                     const oldParent = newChild.parent;
                     removeFromParent(oldParent, newChild);
-                    this.emitDelta(() => new ChildMovedDelta(oldParent, newChild.containment!, 0, this.container, this.feature, 0, newChild));
+                    this.emitDelta(() => new ChildMovedFromOtherContainmentDelta(oldParent, newChild.containment!, 0, this.container, this.feature, 0, newChild));
                 } else {
                     this.emitDelta(() => new ChildAddedDelta(this.container, this.feature, 0, newChild));
                 }
@@ -155,7 +184,7 @@ export class RequiredSingleContainmentValueManager<T extends INodeBase> extends
                 if (newChild.parent && newChild.containment) {
                     const oldParent = newChild.parent;
                     removeFromParent(oldParent, newChild);
-                    this.emitDelta(() => new ChildMovedDelta(oldParent, newChild.containment!, 0, this.container, this.feature, 0, newChild));
+                    this.emitDelta(() => new ChildMovedFromOtherContainmentDelta(oldParent, newChild.containment!, 0, this.container, this.feature, 0, newChild));
                 } else {
                     this.emitDelta(() => new ChildAddedDelta(this.container, this.feature, 0, newChild));
                 }
@@ -228,7 +257,7 @@ export abstract class MultiContainmentValueManager<T extends INodeBase> extends
             this.emitDelta(() => new ChildAddedDelta(this.container, this.containment, index, newChild));
         } else {
             const oldIndex = removeFromParent(newChild.parent, newChild);
-            this.emitDelta(() => new ChildMovedDelta(newChild.parent!, newChild.containment!, oldIndex, this.container, this.containment, index, newChild));
+            this.emitDelta(() => new ChildMovedFromOtherContainmentDelta(newChild.parent!, newChild.containment!, oldIndex, this.container, this.containment, index, newChild));
             newChild.detach();
         }
         newChild.attachTo(this.container, this.containment);
@@ -236,7 +265,7 @@ export abstract class MultiContainmentValueManager<T extends INodeBase> extends
 
     @action removeDirectly(childToRemove: T): number {
         const children = this.getDirectly();
-        const index = children.findIndex((child) => child === childToRemove);
+        const index = children.indexOf(childToRemove);
         if (index > -1) {
             children.splice(index, 1);
             return index;
@@ -244,6 +273,11 @@ export abstract class MultiContainmentValueManager<T extends INodeBase> extends
         return -1;
     }
 
+    @action removeAtIndexDirectly(index: number) {
+        checkIndex(index, this.children.length, false);
+        this.getDirectly().splice(index, 1);
+    }
+
     @action moveDirectly(oldIndex: number, newIndex: number): T | undefined {
         checkIndex(oldIndex, this.children.length, false);
         checkIndex(newIndex, this.children.length, false);
@@ -262,6 +296,37 @@ export abstract class MultiContainmentValueManager<T extends INodeBase> extends
         }
     }
 
+    @action replaceAtIndex(movedChild: T, newIndex: number) {
+        checkIndex(newIndex, this.children.length, false);
+        const replacedChild = this.children[newIndex];
+        if (replacedChild === movedChild) {
+            // do nothing: nothing's changed
+        } else {
+            this.children.splice(newIndex, 1, movedChild);
+            if (replacedChild.parent) {
+                const oldValueManager = replacedChild.parent.getContainmentValueManager(replacedChild.containment!);
+                const oldIndex = oldValueManager instanceof SingleContainmentValueManager
+                    ? 0
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    : (oldValueManager as MultiContainmentValueManager<any>).children.indexOf(replacedChild);
+                replacedChild.detach();
+                if (replacedChild.parent === movedChild.parent) {
+                    if (replacedChild.containment === movedChild.containment) {
+                        this.emitDelta(() => new ChildMovedAndReplacedInSameContainmentDelta(this.container, this.containment, oldIndex, newIndex, movedChild, replacedChild));
+                    } else {
+                        this.emitDelta(() => new ChildMovedAndReplacedFromOtherContainmentInSameParentDelta(this.container, replacedChild.containment!, oldIndex, this.containment, newIndex, movedChild, replacedChild));
+                    }
+                } else {
+                    this.emitDelta(() => new ChildMovedFromOtherContainmentDelta(replacedChild.parent!, replacedChild.containment!, oldIndex, this.container, this.containment, newIndex, movedChild));
+                }
+            } else {
+                // not a move+replace, but a regular replace instead:
+                this.emitDelta(() => new ChildReplacedDelta(this.container, this.containment, newIndex, replacedChild, movedChild));
+            }
+            movedChild.attachTo(this.container, this.containment);
+        }
+    }
+
 }
 
 
@@ -274,7 +339,7 @@ export class OptionalMultiContainmentValueManager<T extends INodeBase> extends M
 
     @action remove(childToRemove: T) {
         const children = this.getDirectly();
-        const index = children.findIndex((child) => child === childToRemove);
+        const index = children.indexOf(childToRemove);
         if (index > -1) {
             children.splice(index, 1);
             childToRemove.detach();
@@ -302,7 +367,7 @@ export class RequiredMultiContainmentValueManager<T extends INodeBase> extends M
 
     @action remove(childToRemove: T) {
         const children = this.getDirectly();
-        const index = children.findIndex((child) => child === childToRemove);
+        const index = children.indexOf(childToRemove);
         if (index > -1) {
             if (children.length === 1) {
                 this.throwOnUnset();

package/src/value-managers/references.ts

@@ -19,7 +19,12 @@ import { Reference, SingleRef } from "@lionweb/core"
 import { action, observable } from "mobx"
 
 import { INodeBase } from "../base-types.js"
-import { ReferenceAddedDelta, ReferenceDeletedDelta, ReferenceMovedInSameReferenceDelta, ReferenceReplacedDelta } from "../deltas/index.js"
+import {
+    EntryMovedInSameReferenceDelta,
+    ReferenceAddedDelta,
+    ReferenceChangedDelta,
+    ReferenceDeletedDelta
+} from "../deltas/index.js"
 import { checkIndex, FeatureValueManager } from "./base.js"
 
 
@@ -37,6 +42,7 @@ export abstract class ReferenceValueManager<T extends INodeBase> extends Feature
     /**
      * Adds the given target to the reference.
      * For a single-valued reference, this replaces an already-present target.
+     * **Note**: this method predominantly exists for the benefit of the deserializer and duplicator!
      */
     abstract addDirectly(newTarget: SingleRef<T> | undefined): void;
 
@@ -89,18 +95,18 @@ export class OptionalSingleReferenceValueManager<T extends INodeBase> extends Si
             return
         }
         if (newTarget === undefined) {
-            this.addDirectly(undefined);
+            this.setDirectly(undefined);
             if (oldTarget === undefined) {
                 // (nothing)
             } else {
                 this.emitDelta(() => new ReferenceDeletedDelta(this.container, this.reference, 0, oldTarget));
             }
         } else {
-            this.addDirectly(newTarget);
+            this.setDirectly(newTarget);
             if (oldTarget === undefined) {
                 this.emitDelta(() => new ReferenceAddedDelta(this.container, this.reference, 0, newTarget));
             } else {
-                this.emitDelta(() => new ReferenceReplacedDelta(this.container, this.reference, 0, oldTarget, newTarget));
+                this.emitDelta(() => new ReferenceChangedDelta(this.container, this.reference, 0, oldTarget, newTarget));
             }
         }
     }
@@ -132,11 +138,11 @@ export class RequiredSingleReferenceValueManager<T extends INodeBase> extends Si
         if (newTarget === undefined) {
             this.throwOnUnset();
         } else {
-            this.addDirectly(newTarget);
+            this.setDirectly(newTarget);
             if (oldTarget === undefined) {
                 this.emitDelta(() => new ReferenceAddedDelta(this.container, this.reference, 0, newTarget));
             } else {
-                this.emitDelta(() => new ReferenceReplacedDelta(this.container, this.reference, 0, oldTarget, newTarget));
+                this.emitDelta(() => new ReferenceChangedDelta(this.container, this.reference, 0, oldTarget, newTarget));
             }
         }
     }
@@ -158,7 +164,7 @@ export abstract class MultiReferenceValueManager<T extends INodeBase> extends Re
     }
 
     get(): SingleRef<T>[] {
-        return this.getDirectly().slice();
+        return this.getDirectly().slice();  // make defensive copy
     }
 
     isSet(): boolean {
@@ -194,6 +200,11 @@ export abstract class MultiReferenceValueManager<T extends INodeBase> extends Re
 
     abstract remove(targetToRemove: SingleRef<T>): void;
 
+    @action removeAtIndexDirectly(index: number): SingleRef<T> {
+        checkIndex(index, this.targets.length, false);
+        return this.targets.splice(index, 1)[0];
+    }
+
     @action moveDirectly(oldIndex: number, newIndex: number): SingleRef<T> | undefined {
         checkIndex(oldIndex, this.targets.length, false);
         checkIndex(newIndex, this.targets.length, false);
@@ -208,7 +219,16 @@ export abstract class MultiReferenceValueManager<T extends INodeBase> extends Re
     @action move(oldIndex: number, newIndex: number) {
         const target = this.moveDirectly(oldIndex, newIndex);
         if (target !== undefined) {
-            this.emitDelta(() => new ReferenceMovedInSameReferenceDelta(this.container, this.reference, oldIndex, newIndex, target));
+            this.emitDelta(() => new EntryMovedInSameReferenceDelta(this.container, this.reference, oldIndex, newIndex, target));
+        }
+    }
+
+    @action moveAndReplaceDirectly(oldIndex: number, newIndex: number) {
+        checkIndex(oldIndex, this.targets.length, false);
+        checkIndex(newIndex, this.targets.length, false);
+        if (oldIndex !== newIndex) {
+            this.targets.splice(newIndex, 1, this.targets[oldIndex]);
+            this.targets.splice(oldIndex, 1);
         }
     }