@lionweb/class-core 0.6.13-beta.0

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

@@ -0,0 +1,193 @@
+// 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
+
+// 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 {ILanguageBase} from "../../base-types.js";
+import {IdMapping} from "../../id-mapping.js";
+import {SerializedDelta} from "./types.g.js";
+import {DeltaDeserializer} from "./base.js";
+import {
+    AnnotationAddedDelta,
+    AnnotationDeletedDelta,
+    AnnotationMovedFromOtherParentDelta,
+    AnnotationMovedInSameParentDelta,
+    AnnotationReplacedDelta,
+    ChildAddedDelta,
+    ChildDeletedDelta,
+    ChildMovedDelta,
+    ChildMovedInSameContainmentDelta,
+    ChildReplacedDelta,
+    NoOpDelta,
+    PropertyAddedDelta,
+    PropertyChangedDelta,
+    PropertyDeletedDelta,
+    ReferenceAddedDelta,
+    ReferenceDeletedDelta,
+    ReferenceMovedDelta,
+    ReferenceMovedInSameReferenceDelta,
+    ReferenceReplacedDelta
+} from "../types.g.js";
+
+
+export const deltaDeserializer = (languageBases: ILanguageBase[], idMapping: IdMapping): DeltaDeserializer => {
+    const symbolTable = new MemoisingSymbolTable(languageBases.map(({language}) => language));
+    return (delta: SerializedDelta) => {
+        switch (delta.kind) {
+            case "NoOp": {
+                return new NoOpDelta();
+            }
+            case "PropertyAdded": {
+                const container = idMapping.fromId(delta.container);
+                const property = symbolTable.featureMatching(container.classifier.metaPointer(), delta.property) as Property;
+                const value = delta.value;
+                return new PropertyAddedDelta(container, property, value);
+            }
+            case "PropertyDeleted": {
+                const container = idMapping.fromId(delta.container);
+                const property = symbolTable.featureMatching(container.classifier.metaPointer(), delta.property) as Property;
+                const oldValue = delta.oldValue;
+                return new PropertyDeletedDelta(container, property, oldValue);
+            }
+            case "PropertyChanged": {
+                const container = idMapping.fromId(delta.container);
+                const property = symbolTable.featureMatching(container.classifier.metaPointer(), delta.property) as Property;
+                const oldValue = delta.oldValue;
+                const newValue = delta.newValue;
+                return new PropertyChangedDelta(container, property, oldValue, newValue);
+            }
+            case "ChildAdded": {
+                const parent = idMapping.fromId(delta.parent);
+                const containment = symbolTable.featureMatching(parent.classifier.metaPointer(), delta.containment) as Containment;
+                const index = delta.index;
+                const newChild = idMapping.fromId(delta.newChild);
+                return new ChildAddedDelta(parent, containment, index, newChild);
+            }
+            case "ChildDeleted": {
+                const parent = idMapping.fromId(delta.parent);
+                const containment = symbolTable.featureMatching(parent.classifier.metaPointer(), delta.containment) as Containment;
+                const index = delta.index;
+                const deletedChild = idMapping.fromId(delta.deletedChild);
+                return new ChildDeletedDelta(parent, containment, index, deletedChild);
+            }
+            case "ChildReplaced": {
+                const parent = idMapping.fromId(delta.parent);
+                const containment = symbolTable.featureMatching(parent.classifier.metaPointer(), delta.containment) as Containment;
+                const index = delta.index;
+                const replacedChild = idMapping.fromId(delta.replacedChild);
+                const newChild = idMapping.fromId(delta.newChild);
+                return new ChildReplacedDelta(parent, containment, index, replacedChild, newChild);
+            }
+            case "ChildMoved": {
+                const oldParent = idMapping.fromId(delta.oldParent);
+                const oldContainment = symbolTable.featureMatching(oldParent.classifier.metaPointer(), delta.oldContainment) as Containment;
+                const oldIndex = delta.oldIndex;
+                const newParent = idMapping.fromId(delta.newParent);
+                const newContainment = symbolTable.featureMatching(newParent.classifier.metaPointer(), delta.newContainment) as Containment;
+                const newIndex = delta.newIndex;
+                const child = idMapping.fromId(delta.child);
+                return new ChildMovedDelta(oldParent, oldContainment, oldIndex, newParent, newContainment, newIndex, child);
+            }
+            case "ChildMovedInSameContainment": {
+                const parent = idMapping.fromId(delta.parent);
+                const containment = symbolTable.featureMatching(parent.classifier.metaPointer(), delta.containment) as Containment;
+                const oldIndex = delta.oldIndex;
+                const newIndex = delta.newIndex;
+                const child = idMapping.fromId(delta.child);
+                return new ChildMovedInSameContainmentDelta(parent, containment, oldIndex, newIndex, child);
+            }
+            case "ReferenceAdded": {
+                const container = idMapping.fromId(delta.container);
+                const reference = symbolTable.featureMatching(container.classifier.metaPointer(), delta.reference) as Reference;
+                const index = delta.index;
+                const newTarget = idMapping.fromRefId(delta.newTarget);
+                return new ReferenceAddedDelta(container, reference, index, newTarget);
+            }
+            case "ReferenceDeleted": {
+                const container = idMapping.fromId(delta.container);
+                const reference = symbolTable.featureMatching(container.classifier.metaPointer(), delta.reference) as Reference;
+                const index = delta.index;
+                const deletedTarget = idMapping.fromRefId(delta.deletedTarget);
+                return new ReferenceDeletedDelta(container, reference, index, deletedTarget);
+            }
+            case "ReferenceReplaced": {
+                const container = idMapping.fromId(delta.container);
+                const reference = symbolTable.featureMatching(container.classifier.metaPointer(), delta.reference) as Reference;
+                const index = delta.index;
+                const replacedTarget = idMapping.fromRefId(delta.replacedTarget);
+                const newTarget = idMapping.fromRefId(delta.newTarget);
+                return new ReferenceReplacedDelta(container, reference, index, replacedTarget, newTarget);
+            }
+            case "ReferenceMoved": {
+                const oldContainer = idMapping.fromId(delta.oldContainer);
+                const oldReference = symbolTable.featureMatching(oldContainer.classifier.metaPointer(), delta.oldReference) as Reference;
+                const oldIndex = delta.oldIndex;
+                const newContainer = idMapping.fromId(delta.newContainer);
+                const newReference = symbolTable.featureMatching(newContainer.classifier.metaPointer(), delta.newReference) as Reference;
+                const newIndex = delta.newIndex;
+                const target = idMapping.fromRefId(delta.target);
+                return new ReferenceMovedDelta(oldContainer, oldReference, oldIndex, newContainer, newReference, newIndex, target);
+            }
+            case "ReferenceMovedInSameReference": {
+                const container = idMapping.fromId(delta.container);
+                const reference = symbolTable.featureMatching(container.classifier.metaPointer(), delta.reference) as Reference;
+                const oldIndex = delta.oldIndex;
+                const newIndex = delta.newIndex;
+                const target = idMapping.fromRefId(delta.target);
+                return new ReferenceMovedInSameReferenceDelta(container, reference, oldIndex, newIndex, target);
+            }
+            case "AnnotationAdded": {
+                const parent = idMapping.fromId(delta.parent);
+                const index = delta.index;
+                const newAnnotation = idMapping.fromId(delta.newAnnotation);
+                return new AnnotationAddedDelta(parent, index, newAnnotation);
+            }
+            case "AnnotationDeleted": {
+                const parent = idMapping.fromId(delta.parent);
+                const index = delta.index;
+                const deletedAnnotation = idMapping.fromId(delta.deletedAnnotation);
+                return new AnnotationDeletedDelta(parent, index, deletedAnnotation);
+            }
+            case "AnnotationReplaced": {
+                const parent = idMapping.fromId(delta.parent);
+                const index = delta.index;
+                const replacedAnnotation = idMapping.fromId(delta.replacedAnnotation);
+                const newAnnotation = idMapping.fromId(delta.newAnnotation);
+                return new AnnotationReplacedDelta(parent, index, replacedAnnotation, newAnnotation);
+            }
+            case "AnnotationMovedFromOtherParent": {
+                const oldParent = idMapping.fromId(delta.oldParent);
+                const oldIndex = delta.oldIndex;
+                const newParent = idMapping.fromId(delta.newParent);
+                const newIndex = delta.newIndex;
+                const movedAnnotation = idMapping.fromId(delta.movedAnnotation);
+                return new AnnotationMovedFromOtherParentDelta(oldParent, oldIndex, newParent, newIndex, movedAnnotation);
+            }
+            case "AnnotationMovedInSameParent": {
+                const parent = idMapping.fromId(delta.parent);
+                const oldIndex = delta.oldIndex;
+                const newIndex = delta.newIndex;
+                const movedAnnotation = idMapping.fromId(delta.movedAnnotation);
+                return new AnnotationMovedInSameParentDelta(parent, oldIndex, newIndex, movedAnnotation);
+            }
+        }
+    }
+}
+

package/src/deltas/serialization/index.ts

@@ -0,0 +1,22 @@
+// 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
+
+export type {DeltaDeserializer} from "./base.js";
+export * from "./deserializer.g.js";
+export * from "./serializer.g.js";
+// skip serializer-helpers.js: none of its members need to be visible outside this package
+export * from "./types.g.js";

package/src/deltas/serialization/serializer-helpers.ts

@@ -0,0 +1,36 @@
+// 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 {DefaultPrimitiveTypeSerializer, IdOrUnresolved, Property, SingleRef, unresolved} from "@lionweb/core";
+import {INodeBase} from "../../base-types.js";
+
+
+const defaultPrimitiveValueSerializer = new DefaultPrimitiveTypeSerializer();   // (suffices because serializeNodeBases also uses this class)
+/**
+ * A function that serializes the given value of the given {@link Property property},
+ * using (an instance of) the same {@link DefaultPrimitiveTypeSerializer} class as the {@link serializeNodeBases} function.
+ */
+export const serializePropertyValue = <T>(value: T, property: Property): string =>
+    defaultPrimitiveValueSerializer.serializeValue(value, property)!
+
+
+/**
+ * @return the ID of a given reference to a {@link INodeBase}, or {@link unresolved} if that reference was previously unresolved.
+ */
+export const idFrom = (ref: SingleRef<INodeBase>): IdOrUnresolved =>
+    ref === unresolved ? null : ref.id
+

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

@@ -0,0 +1,272 @@
+// 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
+
+// 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 {
+    AnnotationAddedDelta,
+    AnnotationDeletedDelta,
+    AnnotationMovedFromOtherParentDelta,
+    AnnotationMovedInSameParentDelta,
+    AnnotationReplacedDelta,
+    ChildAddedDelta,
+    ChildDeletedDelta,
+    ChildMovedDelta,
+    ChildMovedInSameContainmentDelta,
+    ChildReplacedDelta,
+    NoOpDelta,
+    PropertyAddedDelta,
+    PropertyChangedDelta,
+    PropertyDeletedDelta,
+    ReferenceAddedDelta,
+    ReferenceDeletedDelta,
+    ReferenceMovedDelta,
+    ReferenceMovedInSameReferenceDelta,
+    ReferenceReplacedDelta
+} from "../types.g.js";
+import {
+    AnnotationAddedSerializedDelta,
+    AnnotationDeletedSerializedDelta,
+    AnnotationMovedFromOtherParentSerializedDelta,
+    AnnotationMovedInSameParentSerializedDelta,
+    AnnotationReplacedSerializedDelta,
+    ChildAddedSerializedDelta,
+    ChildDeletedSerializedDelta,
+    ChildMovedInSameContainmentSerializedDelta,
+    ChildMovedSerializedDelta,
+    ChildReplacedSerializedDelta,
+    NoOpSerializedDelta,
+    PropertyAddedSerializedDelta,
+    PropertyChangedSerializedDelta,
+    PropertyDeletedSerializedDelta,
+    ReferenceAddedSerializedDelta,
+    ReferenceDeletedSerializedDelta,
+    ReferenceMovedInSameReferenceSerializedDelta,
+    ReferenceMovedSerializedDelta,
+    ReferenceReplacedSerializedDelta
+} from "./types.g.js";
+import {idFrom, serializePropertyValue} from "./serializer-helpers.js";
+import {serializeNodeBases} from "../../serializer.js";
+
+
+export const serializeDelta = (delta: IDelta) => {
+    if (delta instanceof NoOpDelta) {
+        return {
+            kind: "NoOp"
+        } as NoOpSerializedDelta;
+    }
+
+    if (delta instanceof PropertyAddedDelta) {
+        return {
+            kind: "PropertyAdded",
+            container: delta.container.id,
+            property: metaPointerFor(delta.property),
+            value: serializePropertyValue(delta.value, delta.property)
+        } as PropertyAddedSerializedDelta;
+    }
+
+    if (delta instanceof PropertyDeletedDelta) {
+        return {
+            kind: "PropertyDeleted",
+            container: delta.container.id,
+            property: metaPointerFor(delta.property),
+            oldValue: serializePropertyValue(delta.oldValue, delta.property)
+        } as PropertyDeletedSerializedDelta;
+    }
+
+    if (delta instanceof PropertyChangedDelta) {
+        return {
+            kind: "PropertyChanged",
+            container: delta.container.id,
+            property: metaPointerFor(delta.property),
+            oldValue: serializePropertyValue(delta.oldValue, delta.property),
+            newValue: serializePropertyValue(delta.newValue, delta.property)
+        } as PropertyChangedSerializedDelta;
+    }
+
+    if (delta instanceof ChildAddedDelta) {
+        return {
+            kind: "ChildAdded",
+            parent: delta.parent.id,
+            containment: metaPointerFor(delta.containment),
+            index: delta.index,
+            newChild: delta.newChild.id,
+            newNodes: serializeNodeBases([delta.newChild])
+        } as ChildAddedSerializedDelta;
+    }
+
+    if (delta instanceof ChildDeletedDelta) {
+        return {
+            kind: "ChildDeleted",
+            parent: delta.parent.id,
+            containment: metaPointerFor(delta.containment),
+            index: delta.index,
+            deletedChild: delta.deletedChild.id,
+            deletedNodes: serializeNodeBases([delta.deletedChild])
+        } as ChildDeletedSerializedDelta;
+    }
+
+    if (delta instanceof ChildReplacedDelta) {
+        return {
+            kind: "ChildReplaced",
+            parent: delta.parent.id,
+            containment: metaPointerFor(delta.containment),
+            index: delta.index,
+            replacedChild: delta.replacedChild.id,
+            replacedNodes: serializeNodeBases([delta.replacedChild]),
+            newChild: delta.newChild.id,
+            newNodes: serializeNodeBases([delta.newChild])
+        } as ChildReplacedSerializedDelta;
+    }
+
+    if (delta instanceof ChildMovedDelta) {
+        return {
+            kind: "ChildMoved",
+            oldParent: delta.oldParent.id,
+            oldContainment: metaPointerFor(delta.oldContainment),
+            oldIndex: delta.oldIndex,
+            newParent: delta.newParent.id,
+            newContainment: metaPointerFor(delta.newContainment),
+            newIndex: delta.newIndex,
+            child: delta.child.id
+        } as ChildMovedSerializedDelta;
+    }
+
+    if (delta instanceof ChildMovedInSameContainmentDelta) {
+        return {
+            kind: "ChildMovedInSameContainment",
+            parent: delta.parent.id,
+            containment: metaPointerFor(delta.containment),
+            oldIndex: delta.oldIndex,
+            newIndex: delta.newIndex,
+            child: delta.child.id
+        } as ChildMovedInSameContainmentSerializedDelta;
+    }
+
+    if (delta instanceof ReferenceAddedDelta) {
+        return {
+            kind: "ReferenceAdded",
+            container: delta.container.id,
+            reference: metaPointerFor(delta.reference),
+            index: delta.index,
+            newTarget: idFrom(delta.newTarget)
+        } as ReferenceAddedSerializedDelta;
+    }
+
+    if (delta instanceof ReferenceDeletedDelta) {
+        return {
+            kind: "ReferenceDeleted",
+            container: delta.container.id,
+            reference: metaPointerFor(delta.reference),
+            index: delta.index,
+            deletedTarget: idFrom(delta.deletedTarget)
+        } as ReferenceDeletedSerializedDelta;
+    }
+
+    if (delta instanceof ReferenceReplacedDelta) {
+        return {
+            kind: "ReferenceReplaced",
+            container: delta.container.id,
+            reference: metaPointerFor(delta.reference),
+            index: delta.index,
+            replacedTarget: idFrom(delta.replacedTarget),
+            newTarget: idFrom(delta.newTarget)
+        } as ReferenceReplacedSerializedDelta;
+    }
+
+    if (delta instanceof ReferenceMovedDelta) {
+        return {
+            kind: "ReferenceMoved",
+            oldContainer: delta.oldContainer.id,
+            oldReference: metaPointerFor(delta.oldReference),
+            oldIndex: delta.oldIndex,
+            newContainer: delta.newContainer.id,
+            newReference: metaPointerFor(delta.newReference),
+            newIndex: delta.newIndex,
+            target: idFrom(delta.target)
+        } as ReferenceMovedSerializedDelta;
+    }
+
+    if (delta instanceof ReferenceMovedInSameReferenceDelta) {
+        return {
+            kind: "ReferenceMovedInSameReference",
+            container: delta.container.id,
+            reference: metaPointerFor(delta.reference),
+            oldIndex: delta.oldIndex,
+            newIndex: delta.newIndex,
+            target: idFrom(delta.target)
+        } as ReferenceMovedInSameReferenceSerializedDelta;
+    }
+
+    if (delta instanceof AnnotationAddedDelta) {
+        return {
+            kind: "AnnotationAdded",
+            parent: delta.parent.id,
+            index: delta.index,
+            newAnnotation: delta.newAnnotation.id,
+            newAnnotationNodes: serializeNodeBases([delta.newAnnotation])
+        } as AnnotationAddedSerializedDelta;
+    }
+
+    if (delta instanceof AnnotationDeletedDelta) {
+        return {
+            kind: "AnnotationDeleted",
+            parent: delta.parent.id,
+            index: delta.index,
+            deletedAnnotation: delta.deletedAnnotation.id,
+            deletedAnnotationNodes: serializeNodeBases([delta.deletedAnnotation])
+        } as AnnotationDeletedSerializedDelta;
+    }
+
+    if (delta instanceof AnnotationReplacedDelta) {
+        return {
+            kind: "AnnotationReplaced",
+            parent: delta.parent.id,
+            index: delta.index,
+            replacedAnnotation: delta.replacedAnnotation.id,
+            replacedAnnotationNodes: serializeNodeBases([delta.replacedAnnotation]),
+            newAnnotation: delta.newAnnotation.id,
+            newAnnotationNodes: serializeNodeBases([delta.newAnnotation])
+        } as AnnotationReplacedSerializedDelta;
+    }
+
+    if (delta instanceof AnnotationMovedFromOtherParentDelta) {
+        return {
+            kind: "AnnotationMovedFromOtherParent",
+            oldParent: delta.oldParent.id,
+            oldIndex: delta.oldIndex,
+            newParent: delta.newParent.id,
+            newIndex: delta.newIndex,
+            movedAnnotation: delta.movedAnnotation.id
+        } as AnnotationMovedFromOtherParentSerializedDelta;
+    }
+
+    if (delta instanceof AnnotationMovedInSameParentDelta) {
+        return {
+            kind: "AnnotationMovedInSameParent",
+            parent: delta.parent.id,
+            oldIndex: delta.oldIndex,
+            newIndex: delta.newIndex,
+            movedAnnotation: delta.movedAnnotation.id
+        } as AnnotationMovedInSameParentSerializedDelta;
+    }
+
+    throw new Error(`serialization of delta of class ${delta.constructor.name} not implemented`);
+}