@lionweb/class-core 0.6.13-beta.7 → 0.7.0-alpha.10

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

@@ -18,8 +18,8 @@
 // Warning: this file is generated!
 // Modifying it by hand is useless at best, and sabotage at worst.
 
-import {metaPointerFor} from "@lionweb/core";
-import {IDelta} from "../base.js";
+import { metaPointerFor } from "@lionweb/core";
+import { IDelta } from "../base.js";
 import {
     AnnotationAddedDelta,
     AnnotationDeletedDelta,
@@ -62,8 +62,8 @@ import {
     ReferenceMovedSerializedDelta,
     ReferenceReplacedSerializedDelta
 } from "./types.g.js";
-import {idFrom, serializePropertyValue} from "./serializer-helpers.js";
-import {serializeNodeBases} from "../../serializer.js";
+import { idFrom, serializePropertyValue } from "./serializer-helpers.js";
+import { serializeNodeBases } from "../../serializer.js";
 
 
 export const serializeDelta = (delta: IDelta) => {

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

@@ -18,7 +18,8 @@
 // Warning: this file is generated!
 // Modifying it by hand is useless at best, and sabotage at worst.
 
-import {Id, IdOrUnresolved, MetaPointer, SerializationChunk} from "@lionweb/core";
+import { IdOrUnresolved } from "@lionweb/core";
+import { LionWebId, LionWebJsonMetaPointer, LionWebJsonChunk } from "@lionweb/json";
 
 
 export type SerializedDelta =
@@ -50,95 +51,95 @@ export type NoOpSerializedDelta = {
 
 export type PropertyAddedSerializedDelta = {
     kind: "PropertyAdded"
-    container: Id
-    property: MetaPointer
+    container: LionWebId
+    property: LionWebJsonMetaPointer
     value: string
 }
 
 export type PropertyDeletedSerializedDelta = {
     kind: "PropertyDeleted"
-    container: Id
-    property: MetaPointer
+    container: LionWebId
+    property: LionWebJsonMetaPointer
     oldValue: string
 }
 
 export type PropertyChangedSerializedDelta = {
     kind: "PropertyChanged"
-    container: Id
-    property: MetaPointer
+    container: LionWebId
+    property: LionWebJsonMetaPointer
     oldValue: string
     newValue: string
 }
 
 export type ChildAddedSerializedDelta = {
     kind: "ChildAdded"
-    parent: Id
-    containment: MetaPointer
+    parent: LionWebId
+    containment: LionWebJsonMetaPointer
     index: number
-    newChild: Id
-    newNodes: SerializationChunk
+    newChild: LionWebId
+    newNodes: LionWebJsonChunk
 }
 
 export type ChildDeletedSerializedDelta = {
     kind: "ChildDeleted"
-    parent: Id
-    containment: MetaPointer
+    parent: LionWebId
+    containment: LionWebJsonMetaPointer
     index: number
-    deletedChild: Id
-    deletedNodes: SerializationChunk
+    deletedChild: LionWebId
+    deletedNodes: LionWebJsonChunk
 }
 
 export type ChildReplacedSerializedDelta = {
     kind: "ChildReplaced"
-    parent: Id
-    containment: MetaPointer
+    parent: LionWebId
+    containment: LionWebJsonMetaPointer
     index: number
-    replacedChild: Id
-    replacedNodes: SerializationChunk
-    newChild: Id
-    newNodes: SerializationChunk
+    replacedChild: LionWebId
+    replacedNodes: LionWebJsonChunk
+    newChild: LionWebId
+    newNodes: LionWebJsonChunk
 }
 
 export type ChildMovedSerializedDelta = {
     kind: "ChildMoved"
-    oldParent: Id
-    oldContainment: MetaPointer
+    oldParent: LionWebId
+    oldContainment: LionWebJsonMetaPointer
     oldIndex: number
-    newParent: Id
-    newContainment: MetaPointer
+    newParent: LionWebId
+    newContainment: LionWebJsonMetaPointer
     newIndex: number
-    child: Id
+    child: LionWebId
 }
 
 export type ChildMovedInSameContainmentSerializedDelta = {
     kind: "ChildMovedInSameContainment"
-    parent: Id
-    containment: MetaPointer
+    parent: LionWebId
+    containment: LionWebJsonMetaPointer
     oldIndex: number
     newIndex: number
-    child: Id
+    child: LionWebId
 }
 
 export type ReferenceAddedSerializedDelta = {
     kind: "ReferenceAdded"
-    container: Id
-    reference: MetaPointer
+    container: LionWebId
+    reference: LionWebJsonMetaPointer
     index: number
     newTarget: IdOrUnresolved
 }
 
 export type ReferenceDeletedSerializedDelta = {
     kind: "ReferenceDeleted"
-    container: Id
-    reference: MetaPointer
+    container: LionWebId
+    reference: LionWebJsonMetaPointer
     index: number
     deletedTarget: IdOrUnresolved
 }
 
 export type ReferenceReplacedSerializedDelta = {
     kind: "ReferenceReplaced"
-    container: Id
-    reference: MetaPointer
+    container: LionWebId
+    reference: LionWebJsonMetaPointer
     index: number
     replacedTarget: IdOrUnresolved
     newTarget: IdOrUnresolved
@@ -146,19 +147,19 @@ export type ReferenceReplacedSerializedDelta = {
 
 export type ReferenceMovedSerializedDelta = {
     kind: "ReferenceMoved"
-    oldContainer: Id
-    oldReference: MetaPointer
+    oldContainer: LionWebId
+    oldReference: LionWebJsonMetaPointer
     oldIndex: number
-    newContainer: Id
-    newReference: MetaPointer
+    newContainer: LionWebId
+    newReference: LionWebJsonMetaPointer
     newIndex: number
     target: IdOrUnresolved
 }
 
 export type ReferenceMovedInSameReferenceSerializedDelta = {
     kind: "ReferenceMovedInSameReference"
-    container: Id
-    reference: MetaPointer
+    container: LionWebId
+    reference: LionWebJsonMetaPointer
     oldIndex: number
     newIndex: number
     target: IdOrUnresolved
@@ -166,44 +167,44 @@ export type ReferenceMovedInSameReferenceSerializedDelta = {
 
 export type AnnotationAddedSerializedDelta = {
     kind: "AnnotationAdded"
-    parent: Id
+    parent: LionWebId
     index: number
-    newAnnotation: Id
-    newAnnotationNodes: SerializationChunk
+    newAnnotation: LionWebId
+    newAnnotationNodes: LionWebJsonChunk
 }
 
 export type AnnotationDeletedSerializedDelta = {
     kind: "AnnotationDeleted"
-    parent: Id
+    parent: LionWebId
     index: number
-    deletedAnnotation: Id
-    deletedAnnotationNodes: SerializationChunk
+    deletedAnnotation: LionWebId
+    deletedAnnotationNodes: LionWebJsonChunk
 }
 
 export type AnnotationReplacedSerializedDelta = {
     kind: "AnnotationReplaced"
-    parent: Id
+    parent: LionWebId
     index: number
-    replacedAnnotation: Id
-    replacedAnnotationNodes: SerializationChunk
-    newAnnotation: Id
-    newAnnotationNodes: SerializationChunk
+    replacedAnnotation: LionWebId
+    replacedAnnotationNodes: LionWebJsonChunk
+    newAnnotation: LionWebId
+    newAnnotationNodes: LionWebJsonChunk
 }
 
 export type AnnotationMovedFromOtherParentSerializedDelta = {
     kind: "AnnotationMovedFromOtherParent"
-    oldParent: Id
+    oldParent: LionWebId
     oldIndex: number
-    newParent: Id
+    newParent: LionWebId
     newIndex: number
-    movedAnnotation: Id
+    movedAnnotation: LionWebId
 }
 
 export type AnnotationMovedInSameParentSerializedDelta = {
     kind: "AnnotationMovedInSameParent"
-    parent: Id
+    parent: LionWebId
     oldIndex: number
     newIndex: number
-    movedAnnotation: Id
+    movedAnnotation: LionWebId
 }
 

package/src/deltas/types.g.ts

@@ -25,8 +25,8 @@ import {
     SingleRef
 } from "@lionweb/core";
 
-import {INodeBase} from "../base-types.js";
-import {IDelta} from "./base.js";
+import { INodeBase } from "../base-types.js";
+import { IDelta } from "./base.js";
 
 
 /**

package/src/deserializer.ts

@@ -16,36 +16,34 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import {
-    byIdMap,
+    BuiltinPropertyValueDeserializer,
     Classifier,
     Containment,
-    DefaultPrimitiveTypeDeserializer,
     defaultSimplisticHandler,
     Enumeration,
-    Id,
     Language,
     MemoisingSymbolTable,
     PrimitiveType,
-    PrimitiveTypeDeserializer,
     Property,
+    PropertyValueDeserializer,
     Reference,
-    SerializationChunk,
-    SerializedNode,
     SimplisticHandler,
     unresolved
-} from "@lionweb/core";
+} from "@lionweb/core"
+import { LionWebId, LionWebJsonChunk, LionWebJsonNode } from "@lionweb/json"
+import { byIdMap } from "@lionweb/ts-utils"
 
-import {DeltaHandler, IdMapping, ILanguageBase, INodeBase} from "./index.js";
-import {NodesToInstall} from "./linking.js";
+import { DeltaHandler, IdMapping, ILanguageBase, INodeBase } from "./index.js"
+import { NodesToInstall } from "./linking.js"
 
 
 /**
  * A type for deserializer functions that are parametrized in their return type.
  */
 export type Deserializer<T> = (
-    serializationChunk: SerializationChunk,
+    serializationChunk: LionWebJsonChunk,
     dependentNodes?: INodeBase[],
-    primitiveTypeDeserializer?: PrimitiveTypeDeserializer,
+    propertyValueDeserializer?: PropertyValueDeserializer,
     problemHandler?: SimplisticHandler
 ) => T;
 
@@ -74,7 +72,7 @@ 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 SerializationChunk} to deserialize, minus LionCore M3 and built-ins.
+ * @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.
  */
 export const nodeBaseDeserializerWithIdMapping = (languageBases: ILanguageBase[], handleDelta?: DeltaHandler): Deserializer<RootsWithIdMapping> => {
@@ -84,15 +82,15 @@ export const nodeBaseDeserializerWithIdMapping = (languageBases: ILanguageBase[]
     const factoryFor = factoryLookupFor(languageBases, handleDelta);
 
     return (
-        serializationChunk: SerializationChunk,
+        serializationChunk: LionWebJsonChunk,
         dependentNodes: INodeBase[] = [],
-        primitiveTypeDeserializer: PrimitiveTypeDeserializer = new DefaultPrimitiveTypeDeserializer(),
+        propertyValueDeserializer: PropertyValueDeserializer = new BuiltinPropertyValueDeserializer(),
         problemsHandler: SimplisticHandler = defaultSimplisticHandler
     ): RootsWithIdMapping => {
 
         const nodesToInstall: NodesToInstall[] = [];
 
-        const createNode = ({id, classifier: classifierMetaPointer, properties, containments, references, annotations}: SerializedNode) => {
+        const createNode = ({id, classifier: classifierMetaPointer, properties, containments, references, annotations}: LionWebJsonNode) => {
             const languageMessage = `language ${classifierMetaPointer.language} (${classifierMetaPointer.version})`;
             const classifier = symbolTable.entityMatching(classifierMetaPointer);
             if (classifier === undefined || !(classifier instanceof Classifier)) {
@@ -108,7 +106,7 @@ export const nodeBaseDeserializerWithIdMapping = (languageBases: ILanguageBase[]
                     problemsHandler.reportProblem(`can't deserialize value for feature with key ${propertyMetaPointer.key} in ${languageMessage}: feature not found on classifier ${classifierMetaPointer.key} in language (${classifierMetaPointer.language}, ${classifierMetaPointer.version}) - skipping`);
                 } else if (feature instanceof Property) {
                     if (feature.type instanceof PrimitiveType) {
-                        node.getPropertyValueManager(feature).setDirectly(value === null ? undefined : primitiveTypeDeserializer.deserializeValue(value, feature));
+                        node.getPropertyValueManager(feature).setDirectly(value === null ? undefined : propertyValueDeserializer.deserializeValue(value, feature));
                     } else if (feature.type instanceof Enumeration) {
                         if (value !== undefined) {
                             const literal = feature.type.literals.find((literal) => literal.key === value);
@@ -161,7 +159,7 @@ export const nodeBaseDeserializerWithIdMapping = (languageBases: ILanguageBase[]
 
         const dependentNodesById = byIdMap(dependentNodes)
 
-        const lookupNodeById = (id: Id) =>
+        const lookupNodeById = (id: LionWebId) =>
             nodesById[id] ?? dependentNodesById[id];
 
         nodesToInstall.forEach(([node, feature, ids]) => {
@@ -218,17 +216,17 @@ 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 SerializationChunk} to deserialize, minus LionCore M3 and built-ins.
+ * @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.
  */
 export const nodeBaseDeserializer = (languageBases: ILanguageBase[], handleDelta?: DeltaHandler): Deserializer<INodeBase[]> => {
     const deserializerWithIdMapping = nodeBaseDeserializerWithIdMapping(languageBases, handleDelta);
     return (
-        serializationChunk: SerializationChunk,
+        serializationChunk: LionWebJsonChunk,
         dependentNodes: INodeBase[] = [],
-        primitiveTypeDeserializer: PrimitiveTypeDeserializer = new DefaultPrimitiveTypeDeserializer(),
+        propertyValueDeserializer: PropertyValueDeserializer = new BuiltinPropertyValueDeserializer(),
         problemsHandler: SimplisticHandler = defaultSimplisticHandler
     ): INodeBase[] =>
-        deserializerWithIdMapping(serializationChunk, dependentNodes, primitiveTypeDeserializer, problemsHandler).roots
+        deserializerWithIdMapping(serializationChunk, dependentNodes, propertyValueDeserializer, problemsHandler).roots
 }
 

package/src/duplicator.ts

@@ -15,12 +15,14 @@
 // SPDX-FileCopyrightText: 2025 TRUMPF Laser SE and other contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import {asArray, Containment, Feature, Id, idOf, Link, Property, Reference, SingleRef, unresolved} from "@lionweb/core";
+import {  Containment, Feature, idOf, Link, Property, Reference, SingleRef, unresolved } from "@lionweb/core"
+import { LionWebId } from "@lionweb/json"
+import { asArray } from "@lionweb/ts-utils"
 
-import {INodeBase} from "./base-types.js";
-import {NodesToInstall} from "./linking.js";
-import {getFeatureValue} from "./serializer.js";
-import {allNodesFrom} from "./convenience.js";
+import { INodeBase } from "./base-types.js"
+import { allNodesFrom } from "./convenience.js"
+import { NodesToInstall } from "./linking.js"
+import { getFeatureValue } from "./serializer.js"
 
 
 /**
@@ -45,7 +47,7 @@ export const deepDuplicateWith = (duplicateNode: NodeDuplicator): Duplicator =>
 
         const nodesToInstall: NodesToInstall[] = [];
 
-        const visit = (node: INodeBase): [id: Id, duplicatedNode: INodeBase] => {
+        const visit = (node: INodeBase): [id: LionWebId, duplicatedNode: INodeBase] => {
             const [duplicatedNode, featuresToDuplicate] = duplicateNode(node);
             const duplicateFeatureValue = (feature: Feature) => {
                 const value = getFeatureValue(node, feature);

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

@@ -15,12 +15,12 @@
 // SPDX-FileCopyrightText: 2025 TRUMPF Laser SE and other contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import {Id, IdOrUnresolved, SingleRef, unresolved} from "@lionweb/core";
+import { IdOrUnresolved, SingleRef, unresolved } from "@lionweb/core"
+import { LionWebId } from "@lionweb/json"
 
-import {INodeBase} from "./index.js";
+import { INodeBase } from "./index.js"
 
-
-type NodesById = { [id: Id]: INodeBase};
+type NodesById = { [id: LionWebId]: INodeBase }
 
 
 /**
@@ -34,18 +34,17 @@ export class IdMapping {
     constructor(nodesById: NodesById) {
         this.nodesById = {...nodesById};
     }
+    // TODO  consider using an instance of Map<Id, INodeBase> instead
 
-    fromId(id: Id): INodeBase {
+    fromId(id: LionWebId): INodeBase {
         if (!(id in this.nodesById)) {
             throw new Error(`node with id=${id} not in ID mapping`);
         }
         return this.nodesById[id];
     }
 
-    tryFromId = (id: Id): (INodeBase | undefined) =>
-        id in this.nodesById
-            ? this.nodesById[id]
-            : undefined;
+    tryFromId = (id: LionWebId): (INodeBase | undefined) =>
+        this.nodesById[id];
 
     fromRefId = (idOrUnresolved: IdOrUnresolved): SingleRef<INodeBase> =>
         idOrUnresolved === null

package/src/index.ts

@@ -19,11 +19,12 @@ export * from "./base-types.js";
 export * from "./convenience.js";
 export * from "./deltas/index.js";
 export * from "./deserializer.js";
-export {deepDuplicateWith} from "./duplicator.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 * from "./LionCore_builtins.g.js";
 export {serializeNodeBases} from "./serializer.js";
+export { asTreeTextWith } from "./textualizer.js";
 export * from "./value-managers/index.js";
-export {asTreeTextWith} from "./textualizer.js";
 

package/src/linking.ts

@@ -15,8 +15,9 @@
 // SPDX-FileCopyrightText: 2025 TRUMPF Laser SE and other contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import {Id, Link} from "@lionweb/core";
-import {INodeBase} from "./index.js";
+import { Link } from "@lionweb/core"
+import { LionWebId } from "@lionweb/json"
+import { INodeBase } from "./index.js"
 
 
 /**
@@ -35,5 +36,5 @@ import {INodeBase} from "./index.js";
  * Note: **DON'T** export this types from the package,
  * as these are only used to align the deserializer and deep-cloner.
  */
-export type NodesToInstall = [ container: INodeBase, feature: Link | null, nodesIds: Id[], originalReferenceTargets?: INodeBase[] ];
+export type NodesToInstall = [ container: INodeBase, feature: Link | null, nodesIds: LionWebId[], originalReferenceTargets?: INodeBase[] ];
 

package/src/serializer.ts

@@ -20,14 +20,14 @@ import {
     builtinClassifiers,
     builtinFeatures,
     Containment,
-    ExtractionFacade,
     Feature,
+    nodeSerializer,
     Property,
-    Reference,
-    serializeNodes
-} from "@lionweb/core";
+    Reader,
+    Reference
+} from "@lionweb/core"
 
-import {INodeBase, LionCore_builtinsBase} from "./index.js";
+import { INodeBase, LionCore_builtinsBase } from "./index.js"
 
 
 /**
@@ -48,10 +48,10 @@ export const getFeatureValue = (node: INodeBase, feature: Feature) => {
 };
 
 /**
- * An {@link ExtractionFacade} that works on/for {@link INodeBase}s specifically.
+ * A {@link Reader} that works on/for {@link INodeBase}s specifically.
  * **Note** that this function is for internal use only!
  */
-export const nodeBaseReader: ExtractionFacade<INodeBase> = {
+export const nodeBaseReader: Reader<INodeBase> = {
     classifierOf: (node) => node.classifier,
     getFeatureValue,
     enumerationLiteralFrom: (encoding, enumeration) => {
@@ -79,8 +79,7 @@ export const nodeBaseReader: ExtractionFacade<INodeBase> = {
 };
 
 /**
- * @return a serialization of the given nodes (of type {@link INodeBase}) as a {@link SerializationChunk}.
+ * @return a serialization of the given nodes (of type {@link INodeBase}) as a {@link LionWebJsonChunk}.
  */
-export const serializeNodeBases = (nodes: INodeBase[]) =>
-    serializeNodes(nodes, nodeBaseReader, { serializeEmptyFeatures: false });
+export const serializeNodeBases = nodeSerializer(nodeBaseReader, { serializeEmptyFeatures: false });
 

package/src/textualizer.ts

@@ -15,12 +15,11 @@
 // SPDX-FileCopyrightText: 2025 TRUMPF Laser SE and other contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import {asString, indentWith, Template} from "littoral-templates"
-import {allFeaturesOf, Containment, Feature, Property, Reference, unresolved} from "@lionweb/core"
-
-import {INodeBase} from "./base-types.js";
-import {LionCore_builtinsBase} from "./lionCore_builtins.g.js";
+import { allFeaturesOf, Containment, Feature, Property, Reference, unresolved } from "@lionweb/core"
+import { asString, indentWith, Template } from "littoral-templates"
 
+import { INodeBase } from "./base-types.js"
+import { LionCore_builtinsBase } from "./LionCore_builtins.g.js"
 
 const indent = indentWith("    ")(1)
 

package/src/value-managers/annotations.ts

@@ -15,17 +15,17 @@
 // SPDX-FileCopyrightText: 2025 TRUMPF Laser SE and other contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import {action, observable} from "mobx";
+import { action, observable } from "mobx"
 
-import {INodeBase, removeFromParent} from "../base-types.js";
-import {checkIndex, ValueManager} from "./base.js";
+import { INodeBase, removeFromParent } from "../base-types.js"
+import { checkIndex, ValueManager } from "./base.js"
 import {
     AnnotationAddedDelta,
     AnnotationDeletedDelta,
     AnnotationMovedFromOtherParentDelta,
     AnnotationMovedInSameParentDelta,
     AnnotationReplacedDelta
-} from "../deltas/index.js";
+} from "../deltas/index.js"
 
 
 /**

package/src/value-managers/base.ts

@@ -15,9 +15,9 @@
 // SPDX-FileCopyrightText: 2025 TRUMPF Laser SE and other contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import {Feature, featureMetaType, Link} from "@lionweb/core";
-import {INodeBase} from "../base-types.js";
-import {IDelta} from "../deltas/index.js";
+import { Feature, featureMetaType, Link } from "@lionweb/core"
+import { INodeBase } from "../base-types.js"
+import { IDelta } from "../deltas/index.js"
 
 
 /**

package/src/value-managers/containments.ts

@@ -15,18 +15,12 @@
 // SPDX-FileCopyrightText: 2025 TRUMPF Laser SE and other contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import {Containment} from "@lionweb/core";
-import {action, observable} from "mobx";
-
-import {INodeBase, removeFromParent} from "../base-types.js";
-import {checkIndex, FeatureValueManager} from "./base.js";
-import {
-    ChildAddedDelta,
-    ChildDeletedDelta,
-    ChildMovedDelta,
-    ChildMovedInSameContainmentDelta,
-    ChildReplacedDelta
-} from "../deltas/index.js";
+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 { checkIndex, FeatureValueManager } from "./base.js"
 
 
 /**