@lionweb/delta-protocol-common 0.7.0-beta.22 → 0.7.0-beta.24

package/src/translators/delta-to-event.ts

@@ -15,5 +15,434 @@
 // SPDX-FileCopyrightText: 2025 TRUMPF Laser SE and other contributors
 // SPDX-License-Identifier: Apache-2.0
 
-// TODO  implement: translate a delta directly into an event
+import {
+    allNodesFrom,
+    AnnotationAddedDelta,
+    AnnotationDeletedDelta,
+    AnnotationMovedAndReplacedFromOtherParentDelta,
+    AnnotationMovedAndReplacedInSameParentDelta,
+    AnnotationMovedFromOtherParentDelta,
+    AnnotationMovedInSameParentDelta,
+    AnnotationReplacedDelta,
+    ChildAddedDelta,
+    ChildDeletedDelta,
+    ChildMovedAndReplacedFromOtherContainmentDelta,
+    ChildMovedAndReplacedFromOtherContainmentInSameParentDelta,
+    ChildMovedAndReplacedInSameContainmentDelta,
+    ChildMovedFromOtherContainmentDelta,
+    ChildMovedFromOtherContainmentInSameParentDelta,
+    ChildMovedInSameContainmentDelta,
+    ChildReplacedDelta,
+    CompositeDelta,
+    EntryMovedAndReplacedFromOtherReferenceDelta,
+    EntryMovedAndReplacedFromOtherReferenceInSameParentDelta,
+    EntryMovedAndReplacedInSameReferenceDelta,
+    EntryMovedFromOtherReferenceDelta,
+    EntryMovedFromOtherReferenceInSameParentDelta,
+    EntryMovedInSameReferenceDelta,
+    IDelta,
+    INodeBase,
+    NoOpDelta,
+    PartitionAddedDelta,
+    PartitionDeletedDelta,
+    PropertyAddedDelta,
+    PropertyChangedDelta,
+    PropertyDeletedDelta,
+    ReferenceAddedDelta,
+    ReferenceChangedDelta,
+    ReferenceDeletedDelta,
+    serializeNodeBases
+} from "@lionweb/class-core"
+import {
+    builtinPropertyValueSerializer,
+    idOf,
+    metaPointerFor,
+    PropertyValueSerializer,
+    serializedRef
+} from "@lionweb/core"
+import {
+    AnnotationAddedEvent,
+    AnnotationDeletedEvent,
+    AnnotationMovedAndReplacedFromOtherParentEvent,
+    AnnotationMovedAndReplacedInSameParentEvent,
+    AnnotationMovedFromOtherParentEvent,
+    AnnotationMovedInSameParentEvent,
+    AnnotationReplacedEvent,
+    ChildAddedEvent,
+    ChildDeletedEvent,
+    ChildMovedAndReplacedFromOtherContainmentEvent,
+    ChildMovedAndReplacedFromOtherContainmentInSameParentEvent,
+    ChildMovedAndReplacedInSameContainmentEvent,
+    ChildMovedFromOtherContainmentEvent,
+    ChildMovedFromOtherContainmentInSameParentEvent,
+    ChildMovedInSameContainmentEvent,
+    ChildReplacedEvent,
+    CompositeEvent,
+    EntryMovedAndReplacedFromOtherReferenceEvent,
+    EntryMovedAndReplacedFromOtherReferenceInSameParentEvent,
+    EntryMovedAndReplacedInSameReferenceEvent,
+    EntryMovedFromOtherReferenceEvent,
+    EntryMovedFromOtherReferenceInSameParentEvent,
+    EntryMovedInSameReferenceEvent,
+    Event,
+    NoOpEvent,
+    PartitionAddedEvent,
+    PartitionDeletedEvent,
+    PropertyAddedEvent,
+    PropertyChangedEvent,
+    PropertyDeletedEvent,
+    ReferenceAddedEvent,
+    ReferenceChangedEvent,
+    ReferenceDeletedEvent
+} from "../payload/index.js"
+import { nodeBaseReader } from "@lionweb/class-core/dist/serializer.js"
+
+
+const allIdsOfDescendantsFrom = (node: INodeBase) =>
+    allNodesFrom(node).slice(1).map(idOf)
+
+
+/**
+ * Type def. for functions that translate {@link IDelta deltas} into {@link Event events},
+ * taking care of proper sequence numbers and (implicitly) serialization of property values.
+ *
+ * More precisely, such a function returns a pair consisting of an {@link Event event}
+ * and the last-used sequence number, where the event is the translation of the given {@link IDelta delta}.
+ * Sequence numbers start from the given `lastUsedSequenceNumber`.
+ * More than one sequence number might be allocated because of composite deltas.
+ */
+export type DeltaToEventTranslator = (
+    delta: IDelta,
+    lastUsedSequenceNumber: number
+) => [event: Event, lastUsedSequenceNumber: number];
+
+
+/**
+ * @return a {@link DeltaToEventTranslator} instance using the given {@link PropertyValueSerializer}
+ * (with that defaulting to the {@link builtinPropertyValueSerializer}).
+ */
+export const deltaToEventTranslator = (
+    propertyValueSerializer: PropertyValueSerializer = builtinPropertyValueSerializer
+): DeltaToEventTranslator =>
+    (delta, lastUsedSequenceNumber) => {
+
+        let sequenceNumber = lastUsedSequenceNumber
+        const completed = <ET extends Event>(
+            technicalName: ET["messageKind"],
+            partialEvent: Omit<ET, "messageKind" | "sequenceNumber" | "originCommands" | "protocolMessages">
+        ) => ({
+            messageKind: technicalName,
+            ...partialEvent,
+            sequenceNumber: ++sequenceNumber,
+            originCommands: [],
+            protocolMessages: []
+        })
+
+        // in order of the specification (§ 6.6):
+
+        const translated = (delta: IDelta): Event => {
+            if (delta instanceof PartitionAddedDelta) {
+                return completed<PartitionAddedEvent>("PartitionAdded", { // § 6.6.1.1
+                    newPartition: serializeNodeBases([delta.newPartition])
+                })
+            }
+            if (delta instanceof PartitionDeletedDelta) {
+                return completed<PartitionDeletedEvent>("PartitionDeleted", { // § 6.6.1.2
+                    deletedPartition: delta.deletedPartition.id
+                })
+            }
+            if (delta instanceof PropertyAddedDelta) {
+                return completed<PropertyAddedEvent>("PropertyAdded", { // § 6.6.3.1
+                    node: delta.node.id,
+                    property: metaPointerFor(delta.property),
+                    newValue: propertyValueSerializer.serializeValue(delta.value, delta.property)!
+                })
+            }
+            if (delta instanceof PropertyDeletedDelta) {
+                return completed<PropertyDeletedEvent>("PropertyDeleted", { // § 6.6.3.2
+                    node: delta.node.id,
+                    property: metaPointerFor(delta.property),
+                    oldValue: propertyValueSerializer.serializeValue(delta.oldValue, delta.property)!
+                })
+            }
+            if (delta instanceof PropertyChangedDelta) {
+                return completed<PropertyChangedEvent>("PropertyChanged", { // § 6.6.3.3
+                    node: delta.node.id,
+                    property: metaPointerFor(delta.property),
+                    newValue: propertyValueSerializer.serializeValue(delta.newValue, delta.property)!,
+                    oldValue: propertyValueSerializer.serializeValue(delta.oldValue, delta.property)!
+                })
+            }
+            if (delta instanceof ChildAddedDelta) {
+                return completed<ChildAddedEvent>("ChildAdded", { // § 6.6.4.1
+                    parent: delta.parent.id,
+                    newChild: serializeNodeBases([delta.newChild]),
+                    containment: metaPointerFor(delta.containment),
+                    index: delta.index
+                })
+            }
+            if (delta instanceof ChildDeletedDelta) {
+                return completed<ChildDeletedEvent>("ChildDeleted", { // § 6.6.4.2
+                    parent: delta.parent.id,
+                    containment: metaPointerFor(delta.containment),
+                    index: delta.index,
+                    deletedChild: delta.deletedChild.id,
+                    deletedDescendants: allIdsOfDescendantsFrom(delta.deletedChild)
+                })
+            }
+            if (delta instanceof ChildReplacedDelta) {
+                return completed<ChildReplacedEvent>("ChildReplaced", { // § 6.6.4.3
+                    newChild: serializeNodeBases([delta.newChild]),
+                    parent: delta.parent.id,
+                    containment: metaPointerFor(delta.containment),
+                    index: delta.index,
+                    replacedChild: delta.replacedChild.id,
+                    replacedDescendants: allIdsOfDescendantsFrom(delta.replacedChild)
+                })
+            }
+            if (delta instanceof ChildMovedFromOtherContainmentDelta) {
+                return completed<ChildMovedFromOtherContainmentEvent>("ChildMovedFromOtherContainment", { // § 6.6.4.4
+                    newParent: delta.newParent.id,
+                    newContainment: metaPointerFor(delta.newContainment),
+                    newIndex: delta.newIndex,
+                    movedChild: delta.movedChild.id,
+                    oldParent: delta.oldParent.id,
+                    oldContainment: metaPointerFor(delta.oldContainment),
+                    oldIndex: delta.oldIndex
+                })
+            }
+            if (delta instanceof ChildMovedFromOtherContainmentInSameParentDelta) {
+                return completed<ChildMovedFromOtherContainmentInSameParentEvent>("ChildMovedFromOtherContainmentInSameParent", { // § 6.6.4.5
+                    newContainment: metaPointerFor(delta.newContainment),
+                    newIndex: delta.newIndex,
+                    movedChild: delta.movedChild.id,
+                    parent: delta.parent.id,
+                    oldContainment: metaPointerFor(delta.oldContainment),
+                    oldIndex: delta.oldIndex
+                })
+            }
+            if (delta instanceof ChildMovedInSameContainmentDelta) {
+                return completed<ChildMovedInSameContainmentEvent>("ChildMovedInSameContainment", { // § 6.6.4.6
+                    parent: delta.parent.id,
+                    containment: metaPointerFor(delta.containment),
+                    oldIndex: delta.oldIndex,
+                    newIndex: delta.newIndex,
+                    movedChild: delta.movedChild.id
+                })
+            }
+            if (delta instanceof ChildMovedAndReplacedFromOtherContainmentDelta) {
+                return completed<ChildMovedAndReplacedFromOtherContainmentEvent>("ChildMovedAndReplacedFromOtherContainment", { // § 6.6.4.7
+                    newParent: delta.newParent.id,
+                    newContainment: metaPointerFor(delta.newContainment),
+                    newIndex: delta.newIndex,
+                    oldParent: delta.oldParent.id,
+                    oldContainment: metaPointerFor(delta.oldContainment),
+                    oldIndex: delta.oldIndex,
+                    movedChild: delta.movedChild.id,
+                    replacedChild: delta.replacedChild.id,
+                    replacedDescendants: allIdsOfDescendantsFrom(delta.replacedChild)
+                })
+            }
+            if (delta instanceof ChildMovedAndReplacedFromOtherContainmentInSameParentDelta) {
+                return completed<ChildMovedAndReplacedFromOtherContainmentInSameParentEvent>("ChildMovedAndReplacedFromOtherContainmentInSameParent", { // § 6.6.4.8
+                    parent: delta.parent.id,
+                    oldContainment: metaPointerFor(delta.oldContainment),
+                    oldIndex: delta.oldIndex,
+                    newContainment: metaPointerFor(delta.newContainment),
+                    newIndex: delta.newIndex,
+                    replacedChild: delta.replacedChild.id,
+                    replacedDescendants: allIdsOfDescendantsFrom(delta.replacedChild),
+                    movedChild: delta.movedChild.id
+                })
+            }
+            if (delta instanceof ChildMovedAndReplacedInSameContainmentDelta) {
+                return completed<ChildMovedAndReplacedInSameContainmentEvent>("ChildMovedAndReplacedInSameContainment", { // § 6.6.4.9
+                    parent: delta.parent.id,
+                    containment: metaPointerFor(delta.containment),
+                    oldIndex: delta.oldIndex,
+                    newIndex: delta.newIndex,
+                    movedChild: delta.movedChild.id,
+                    replacedChild: delta.replacedChild.id,
+                    replacedDescendants: allIdsOfDescendantsFrom(delta.replacedChild)
+                })
+            }
+            if (delta instanceof AnnotationAddedDelta) {
+                return completed<AnnotationAddedEvent>("AnnotationAdded", { // § 6.6.5.1
+                    parent: delta.parent.id,
+                    index: delta.index,
+                    newAnnotation: serializeNodeBases([delta.newAnnotation])
+                })
+            }
+            if (delta instanceof AnnotationDeletedDelta) {
+                return completed<AnnotationDeletedEvent>("AnnotationDeleted", { // § 6.6.5.2
+                    parent: delta.parent.id,
+                    deletedAnnotation: delta.deletedAnnotation.id,
+                    index: delta.index,
+                    deletedDescendants: allIdsOfDescendantsFrom(delta.deletedAnnotation)
+                })
+            }
+            if (delta instanceof AnnotationReplacedDelta) {
+                return completed<AnnotationReplacedEvent>("AnnotationReplaced", { // § 6.6.5.3
+                    newAnnotation: serializeNodeBases([delta.newAnnotation]),
+                    parent: delta.parent.id,
+                    index: delta.index,
+                    replacedAnnotation: delta.replacedAnnotation.id,
+                    replacedDescendants: allIdsOfDescendantsFrom(delta.replacedAnnotation)
+                })
+            }
+            if (delta instanceof AnnotationMovedFromOtherParentDelta) {
+                return completed<AnnotationMovedFromOtherParentEvent>("AnnotationMovedFromOtherParent", { // § 6.6.5.4
+                    oldParent: delta.oldParent.id,
+                    oldIndex: delta.oldIndex,
+                    newParent: delta.newParent.id,
+                    newIndex: delta.newIndex,
+                    movedAnnotation: delta.movedAnnotation.id
+                })
+            }
+            if (delta instanceof AnnotationMovedInSameParentDelta) {
+                return completed<AnnotationMovedInSameParentEvent>("AnnotationMovedInSameParent", { // § 6.6.5.5
+                    parent: delta.parent.id,
+                    oldIndex: delta.oldIndex,
+                    newIndex: delta.newIndex,
+                    movedAnnotation: delta.movedAnnotation.id
+                })
+            }
+            if (delta instanceof AnnotationMovedAndReplacedFromOtherParentDelta) {
+                return completed<AnnotationMovedAndReplacedFromOtherParentEvent>("AnnotationMovedAndReplacedFromOtherParent", { // § 6.6.5.6
+                    oldParent: delta.oldParent.id,
+                    oldIndex: delta.oldIndex,
+                    newParent: delta.newParent.id,
+                    newIndex: delta.newIndex,
+                    replacedAnnotation: delta.replacedAnnotation.id,
+                    replacedDescendants: allIdsOfDescendantsFrom(delta.replacedAnnotation),
+                    movedAnnotation: delta.movedAnnotation.id
+                })
+            }
+            if (delta instanceof AnnotationMovedAndReplacedInSameParentDelta) {
+                return completed<AnnotationMovedAndReplacedInSameParentEvent>("AnnotationMovedAndReplacedInSameParent", { // § 6.6.5.7
+                    parent: delta.parent.id,
+                    oldIndex: delta.oldIndex,
+                    newIndex: delta.newIndex,
+                    replacedAnnotation: delta.replacedAnnotation.id,
+                    replacedDescendants: allIdsOfDescendantsFrom(delta.replacedAnnotation),
+                    movedAnnotation: delta.movedAnnotation.id
+                })
+            }
+            if (delta instanceof ReferenceAddedDelta) {
+                return completed<ReferenceAddedEvent>("ReferenceAdded", { // § 6.6.6.1
+                    parent: delta.parent.id,
+                    reference: metaPointerFor(delta.reference),
+                    index: delta.index,
+                    newTarget: serializedRef(delta.newTarget),
+                    newResolveInfo: nodeBaseReader.resolveInfoFor!(delta.newTarget!)!
+                })
+            }
+            if (delta instanceof ReferenceDeletedDelta) {
+                return completed<ReferenceDeletedEvent>("ReferenceDeleted", { // § 6.6.6.2
+                    parent: delta.parent.id,
+                    reference: metaPointerFor(delta.reference),
+                    index: delta.index,
+                    deletedTarget: serializedRef(delta.deletedTarget),
+                    deletedResolveInfo: nodeBaseReader.resolveInfoFor!(delta.deletedTarget!)!
+                })
+            }
+            if (delta instanceof ReferenceChangedDelta) {
+                return completed<ReferenceChangedEvent>("ReferenceChanged", { // § 6.6.6.3
+                    parent: delta.parent.id,
+                    reference: metaPointerFor(delta.reference),
+                    index: delta.index,
+                    oldTarget: serializedRef(delta.oldTarget),
+                    oldResolveInfo: nodeBaseReader.resolveInfoFor!(delta.oldTarget!)!,
+                    newTarget: serializedRef(delta.newTarget),
+                    newResolveInfo: nodeBaseReader.resolveInfoFor!(delta.newTarget!)!
+                })
+            }
+            if (delta instanceof EntryMovedFromOtherReferenceDelta) {
+                return completed<EntryMovedFromOtherReferenceEvent>("EntryMovedFromOtherReference", { // § 6.6.6.4
+                    newParent: delta.newParent.id,
+                    newReference: metaPointerFor(delta.newReference),
+                    newIndex: delta.newIndex,
+                    oldParent: delta.oldParent.id,
+                    oldReference: metaPointerFor(delta.oldReference),
+                    oldIndex: delta.oldIndex,
+                    movedTarget: serializedRef(delta.movedTarget),
+                    movedResolveInfo: nodeBaseReader.resolveInfoFor!(delta.movedTarget!)!
+                })
+            }
+            if (delta instanceof EntryMovedFromOtherReferenceInSameParentDelta) {
+                return completed<EntryMovedFromOtherReferenceInSameParentEvent>("EntryMovedFromOtherReferenceInSameParent", { // § 6.6.6.5
+                    parent: delta.parent.id,
+                    newReference: metaPointerFor(delta.newReference),
+                    newIndex: delta.newIndex,
+                    oldReference: metaPointerFor(delta.oldReference),
+                    oldIndex: delta.oldIndex,
+                    movedTarget: serializedRef(delta.movedTarget),
+                    movedResolveInfo: nodeBaseReader.resolveInfoFor!(delta.movedTarget!)!
+                })
+            }
+            if (delta instanceof EntryMovedInSameReferenceDelta) {
+                return completed<EntryMovedInSameReferenceEvent>("EntryMovedInSameReference", { // § 6.6.6.6
+                    parent: delta.parent.id,
+                    reference: metaPointerFor(delta.reference),
+                    oldIndex: delta.oldIndex,
+                    newIndex: delta.newIndex,
+                    movedTarget: serializedRef(delta.movedTarget),
+                    movedResolveInfo: nodeBaseReader.resolveInfoFor!(delta.movedTarget!)!
+                })
+            }
+            if (delta instanceof EntryMovedAndReplacedFromOtherReferenceDelta) {
+                return completed<EntryMovedAndReplacedFromOtherReferenceEvent>("EntryMovedAndReplacedFromOtherReference", { // § 6.6.6.7
+                    newParent: delta.newParent.id,
+                    newReference: metaPointerFor(delta.newReference),
+                    newIndex: delta.newIndex,
+                    replacedTarget: serializedRef(delta.replacedTarget),
+                    replacedResolveInfo: nodeBaseReader.resolveInfoFor!(delta.replacedTarget!)!,
+                    oldParent: delta.oldParent.id,
+                    oldReference: metaPointerFor(delta.oldReference),
+                    oldIndex: delta.oldIndex,
+                    movedTarget: serializedRef(delta.movedTarget),
+                    movedResolveInfo: nodeBaseReader.resolveInfoFor!(delta.movedTarget!)!
+                })
+            }
+            if (delta instanceof EntryMovedAndReplacedFromOtherReferenceInSameParentDelta) {
+                return completed<EntryMovedAndReplacedFromOtherReferenceInSameParentEvent>("EntryMovedAndReplacedFromOtherReferenceInSameParent", { // § 6.6.6.8
+                    parent: delta.parent.id,
+                    newReference: metaPointerFor(delta.newReference),
+                    newIndex: delta.newIndex,
+                    replacedTarget: serializedRef(delta.replacedTarget),
+                    replacedResolveInfo: nodeBaseReader.resolveInfoFor!(delta.replacedTarget!)!,
+                    oldReference: metaPointerFor(delta.oldReference),
+                    oldIndex: delta.oldIndex,
+                    movedTarget: serializedRef(delta.movedTarget),
+                    movedResolveInfo: nodeBaseReader.resolveInfoFor!(delta.movedTarget!)!
+                })
+            }
+            if (delta instanceof EntryMovedAndReplacedInSameReferenceDelta) {
+                return completed<EntryMovedAndReplacedInSameReferenceEvent>("EntryMovedAndReplacedInSameReference", { // § 6.6.6.9
+                    parent: delta.parent.id,
+                    reference: metaPointerFor(delta.reference),
+                    oldIndex: delta.oldIndex,
+                    movedTarget: serializedRef(delta.movedTarget),
+                    movedResolveInfo: nodeBaseReader.resolveInfoFor!(delta.movedTarget!)!,
+                    newIndex: delta.newIndex,
+                    replacedTarget: serializedRef(delta.replacedTarget),
+                    replacedResolveInfo: nodeBaseReader.resolveInfoFor!(delta.replacedTarget!)!
+                })
+            }
+            if (delta instanceof CompositeDelta) {
+                return completed<CompositeEvent>("CompositeEvent", { // § 6.6.7.1
+                    parts: delta.parts
+                        .map((part) => translated(part))
+                        .filter((event) => event !== undefined) as Event[]
+                })
+            }
+            if (delta instanceof NoOpDelta) {
+                return completed<NoOpEvent>("NoOp", {})
+            }
+
+            throw new Error(`can't handle delta of type ${delta.constructor.name}`)
+        }
+
+        return [translated(delta), sequenceNumber]
+    }
 

package/src/translators/event-to-delta.ts

@@ -54,7 +54,12 @@ import {
     ReferenceChangedDelta,
     ReferenceDeletedDelta
 } from "@lionweb/class-core"
-import { featureResolversFor, unresolved } from "@lionweb/core"
+import {
+    builtinPropertyValueDeserializer,
+    featureResolversFor,
+    PropertyValueDeserializer,
+    unresolved
+} from "@lionweb/core"
 import { LionWebId, LionWebJsonChunk } from "@lionweb/json"
 import {
     AnnotationAddedEvent,
@@ -89,7 +94,7 @@ import {
     ReferenceAddedEvent,
     ReferenceChangedEvent,
     ReferenceDeletedEvent
-} from "../payload/event-types.js"
+} from "../payload/index.js"
 
 /**
  * Type def. for a function that translates {@link Event events} to their corresponding {@link IDelta deltas},
@@ -101,20 +106,24 @@ export type EventToDeltaTranslator = (event: Event, idMapping: IdMapping) => IDe
  * @return a {@link EventToDeltaTranslator} for the languages given as {@link ILanguageBase language bases},
  * with the given {@link IdMapping `idMapping`} and {@link Deserializer `deserialized` deserializer function}.
  */
-export const eventToDeltaTranslator = (languageBases: ILanguageBase[], deserialized: Deserializer<INodeBase[]>): EventToDeltaTranslator => {
+export const eventToDeltaTranslator = (
+    languageBases: ILanguageBase[],
+    deserialized: Deserializer<INodeBase[]>,
+    propertyValueDeserializer: PropertyValueDeserializer = builtinPropertyValueDeserializer
+): EventToDeltaTranslator => {
 
     const eventAsDelta = (event: Event, idMapping: IdMapping): IDelta | undefined => {
 
         const deserializedNodeFrom = (chunk: LionWebJsonChunk): INodeBase => {
-            const nodes = deserialized(chunk, undefined, idMapping)    // (deserializer should take care of installing delta receiver)
+            const nodes = deserialized(chunk, /* dependentNodes: */ [], idMapping)    // (deserializer should take care of installing delta receiver)
             if (nodes.length !== 1) {
                 throw new Error(`expected exactly 1 root node in deserialization of chunk in event, but got ${nodes.length}`)
             }
             return nodes[0]
         }
         const { resolvedPropertyFrom, resolvedContainmentFrom, resolvedReferenceFrom } = featureResolversFor(languageBases.map(({language}) => language));
-        const resolvedRefTo = (ref: LionWebId | null) =>
-            ref === null ? unresolved : idMapping.fromId(ref)
+        const resolvedRefTo = (ref: LionWebId | typeof unresolved) =>
+            ref === unresolved ? unresolved : idMapping.fromId(ref)
 
         switch (event.messageKind) {
 
@@ -132,25 +141,22 @@ export const eventToDeltaTranslator = (languageBases: ILanguageBase[], deseriali
                 return undefined
             }
             case "PropertyAdded": { // § 6.6.3.1
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                const { node, property, newValue } = event as PropertyAddedEvent<any>
+                const { node, property, newValue } = event as PropertyAddedEvent
                 const resolvedNode = idMapping.fromId(node)
                 const resolvedProperty = resolvedPropertyFrom(property, resolvedNode.classifier)
-                return new PropertyAddedDelta(resolvedNode, resolvedProperty, newValue)
+                return new PropertyAddedDelta(resolvedNode, resolvedProperty, propertyValueDeserializer.deserializeValue(newValue, resolvedProperty))
             }
             case "PropertyDeleted": { // § 6.6.3.2
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                const { node, property, oldValue } = event as PropertyDeletedEvent<any>
+                const { node, property, oldValue } = event as PropertyDeletedEvent
                 const resolvedNode = idMapping.fromId(node)
                 const resolvedProperty = resolvedPropertyFrom(property, resolvedNode.classifier)
-                return new PropertyDeletedDelta(resolvedNode, resolvedProperty, oldValue)
+                return new PropertyDeletedDelta(resolvedNode, resolvedProperty, propertyValueDeserializer.deserializeValue(oldValue, resolvedProperty))
             }
             case "PropertyChanged": { // § 6.6.3.3
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                const { node, property, newValue, oldValue } = event as PropertyChangedEvent<any>
+                const { node, property, newValue, oldValue } = event as PropertyChangedEvent
                 const resolvedNode = idMapping.fromId(node)
                 const resolvedProperty = resolvedPropertyFrom(property, resolvedNode.classifier)
-                return new PropertyChangedDelta(resolvedNode, resolvedProperty, oldValue, newValue)
+                return new PropertyChangedDelta(resolvedNode, resolvedProperty, propertyValueDeserializer.deserializeValue(oldValue, resolvedProperty), propertyValueDeserializer.deserializeValue(newValue, resolvedProperty))
             }
             case "ChildAdded": { // § 6.6.4.1
                 const { parent, newChild, containment, index } = event as ChildAddedEvent

package/src/translators/index.ts

@@ -15,7 +15,8 @@
 // SPDX-FileCopyrightText: 2025 TRUMPF Laser SE and other contributors
 // SPDX-License-Identifier: Apache-2.0
 
-export { deltaAsCommand } from "./delta-to-command.js"
+export { deltaToCommandTranslator } from "./delta-to-command.js"
+export { deltaToEventTranslator } from "./delta-to-event.js"
 export { eventToDeltaTranslator } from "./event-to-delta.js"
 export type { EventToDeltaTranslator } from "./event-to-delta.js"