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

package/package.json

@@ -1,36 +1,36 @@
 {
-  "name": "@lionweb/class-core",
-  "version": "0.7.0-beta.13",
-  "description": "Generic, language-aspecific base types for generated TypeScript APIs",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "typings": "dist/index.d.ts",
-  "type": "module",
-  "license": "Apache-2.0",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/LionWeb-io/lionweb-typescript.git"
-  },
-  "bugs": {
-    "url": "https://github.com/LionWeb-io/lionweb-typescript/issues"
-  },
-  "scripts": {
-    "clean": "npx rimraf dist node_modules -g lionweb-class-core-*.tgz",
-    "build": "npx rimraf dist && tsc",
-    "lint": "eslint src",
-    "prep:pre-release": "npm run clean && npm install && npm run build",
-    "prerelease-alpha": "npm run prep:pre-release",
-    "release-alpha": "npm publish --tag alpha",
-    "prerelease-beta": "npm run prep:pre-release",
-    "release-beta": "npm publish --tag beta",
-    "prerelease": "npm run prep:pre-release",
-    "release": "npm publish"
-  },
-  "dependencies": {
-    "@lionweb/core": "0.7.0-beta.13",
-    "@lionweb/json": "0.7.0-beta.13",
-    "@lionweb/ts-utils": "0.7.0-beta.13",
-    "littoral-templates": "0.5.0",
-    "mobx": "6.13.7"
-  }
+    "name": "@lionweb/class-core",
+    "version": "0.7.0-beta.15",
+    "description": "Generic, language-aspecific base types for generated TypeScript APIs",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "typings": "dist/index.d.ts",
+    "type": "module",
+    "license": "Apache-2.0",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/LionWeb-io/lionweb-typescript.git"
+    },
+    "bugs": {
+        "url": "https://github.com/LionWeb-io/lionweb-typescript/issues"
+    },
+    "scripts": {
+        "clean": "npx rimraf dist node_modules -g lionweb-class-core-*.tgz",
+        "build": "npx rimraf dist && tsc",
+        "lint": "eslint src",
+        "prep:pre-release": "npm run clean && npm install && npm run build",
+        "prerelease-alpha": "npm run prep:pre-release",
+        "release-alpha": "npm publish --tag alpha",
+        "prerelease-beta": "npm run prep:pre-release",
+        "release-beta": "npm publish --tag beta",
+        "prerelease": "npm run prep:pre-release",
+        "release": "npm publish"
+    },
+    "dependencies": {
+        "@lionweb/core": "0.7.0-beta.15",
+        "@lionweb/json": "0.7.0-beta.15",
+        "@lionweb/ts-utils": "0.7.0-beta.15",
+        "littoral-templates": "0.5.0",
+        "mobx": "6.13.7"
+    }
 }

package/src/base-types.ts

@@ -351,28 +351,3 @@ export interface ILanguageBase {
     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/deltas/appliers.ts

@@ -66,7 +66,8 @@ import { IDelta } from "./base.js"
  * 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?: IdMapping, updatablePartitions?: () => INodeBase[]) =>
     (delta: IDelta): void => {

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

@@ -15,6 +15,7 @@
 // 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"
 
@@ -37,7 +38,7 @@ export const collectingDeltaReceiver = (printSerializations = false): [DeltaRece
     const receiveDelta: DeltaReceiver = (delta) => {
         deltas.push(delta);
         if (printSerializations) {
-            console.log(JSON.stringify(serializeDelta(delta), null, 4));
+            console.log(asPrettyJsonString(serializeDelta(delta)));
         }
     };
     return [receiveDelta, deltas];

package/src/deltas/serialization/deserializer.g.ts

@@ -18,7 +18,7 @@
 // Warning: this file is generated!
 // Modifying it by hand is useless at best, and sabotage at worst.
 
-import { Containment, MemoisingSymbolTable, Property, Reference } from "@lionweb/core";
+import { Containment, Feature, MemoisingSymbolTable, Property, Reference } from "@lionweb/core";
 import { LionWebJsonMetaPointer } from "@lionweb/json";
 
 import { ILanguageBase, INodeBase } from "../../base-types.js";
@@ -62,14 +62,26 @@ import {
 import { IDelta } from "../base.js";
 
 
+type FeatureResolver<FT extends Feature> = (metaPointer: LionWebJsonMetaPointer, container: INodeBase) => FT;
+
 export const deltaDeserializer = (languageBases: ILanguageBase[], idMapping: IdMapping): DeltaDeserializer => {
     const symbolTable = new MemoisingSymbolTable(languageBases.map(({language}) => language));
-    const resolvedPropertyFrom = (metaPointer: LionWebJsonMetaPointer, container: INodeBase): Property =>
-        symbolTable.featureMatching(container.classifier.metaPointer(), metaPointer) as Property
-    const resolvedContainmentFrom = (metaPointer: LionWebJsonMetaPointer, container: INodeBase): Containment =>
-        symbolTable.featureMatching(container.classifier.metaPointer(), metaPointer) as Containment
-    const resolvedReferenceFrom = (metaPointer: LionWebJsonMetaPointer, container: INodeBase): Reference =>
-        symbolTable.featureMatching(container.classifier.metaPointer(), metaPointer) as Reference
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const featureResolverFor = <FT extends Feature>(featureClazz: new (...args: any[]) => FT): FeatureResolver<FT> =>
+        (metaPointer, container) => {
+            const featureLocationMessage = () => `feature with meta-pointer ${JSON.stringify(metaPointer)} on instance with ID="${container.id}" with meta-pointer ${JSON.stringify(container.classifier.metaPointer())}`;
+            const feature = symbolTable.featureMatching(container.classifier.metaPointer(), metaPointer);
+            if (feature === undefined) {
+                throw new Error(`couldn't resolve ${featureLocationMessage()}`);    // fail early <== unrecoverable
+            }
+            if (!(feature instanceof featureClazz)) {
+                throw new Error(`${featureLocationMessage()} is not a ${featureClazz.name} but a ${feature.constructor.name}`);    // fail early <== unrecoverable
+            }
+            return feature as FT;
+        }
+    const resolvedPropertyFrom = featureResolverFor(Property);
+    const resolvedContainmentFrom = featureResolverFor(Containment);
+    const resolvedReferenceFrom = featureResolverFor(Reference);
     const deserializedDelta = (delta: SerializedDelta): IDelta => {
         switch (delta.kind) {
             case "PartitionAdded": {

package/src/deserializer.ts

@@ -21,7 +21,6 @@ import {
     Containment,
     defaultSimplisticHandler,
     Enumeration,
-    Language,
     MemoisingSymbolTable,
     PrimitiveType,
     Property,
@@ -34,6 +33,7 @@ import { LionWebId, LionWebJsonChunk, LionWebJsonNode } from "@lionweb/json"
 import { byIdMap, keepDefineds } from "@lionweb/ts-utils"
 
 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[], receiveDelta?: DeltaReceiver) => {
-    const lookup = languageBaseLookupFor(languageBases);
-    return (language: Language) => lookup(language).factory(receiveDelta);
-}
-
-
 /**
  * A quasi-tuple of the roots (of type {@link INodeBase}) of a model,
  * and its {@link IdMapping} instance.
@@ -78,8 +63,7 @@ export type RootsWithIdMapping = { roots: INodeBase[], idMapping: IdMapping };
 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, receiveDelta);
+    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);

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];
         }