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

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 { 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[], receiveDelta?: DeltaReceiver): 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(receiveDelta))
-            // (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)
+}
+

package/src/id-mapping.ts

@@ -30,35 +30,56 @@ type NodesById = { [id: LionWebId]: INodeBase }
  */
 export class IdMapping {
 
-    nodesById: NodesById;
+    private nodesById: NodesById;
     constructor(nodesById: NodesById) {
         this.nodesById = {...nodesById};
     }
     // TODO  consider using an instance of Map<Id, INodeBase> instead
 
-    fromId(id: LionWebId): INodeBase {
+    /**
+     * @return the {@link INodeBase node} with the given {@link LionWebId `id`}, or
+     * @throws an Error if no node with the given ID was registered.
+     */
+    fromId = (id: LionWebId): INodeBase => {
         if (!(id in this.nodesById)) {
             throw new Error(`node with id=${id} not in ID mapping`);
         }
         return this.nodesById[id];
     }
 
+    /**
+     * @return the {@link INodeBase node} with the given {@link LionWebId `id`},
+     * or `undefined` if no node with the given ID was registered.
+     */
     tryFromId = (id: LionWebId): (INodeBase | undefined) =>
         this.nodesById[id];
 
+    /**
+     * @return the {@link INodeBase node} referenced from the given {@link LionWebId ID},
+     * or `unresolved` if `unresolved` was passed in or no node with the given ID was registered.
+     */
     fromRefId = (idOrUnresolved: IdOrUnresolved): SingleRef<INodeBase> =>
-        idOrUnresolved === null
-            ? null
+        idOrUnresolved === unresolved
+            ? unresolved
             : (this.nodesById[idOrUnresolved] ?? unresolved);
 
     /**
      * Updates this {@link IdMapping} with the given `node` *and all its descendants* (recursively).
      */
-    updateWith(node: INodeBase) {
+    updateWith= (node: INodeBase) => {
         this.nodesById[node.id] = node;
         node.children   // recurse into all children
             .forEach((child) => this.updateWith(child));
     }
 
+    /**
+     * Re-initializes this {@link IdMapping ID mapping} with the given nodes-by-ID.
+     * This completely removes all registrations of nodes,
+     * and should only be used by components which are in complete control of the nodes being passed to this method.
+     */
+    reinitializeWith = (nodesById: NodesById) => {
+        this.nodesById = nodesById
+    }
+
 }
 

package/src/textualizer.ts

@@ -54,7 +54,7 @@ export const asTreeTextWith = (identificationFor: (node: INodeBase) => string):
                 const valueManager = node.getPropertyValueManager(feature)
                 const displayValue = (() => {
                     if (!valueManager.isSet()) {
-                        return `$<not set>`
+                        return `<not set>`
                     }
                     const value = valueManager.getDirectly()
                     if (feature.type === LionCore_builtinsBase.INSTANCE.String) {

package/src/value-managers/annotations.ts

@@ -17,7 +17,7 @@
 
 import { action, observable } from "mobx"
 
-import { INodeBase, removeFromParent } from "../base-types.js"
+import { INodeBase } from "../base-types.js"
 import { checkIndex, ValueManager } from "./base.js"
 import {
     AnnotationAddedDelta,
@@ -67,7 +67,7 @@ export class AnnotationsValueManager extends ValueManager {
             newAnnotation.attachTo(this.container, null);
             return false;
         } else {
-            const oldIndex = removeFromParent(oldParent, newAnnotation);
+            const oldIndex = oldParent.annotationsValueManager.removeDirectly(newAnnotation);
             newAnnotation.attachTo(this.container, null);
             return [oldParent, oldIndex];
         }

package/src/value-managers/containments.ts

@@ -18,12 +18,15 @@
 import { Containment } from "@lionweb/core"
 import { action, observable } from "mobx"
 
-import { INodeBase, removeFromParent } from "../base-types.js"
+import { INodeBase } from "../base-types.js"
 import {
     ChildAddedDelta,
     ChildDeletedDelta,
-    ChildMovedAndReplacedFromOtherContainmentInSameParentDelta, ChildMovedAndReplacedInSameContainmentDelta,
+    ChildMovedAndReplacedFromOtherContainmentDelta,
+    ChildMovedAndReplacedFromOtherContainmentInSameParentDelta,
+    ChildMovedAndReplacedInSameContainmentDelta,
     ChildMovedFromOtherContainmentDelta,
+    ChildMovedFromOtherContainmentInSameParentDelta,
     ChildMovedInSameContainmentDelta,
     ChildReplacedDelta
 } from "../deltas/index.js"
@@ -80,24 +83,38 @@ export abstract class SingleContainmentValueManager<T extends INodeBase> extends
         this.child.set(newChild);
     }
 
-    @action replaceWith(newChild: T) {
-        const oldChild = this.getDirectly();
-        if (oldChild === undefined) {
+    @action replaceWith(movedChild: T) {
+        const replacedChild = this.getDirectly();
+        if (replacedChild === 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);
+                this.set(movedChild);
             }
             if (this instanceof RequiredSingleContainmentValueManager) {
-                this.set(newChild);
+                this.set(movedChild);
             }
         } else {
-            if (oldChild === newChild) {
+            if (replacedChild === movedChild) {
                 // 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));
+                if (movedChild.parent === undefined) {
+                    this.emitDelta(() => new ChildReplacedDelta(this.container, this.feature, 0, replacedChild, movedChild));
+                } else {
+                    if (movedChild.parent === this.container) {
+                        if (movedChild.containment === this.containment) {
+                            this.emitDelta(() => new ChildMovedAndReplacedInSameContainmentDelta(this.container, this.containment, 0, 0, movedChild, replacedChild));
+                        } else {
+                            const oldIndex = removeFromContainment(replacedChild);
+                            this.emitDelta(() => new ChildMovedAndReplacedFromOtherContainmentInSameParentDelta(this.container, movedChild.containment!, oldIndex, this.containment, 0, movedChild, replacedChild));
+                        }
+                    } else {
+                        const oldIndex = removeFromContainment(replacedChild);
+                        this.emitDelta(() => new ChildMovedAndReplacedFromOtherContainmentDelta(this.container, this.containment, 0, movedChild, movedChild.parent!, movedChild.containment!, oldIndex, replacedChild));
+                    }
+                }
+                this.setDirectly(movedChild);
+                movedChild.attachTo(this.container, this.containment);
+                replacedChild.detach();
             }
         }
     }
@@ -124,7 +141,7 @@ export class OptionalSingleContainmentValueManager<T extends INodeBase> extends
             } else {
                 if (newChild.parent && newChild.containment) {
                     const oldParent = newChild.parent;
-                    removeFromParent(oldParent, newChild);
+                    removeFromContainment(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));
@@ -141,13 +158,14 @@ export class OptionalSingleContainmentValueManager<T extends INodeBase> extends
                 if (oldChild === newChild) {
                     // do nothing: nothing's changed
                 } else {
+                    // FIXME  this could emit 2 deltas where it should be a single ChildReplaced-delta
                     if (oldChild.parent && oldChild.containment && oldChild.parent === this.container && oldChild.containment === this.feature) {
                         // FIXME  oldChild.parent COULD be this.container
                         this.emitDelta(() => new ChildDeletedDelta(this.container, this.feature, 0, oldChild));
                     }
                     oldChild.detach();
                     if (newChild.parent && newChild.containment) {
-                        removeFromParent(newChild.parent, newChild);
+                        removeFromContainment(newChild);
                     }
                     this.setDirectly(newChild);
                     newChild.attachTo(this.container, this.feature);
@@ -183,7 +201,7 @@ export class RequiredSingleContainmentValueManager<T extends INodeBase> extends
             } else {
                 if (newChild.parent && newChild.containment) {
                     const oldParent = newChild.parent;
-                    removeFromParent(oldParent, newChild);
+                    removeFromContainment(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));
@@ -204,7 +222,7 @@ export class RequiredSingleContainmentValueManager<T extends INodeBase> extends
                     }
                     oldChild.detach();
                     if (newChild.parent && newChild.containment) {
-                        removeFromParent(newChild.parent, newChild);
+                        removeFromContainment(newChild);
                     }
                     this.setDirectly(newChild);
                     newChild.attachTo(this.container, this.feature);
@@ -251,16 +269,31 @@ export abstract class MultiContainmentValueManager<T extends INodeBase> extends
         this.children.splice(index, 0, newChild);
     }
 
-    @action insertAtIndex(newChild: T, index: number) {
-        this.insertAtIndexDirectly(newChild, index);
-        if (newChild.parent === undefined && newChild.containment === undefined) {
-            this.emitDelta(() => new ChildAddedDelta(this.container, this.containment, index, newChild));
+    @action insertAtIndex(newChild: T, newIndex: number) {
+        if (newChild.parent === undefined) {
+            this.insertAtIndexDirectly(newChild, newIndex);
+            newChild.attachTo(this.container, this.containment);
+            this.emitDelta(() => new ChildAddedDelta(this.container, this.containment, newIndex, newChild));
         } else {
-            const oldIndex = removeFromParent(newChild.parent, newChild);
-            this.emitDelta(() => new ChildMovedFromOtherContainmentDelta(newChild.parent!, newChild.containment!, oldIndex, this.container, this.containment, index, newChild));
-            newChild.detach();
+            if (newChild.parent === this.container) {
+                if (newChild.containment === this.containment) {
+                    const oldIndex = this.children.indexOf(newChild);
+                    this.moveDirectly(oldIndex, newIndex);
+                    this.emitDelta(() => new ChildMovedInSameContainmentDelta(this.container, this.containment, oldIndex, newIndex, newChild));
+                } else {
+                    const oldIndex = removeFromContainment(newChild);
+                    checkIndex(newIndex, this.children.length, true);
+                    this.insertAtIndexDirectly(newChild, newIndex);
+                    this.emitDelta(() => new ChildMovedFromOtherContainmentInSameParentDelta(this.container, newChild.containment!, oldIndex, newChild, this.containment, newIndex));
+                    newChild.attachTo(this.container, this.containment);
+                }
+            } else {
+                const oldIndex = removeFromContainment(newChild);
+                this.insertAtIndexDirectly(newChild, newIndex);
+                this.emitDelta(() => new ChildMovedFromOtherContainmentDelta(newChild.parent!, newChild.containment!, oldIndex, this.container, this.containment, newIndex, newChild));
+                newChild.attachTo(this.container, this.containment);
+            }
         }
-        newChild.attachTo(this.container, this.containment);
     }
 
     @action removeDirectly(childToRemove: T): number {
@@ -298,18 +331,20 @@ export abstract class MultiContainmentValueManager<T extends INodeBase> extends
 
     @action replaceAtIndex(movedChild: T, newIndex: number) {
         checkIndex(newIndex, this.children.length, false);
+        if (movedChild.parent === undefined) {
+            throw new Error(`a child-to-move (id=${movedChild.id}) must already be contained`);
+        }
         const replacedChild = this.children[newIndex];
         if (replacedChild === movedChild) {
             // do nothing: nothing's changed
         } else {
             this.children.splice(newIndex, 1, movedChild);
-            if (replacedChild.parent) {
+            if (replacedChild.parent !== undefined) {
                 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));
@@ -317,8 +352,9 @@ export abstract class MultiContainmentValueManager<T extends INodeBase> extends
                         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));
+                    this.emitDelta(() => new ChildMovedAndReplacedFromOtherContainmentDelta(this.container, this.containment, newIndex, movedChild, movedChild.parent!, movedChild.containment!, oldIndex, replacedChild));
                 }
+                replacedChild.detach();
             } else {
                 // not a move+replace, but a regular replace instead:
                 this.emitDelta(() => new ChildReplacedDelta(this.container, this.containment, newIndex, replacedChild, movedChild));
@@ -380,3 +416,27 @@ export class RequiredMultiContainmentValueManager<T extends INodeBase> extends M
 
 }
 
+/**
+ * Removes the given child node from its containment, and returns the containment index it had before removal.
+ */
+const removeFromContainment = (child: INodeBase): number => {
+    if (child.parent === undefined) {
+        throw new Error(`can't remove an orphan from its parent`)
+    }
+    if (child.containment === undefined) {
+        throw new Error(`can't remove an orphan from its containing feature`)
+    }
+    if (child.containment === null) {
+        throw new Error(`can't remove an annotation`)
+    }
+    const valueManager = child.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}`)
+    }
+}
+

package/src/value-managers/references.ts

@@ -106,7 +106,7 @@ export class OptionalSingleReferenceValueManager<T extends INodeBase> extends Si
             if (oldTarget === undefined) {
                 this.emitDelta(() => new ReferenceAddedDelta(this.container, this.reference, 0, newTarget));
             } else {
-                this.emitDelta(() => new ReferenceChangedDelta(this.container, this.reference, 0, oldTarget, newTarget));
+                this.emitDelta(() => new ReferenceChangedDelta(this.container, this.reference, 0, newTarget, oldTarget));
             }
         }
     }
@@ -142,7 +142,7 @@ export class RequiredSingleReferenceValueManager<T extends INodeBase> extends Si
             if (oldTarget === undefined) {
                 this.emitDelta(() => new ReferenceAddedDelta(this.container, this.reference, 0, newTarget));
             } else {
-                this.emitDelta(() => new ReferenceChangedDelta(this.container, this.reference, 0, oldTarget, newTarget));
+                this.emitDelta(() => new ReferenceChangedDelta(this.container, this.reference, 0, newTarget, oldTarget));
             }
         }
     }