@lionweb/validation 0.6.0-beta.3 → 0.6.0-beta.5

package/src/diff/LionWebJsonDiff.ts

@@ -1,22 +1,23 @@
 import { JsonContext } from "../issues/index.js"
 import {
     ChunkUtils,
-    isEqualMetaPointer,
-    LionWebJsonContainment,
+    isEqualMetaPointer, isEqualReferenceTarget,
     LionWebJsonChunk,
+    LionWebJsonContainment,
     LionWebJsonNode,
     LionWebJsonProperty,
     LionWebJsonReference,
+    LionWebJsonReferenceTarget,
     LwJsonUsedLanguage,
-    NodeUtils, LionWebJsonReferenceTarget
+    NodeUtils
 } from "../json/index.js"
-import { Change, GenericChange } from "./changes/Change.js"
+import { Change, GenericChange, Missing } from "./changes/Change.js"
 import { LanguageAdded, LanguageRemoved, NodeAdded, NodeRemoved, SerializationFormatChange } from "./changes/ChunkChange.js"
-import { ChildAdded, ChildRemoved } from "./changes/ContainmentChange.js"
-import { TargetAdded, TargetRemoved } from "./changes/index.js"
-import { DiffResult } from "./DiffResult.js"
+import { ChildAdded, ChildRemoved, ChildOrderChanged } from "./changes/ContainmentChange.js"
+import { AnnotationAdded, AnnotationOrderChanged, AnnotationRemoved, TargetAdded, TargetOrderChanged, TargetRemoved } from "./changes/index.js"
 import { NodeClassifierChanged, ParentChanged } from "./changes/NodeChange.js"
 import { PropertyValueChanged } from "./changes/PropertyChange.js"
+import { DiffResult } from "./DiffResult.js"
 
 /**
  * Comparing LionWeb JSON chunks and find all differences
@@ -42,9 +43,7 @@ export class LionWebJsonDiff {
      */
     diffLwNode(ctx: JsonContext, beforeNode: LionWebJsonNode, afterNode: LionWebJsonNode): void {
         if (!isEqualMetaPointer(beforeNode.classifier, afterNode.classifier)) {
-            this.change(
-                new NodeClassifierChanged(ctx.concat("classifier"), beforeNode, beforeNode.classifier, afterNode.classifier),
-            )
+            this.change(new NodeClassifierChanged(ctx.concat("classifier"), beforeNode, beforeNode.classifier, afterNode.classifier))
         }
         if (beforeNode.parent !== afterNode.parent) {
             this.change(new ParentChanged(ctx, beforeNode, beforeNode.parent, afterNode.parent))
@@ -60,7 +59,8 @@ export class LionWebJsonDiff {
                         beforeNode.id,
                         beforeProperty.property,
                         beforeProperty.value,
-                        undefined,
+                        null,
+                        Missing.MissingAfter
                     ),
                 )
             } else {
@@ -76,8 +76,9 @@ export class LionWebJsonDiff {
                         ctx.concat("properties", index),
                         beforeNode.id,
                         afterProperty.property,
-                        undefined,
+                        null,
                         afterProperty.value,
+                        Missing.MissingBefore
                     ),
                 )
             }
@@ -90,7 +91,7 @@ export class LionWebJsonDiff {
                 // NB No containment is considered equivalent to a containment with empty _children_
                 if (beforeContainment.children.length !== 0) {
                     beforeContainment.children.forEach(childId => {
-                        this.change(new ChildRemoved(ctx.concat("containments", index), beforeNode, beforeContainment.containment, childId))
+                        this.change(new ChildRemoved(ctx.concat("containments", index), beforeNode, beforeContainment.containment, afterContainment, childId, Missing.MissingAfter))
                     })
                 }
             } else {
@@ -103,7 +104,7 @@ export class LionWebJsonDiff {
             if (beforeContainment === null) {
                 if (afterContainment.children.length !== 0) {
                     afterContainment.children.forEach(childId => {
-                        this.change(new ChildAdded(ctx.concat("containments", index), afterNode, afterContainment.containment, childId))
+                        this.change(new ChildAdded(ctx.concat("containments", index), afterNode, afterContainment.containment, afterContainment, childId, Missing.MissingBefore))
                     })
                 }
             }
@@ -115,7 +116,7 @@ export class LionWebJsonDiff {
             if (afterReference === null) {
                 if (beforeReference.targets.length !== 0) {
                     beforeReference.targets.forEach(target => {
-                        this.change(new TargetRemoved(ctx.concat("references", index), afterNode, beforeReference.reference, target.reference))
+                        this.change(new TargetRemoved(ctx.concat("references", index), afterNode, beforeReference, afterReference, target, Missing.MissingAfter))
                     })
                 }
             } else {
@@ -128,11 +129,34 @@ export class LionWebJsonDiff {
             if (beforeReference === null) {
                 if (afterReference.targets.length !== 0) {
                     afterReference.targets.forEach(target => {
-                        this.change(new TargetAdded(ctx.concat("references", index), afterNode, afterReference.reference, target.reference))
+                        this.change(new TargetAdded(ctx.concat("references", index), afterNode, beforeReference, afterReference, target, Missing.MissingBefore))
                     })
                 }
             }
         })
+        if (beforeNode.annotations !== undefined && afterNode.annotations !== undefined) {
+            let annotationDiffFound = false
+            beforeNode.annotations.forEach((beforeAnn: string, index: number) => {
+                if (!afterNode.annotations.includes(beforeAnn)) {
+                    annotationDiffFound = true
+                    this.change(new AnnotationRemoved(ctx, beforeNode, afterNode, beforeAnn, index))
+                }
+            })
+            afterNode.annotations.forEach((afterAnn: string, index: number) => {
+                if (!beforeNode.annotations.includes(afterAnn)) {
+                    annotationDiffFound = true
+                    this.change(new AnnotationAdded(ctx, beforeNode, afterNode, afterAnn, index))
+                }
+            })
+            if (!annotationDiffFound) {
+                for (let i: number = 0; i < afterNode.annotations.length; i++) {
+                    if (afterNode.annotations[i] !== beforeNode.annotations[i]) {
+                        this.change(new AnnotationOrderChanged(ctx.concat("annotations"), beforeNode, afterNode, "", i))
+                        break
+                    }
+                }
+            }
+        }
     }
 
     diffLwChunk(beforeChunk: LionWebJsonChunk, afterChunk: LionWebJsonChunk): void {
@@ -197,14 +221,25 @@ export class LionWebJsonDiff {
         }
         // Check whether children exist in both objects (two for loops)
         // TODO Also check for the order that can be changed!!!
+        let changeFound = false
         for (const childId1 of beforeContainment.children) {
             if (!afterContainment.children.includes(childId1)) {
-                this.change(new ChildRemoved(ctx, node, beforeContainment.containment, childId1))
+                changeFound = true
+                this.change(new ChildRemoved(ctx, node, beforeContainment.containment, afterContainment, childId1))
             }
         }
         for (const childId2 of afterContainment.children) {
             if (!beforeContainment.children.includes(childId2)) {
-                this.change(new ChildAdded(ctx, node, beforeContainment.containment, childId2))
+                changeFound = true
+                this.change(new ChildAdded(ctx, node, beforeContainment.containment, afterContainment, childId2))
+            }
+        }
+        if (!changeFound) {
+            for (let i: number = 0; i < afterContainment.children.length; i++) {
+                if (afterContainment.children[i] !== beforeContainment.children[i]) {
+                    this.change(new ChildOrderChanged(ctx.concat("children"), node, afterContainment.containment, afterContainment, ""))
+                    break
+                }
             }
         }
     }
@@ -214,21 +249,41 @@ export class LionWebJsonDiff {
             console.error("diffContainment: MetaPointers of containments should be identical")
             this.diff(ctx, `Reference has concept ${JSON.stringify(beforeRef.reference)} vs ${JSON.stringify(afterRef.reference)}`)
         }
+        let diffFound = false;
         beforeRef.targets.forEach((beforeTarget: LionWebJsonReferenceTarget, index: number) => {
             const afterTarget = NodeUtils.findLwReferenceTarget(afterRef.targets, beforeTarget)
             if (afterTarget === null) {
-                // this.change(new TargetRemoved(ctx.concat("targets", index), node, target))
-                // this.diff(ctx, `REFERENCE Target ${JSON.stringify(beforeTarget)} missing in second `)
-                this.change(new TargetRemoved(ctx.concat("targets", index), node, beforeRef.reference, beforeTarget.reference))
+                this.change(new TargetRemoved(ctx.concat("targets", index), node, beforeRef, afterRef, beforeTarget))
+                diffFound = true
             } else {
-                if (beforeTarget.reference !== afterTarget.reference || beforeTarget.resolveInfo !== afterTarget.resolveInfo) {
-                    this.diff(ctx.concat("targets", index), `REFERENCE target ${JSON.stringify(beforeTarget)} vs ${JSON.stringify(afterTarget)}`)
+                if (!isEqualReferenceTarget(beforeTarget, afterTarget)) {
+                    this.diff(
+                        ctx.concat("targets", index),
+                        `ERROR: reference target ${JSON.stringify(beforeTarget)} vs ${JSON.stringify(afterTarget)}`,
+                    )
                 }
             }
         })
-        for (const target of afterRef.targets) {
-            if (NodeUtils.findLwReferenceTarget(beforeRef.targets, target) === null) {
-                this.diff(ctx, `REFERENCE Target ${JSON.stringify(target)} missing in first `)
+        afterRef.targets.forEach((afterTarget: LionWebJsonReferenceTarget, index: number) => {
+            const beforeTarget = NodeUtils.findLwReferenceTarget(beforeRef.targets, afterTarget)
+            if (beforeTarget === null) {
+                this.change(new TargetAdded(ctx.concat("targets", index), node, beforeRef, afterRef, afterTarget))
+                diffFound = true
+            } else {
+                if (!isEqualReferenceTarget(beforeTarget, afterTarget)) {
+                    this.diff(
+                        ctx.concat("targets", index),
+                        `ERROR: reference target ${JSON.stringify(beforeTarget)} vs ${JSON.stringify(afterTarget)}`,
+                    )
+                }
+            }
+        })
+        if (!diffFound) {
+            for (let i: number = 0; i < beforeRef.targets.length; i++) {
+                if (!isEqualReferenceTarget(beforeRef.targets[i], afterRef.targets[i])) {
+                    this.change(new TargetOrderChanged(ctx.concat("targets"), node, beforeRef, afterRef, beforeRef.targets[i]))
+                    break
+                }
             }
         }
     }

package/src/diff/changes/Change.ts

@@ -20,9 +20,33 @@ export type ChangeType =
     | "TargetRemoved"
     | "ReferenceRemoved"
     | "ReferenceAdded"
+    | "AnnotationRemoved"
+    | "AnnotationAdded"
+    | "ChildOrderChanged"
+    | "AnnotationOrderChanged"
+    | "TargetOrderChanged"
+
+/**
+ * Additionbal property in property, contauinment and reference changes to state
+ * that the whole property/ containment / reference definition is missing.
+ */
+export enum Missing {
+    /**
+     * Both before and after have a definition for the property / containment / reference
+     */
+    NotMissing,
+    /**
+     * The definition is missing _before_ for the property / containment / reference
+     */
+    MissingBefore,
+    /**
+     * The definition is missing _after_ for the property / containment / reference
+     */
+    MissingAfter
+}
 
 export abstract class Change {
-    abstract readonly id: ChangeType
+    abstract readonly changeType: ChangeType
     context: JsonContext
 
     constructor(context: JsonContext) {
@@ -32,12 +56,12 @@ export abstract class Change {
     protected abstract msg(): string
 
     public changeMsg(): string {
-        return `${this.id}: ${this.msg()} at ${this.context.toString()} `
+        return `${this.changeType}: ${this.msg()} at ${this.context.toString()} `
     }
 }
 
 export class GenericChange extends Change {
-    readonly id = "GenericChange"
+    readonly changeType = "GenericChange"
 
     constructor(
         context: JsonContext,

package/src/diff/changes/ChunkChange.ts

@@ -9,7 +9,7 @@ export abstract class ChunkChange extends Change {
 }
 
 export class SerializationFormatChange extends ChunkChange {
-    readonly id = "SerializationFormatChange"
+    readonly changeType = "SerializationFormatChange"
 
     constructor(
         public context: JsonContext,
@@ -23,7 +23,7 @@ export class SerializationFormatChange extends ChunkChange {
 }
 
 export class NodeRemoved extends ChunkChange {
-    readonly id = "NodeRemoved"
+    readonly changeType = "NodeRemoved"
 
     constructor(
         public context: JsonContext,
@@ -36,7 +36,7 @@ export class NodeRemoved extends ChunkChange {
 }
 
 export class NodeAdded extends ChunkChange {
-    readonly id = "NodeAdded"
+    readonly changeType = "NodeAdded"
 
     constructor(
         public context: JsonContext,
@@ -58,11 +58,11 @@ export abstract class LanguageChange extends ChunkChange {
 }
 
 export class LanguageRemoved extends LanguageChange {
-    readonly id = "LanguageRemoved"
+    readonly changeType = "LanguageRemoved"
     protected msg = () => `Language with  key ${this.language.key} and version ${this.language.version} is removed`
 }
 
 export class LanguageAdded extends LanguageChange {
-    readonly id = "LanguageAdded"
+    readonly changeType = "LanguageAdded"
     protected msg = () => `Language with  key ${this.language.key} and version ${this.language.version} is added`
 }

package/src/diff/changes/ContainmentChange.ts

@@ -1,34 +1,32 @@
 import { JsonContext } from "../../issues/index.js"
-import { LionWebJsonMetaPointer, LionWebJsonNode } from "../../json/index.js"
-import { Change } from "./Change.js"
+import { LionWebJsonContainment, LionWebJsonMetaPointer, LionWebJsonNode } from "../../json/index.js"
+import { Change, Missing } from "./Change.js"
 
 export abstract class ContainmentChange extends Change {
     constructor(
         public context: JsonContext,
         public parentNode: LionWebJsonNode,
         public containment: LionWebJsonMetaPointer,
+        public afterContainment: LionWebJsonContainment | null,
         public childId: string,
+        public missing = Missing.NotMissing
     ) {
         super(context)
     }
 }
 
 export class ChildAdded extends ContainmentChange {
-    readonly id = "ChildAdded"
+    readonly changeType = "ChildAdded"
     protected msg = () => `Node "${this.parentNode.id}" added child "${this.childId}" to containment ${this.containment.key}`
 }
 
 export class ChildRemoved extends ContainmentChange {
-    readonly id = "ChildRemoved"
-    protected msg = () => `Node "${this.parentNode.id}" removed child "${this.childId}"`
+    readonly changeType = "ChildRemoved"
+    protected msg = () => `Node "${this.parentNode.id}" removed child "${this.childId}" from containment "${this.containment.key}"`
 }
 
-export class ContainmentAdded extends Change {
-    readonly id = "ContainmentAdded";
-    constructor(ctx: JsonContext, public node: LionWebJsonNode, public containment: LionWebJsonMetaPointer) {
-        super(ctx)
-    }
-
-    protected msg = () => `Node "${this.node.id}" containment added: "${JSON.stringify(this.containment)}"`
+export class ChildOrderChanged extends ContainmentChange {
+    readonly changeType = "ChildOrderChanged"
+    protected msg = () => `Node "${this.parentNode.id}" changed order of children in containment "${this.containment.key}"`
 }
 

package/src/diff/changes/NodeChange.ts

@@ -3,7 +3,7 @@ import { LionWebJsonMetaPointer, LionWebJsonNode } from "../../json/index.js"
 import { Change, ChangeType } from "./Change.js"
 
 export class NodeClassifierChanged extends Change {
-    readonly id: ChangeType = "NodeClassifierChanged"
+    readonly changeType: ChangeType = "NodeClassifierChanged"
 
     constructor(
         public context: JsonContext,
@@ -13,11 +13,12 @@ export class NodeClassifierChanged extends Change {
     ) {
         super(context)
     }
+
     protected msg = () => `Object ${this.node.id} has classifier changed from ${this.oldClassifier.key} to ${this.newClassifier.key}`
 }
 
 export class ParentChanged extends Change {
-    readonly id = "ParentChanged"
+    readonly changeType = "ParentChanged"
 
     constructor(
         public context: JsonContext,
@@ -30,3 +31,33 @@ export class ParentChanged extends Change {
 
     protected msg = () => `Node "${this.node.id}" changed parent from "${this.beforeParentId}" to "${this.afterParentId}`
 }
+
+export abstract class AnnotationChange extends Change {
+    constructor(
+        ctx: JsonContext,
+        public nodeBefore: LionWebJsonNode,
+        public nodeAfter: LionWebJsonNode,
+        public annotationId: string,
+        public index: number
+    ) {
+        super(ctx)
+    }
+}
+
+export class AnnotationRemoved extends AnnotationChange {
+    readonly changeType = "AnnotationRemoved"
+
+    protected msg = () => `Node "${this.nodeBefore.id}" removed annotation "${this.annotationId}"`
+}
+
+export class AnnotationAdded extends AnnotationChange {
+    readonly changeType = "AnnotationAdded"
+
+    protected msg = () => `Node "${this.nodeAfter.id}" added annotation "${this.annotationId}"`
+}
+
+
+export class AnnotationOrderChanged extends AnnotationChange {
+    readonly changeType = "AnnotationOrderChanged"
+    protected msg = () => `Node "${this.nodeAfter.id}" changed order of annotations`
+}

package/src/diff/changes/PropertyChange.ts

@@ -1,26 +1,28 @@
 import { JsonContext } from "../../issues/index.js"
 import { LionWebJsonMetaPointer, LionWebJsonNode } from "../../json/index.js"
-import { Change } from "./Change.js"
+import { Change, Missing } from "./Change.js"
+
 
 export abstract class PropertyChange extends Change {
     constructor(
         public context: JsonContext,
         public nodeId: string,
         public property: LionWebJsonMetaPointer,
-        public oldValue: string | undefined,
-        public newValue: string | undefined,
+        public oldValue: string | null,
+        public newValue: string | null,
+        public missing: Missing = Missing.NotMissing
     ) {
-        super(context)
+        super(context) 
     }
 }
 
 export class PropertyValueChanged extends PropertyChange {
-    readonly id = "PropertyValueChanged"
+    readonly changeType = "PropertyValueChanged"
     protected msg = () => `Node "${this.nodeId} changed value of property "${this.property.key}" from "${this.oldValue}" to "${this.newValue}"`
 }
 
 export class PropertyAdded extends Change {
-    readonly id = "PropertyAdded";
+    readonly changeType = "PropertyAdded";
     constructor(ctx: JsonContext, public node: LionWebJsonNode, public property: LionWebJsonMetaPointer) {
         super(ctx)
     }

package/src/diff/changes/ReferenceChange.ts

@@ -1,24 +1,34 @@
 import { JsonContext } from "../../issues/index.js"
-import { LionWebJsonMetaPointer, LionWebJsonNode } from "../../json/index.js"
-import { Change } from "./Change.js"
+import { LionWebJsonNode, LionWebJsonReference, LionWebJsonReferenceTarget } from "../../json/index.js"
+import { Change, Missing } from "./Change.js"
 
 export abstract class ReferenceChange extends Change {
     constructor(
         public context: JsonContext,
         public node: LionWebJsonNode,
-        public reference: LionWebJsonMetaPointer,
-        public targetId: string,
+        public beforeReference: LionWebJsonReference | null,
+        public afterReference: LionWebJsonReference | null,
+        public target: LionWebJsonReferenceTarget,
+        public missing = Missing.NotMissing
     ) {
         super(context)
     }
 }
 
 export class TargetAdded extends ReferenceChange {
-    readonly id = "TargetAdded"
-    protected msg = () => `Node "${this.node.id}" added target "${this.targetId}" to reference "${this.reference.key}"`
+    readonly changeType = "TargetAdded"
+    protected msg = () =>
+        `Node "${this.node.id}" added target "${this.target.reference}" to reference "${this?.afterReference?.reference?.key}"`
 }
 
 export class TargetRemoved extends ReferenceChange {
-    readonly id = "TargetRemoved"
-    protected msg = () => `Node "${this.node.id}" removed target "${this.targetId}" from reference "${this.reference.key}"`
+    readonly changeType = "TargetRemoved"
+    protected msg = () =>
+        `Node "${this.node.id}" removed target "${this.target.reference}" from reference "${this?.beforeReference?.reference?.key}"`
 }
+
+export class TargetOrderChanged extends ReferenceChange {
+    readonly changeType = "TargetOrderChanged"
+    protected msg = () => `Node "${this.node.id}" changed order of targets in reference "${this.afterReference?.reference?.key}"`
+}
+

package/src/json/LionWebJson.ts

@@ -14,6 +14,11 @@ export const LIONWEB_JSON_TYPE = "LionCore-builtins-JSON"
 export const LIONWEB_INTEGER_TYPE = "LionCore-builtins-Integer"
 export const LIONWEB_STRING_TYPE = "LionCore-builtins-String"
 
+export const LIONWEB_M3_INAMED_PROPERTY = {
+    language: LION_CORE_BUILTINS_KEY,
+    version: LION_CORE_M3_VERSION,
+    key: LION_CORE_BUILTINS_INAMED_NAME
+}
 export type LionWebId = string
 
 export type LionWebJsonMetaPointer = {
@@ -26,6 +31,10 @@ export function isEqualMetaPointer(p1: LionWebJsonMetaPointer, p2: LionWebJsonMe
     return p1.key === p2.key && p1.version === p2.version && p1.language === p2.language
 }
 
+export function isEqualReferenceTarget(first: LionWebJsonReferenceTarget, second: LionWebJsonReferenceTarget): boolean {
+    return first.reference === second.reference && first.resolveInfo === second.resolveInfo
+}
+
 export type LionWebJsonChunk = {
     serializationFormatVersion: string
     languages: LwJsonUsedLanguage[]

package/src/json/LionWebJsonChunkWrapper.ts

@@ -1,9 +1,7 @@
 import {
-    isEqualMetaPointer, LION_CORE_BUILTINS_INAMED_NAME, LION_CORE_BUILTINS_KEY, LION_CORE_M3_VERSION,
+    LIONWEB_M3_INAMED_PROPERTY,
     LionWebId,
     LionWebJsonChunk,
-    LionWebJsonContainment,
-    LionWebJsonMetaPointer,
     LionWebJsonNode,
     LionWebJsonProperty
 } from "./LionWebJson.js"
@@ -41,18 +39,6 @@ export class LionWebJsonChunkWrapper {
         return this.nodesIdMap.get(id)
     }
 
-    findContainment(node: LionWebJsonNode, containment: LionWebJsonMetaPointer): LionWebJsonContainment | undefined {
-        return node.containments.find(
-            cont => isEqualMetaPointer(cont.containment, containment)
-        )
-    }
-
-    findProperty(node: LionWebJsonNode, property: LionWebJsonMetaPointer): LionWebJsonProperty | undefined {
-        return node.properties.find(
-            prop => isEqualMetaPointer(prop.property, property)
-        )
-    }
-
     findNodesOfConcept(conceptKey: string): LionWebJsonNode[] {
         return this.jsonChunk.nodes.filter(node => node.classifier.key === conceptKey)
     }
@@ -88,22 +74,25 @@ export class LionWebJsonChunkWrapper {
             return "";
         }
         let result: string = ""
-        const nameProperty = this.findProperty(node, {
-            language: LION_CORE_BUILTINS_KEY,
-            version: LION_CORE_M3_VERSION,
-            key: LION_CORE_BUILTINS_INAMED_NAME,
-        })
+        const nameProperty = NodeUtils.findProperty(node, LIONWEB_M3_INAMED_PROPERTY)
         const name = nameProperty === undefined ? "" : " " + nameProperty.value
-        result += Array(depth).join("    ") + "(" + node.id + ")" + name + "\n"
+        result += this.indent(depth) + "(" + node.id + ")" + name + "\n"
+        if (node.annotations !== undefined && node.annotations.length !== 0) {
+            result += this.indent(depth + 1) + "*Annotations*" + "\n"
+            node.annotations.forEach(ann => {
+                result += this.recursiveToString(this.getNode(ann), depth + 1)
+                // result += this.indent(depth) + "[[" + JSON.stringify(ann) + "]]\n"
+            })
+        }
         node.properties.filter(p => p !== nameProperty).forEach(property => {
-            result += Array(depth + 1).join("    ") + "*" + property.property.key + "*: " + property.value + "\n"
+            result += this.indent(depth + 1) + "*property* " + property.property.key + ": " + property.value + "\n"
         })
         node.references.forEach(ref => {
-            result += Array(depth + 1).join("    ") + "*" + ref.reference.key + "*: " + JSON.stringify(ref.targets) + "\n"
+            result += this.indent(depth + 1) + "*" + ref.reference.key + "*: " + JSON.stringify(ref.targets) + "\n"
         })
         node.containments.forEach(cont => {
             if (cont.children.length !== 0) {
-                result += Array(depth + 1).join("    ") + "*" + cont.containment.key + "*" + "\n"
+                result += this.indent(depth + 1) + "*" + cont.containment.key + "*" + "\n"
                 cont.children.forEach(ch => {
                     result += this.recursiveToString(this.getNode(ch), depth + 1)
                 })
@@ -111,4 +100,8 @@ export class LionWebJsonChunkWrapper {
         })
         return result
     }
+    
+    private indent(depth: number): string {
+        return Array(depth).join("    ")
+    }
 }

package/src/json/LionWebLanguageDefinition.ts

@@ -17,6 +17,7 @@ export const LIONWEB_M3_LANGUAGE_KEY = "Language"
 export const LIONWEB_M3_LANGUAGE_VERSION_KEY = "Language-version"
 export const LIONWEB_M3_IKEYED_KEY_KEY = "IKeyed-key"
 export const LIONWEB_M3_PROPERTY_TYPE_KEY = "Property-type"
+
 /**
  * Collection of language definitions
  */

package/src/json/NodeUtils.ts

@@ -1,9 +1,11 @@
 import {
-    LionWebJsonContainment,
+    isEqualMetaPointer,
+    isEqualReferenceTarget,
+    LionWebJsonContainment, LionWebJsonMetaPointer,
     LionWebJsonNode,
     LionWebJsonProperty,
     LionWebJsonReference,
-    LionWebJsonReferenceTarget,
+    LionWebJsonReferenceTarget
 } from "./LionWebJson.js"
 
 /**
@@ -24,6 +26,12 @@ export class NodeUtils {
         return null
     }
 
+    static findProperty(node: LionWebJsonNode, property: LionWebJsonMetaPointer): LionWebJsonProperty | undefined {
+        return node.properties.find(
+            prop => isEqualMetaPointer(prop.property, property)
+        )
+    }
+
     /**
      * Find containment child with key equals `key` in `node`.
      * @param node
@@ -38,6 +46,13 @@ export class NodeUtils {
         return null
     }
 
+    static findContainment(node: LionWebJsonNode, containment: LionWebJsonMetaPointer): LionWebJsonContainment | undefined {
+        return node.containments.find(
+            cont => isEqualMetaPointer(cont.containment, containment)
+        )
+    }
+
+
     static findLwReference(node: LionWebJsonNode, key: string): LionWebJsonReference | null {
         for (const reference of node.references) {
             if (reference.reference.key === key) {
@@ -52,13 +67,13 @@ export class NodeUtils {
         target: LionWebJsonReferenceTarget,
     ): LionWebJsonReferenceTarget | null {
         for (const refTarget of lwReferenceTargets) {
-            if (refTarget.reference === target.reference && refTarget.resolveInfo === target.resolveInfo) {
+            if (isEqualReferenceTarget(refTarget, target)) {
                 return refTarget
             }
         }
         return null
     }
-
+    
     /**
      * Get all nodes that are children for _node_: both the containment and annotation children
      * @param node