@lionweb/validation 0.5.0 → 0.6.0-beta.2

package/src/issues/index.ts

@@ -1,5 +1,5 @@
-export * from "./JsonContext.js";
-export * from "./ValidationIssue.js";
-export * from "./SyntaxIssues.js";
-export * from "./ReferenceIssues.js";
-export * from "./LanguageIssues.js";
+export * from "../json/JsonContext.js"
+export * from "./ValidationIssue.js"
+export * from "./SyntaxIssues.js"
+export * from "./ReferenceIssues.js"
+export * from "./LanguageIssues.js"

package/src/json/ChunkUtils.ts

@@ -1,8 +1,4 @@
-import {
-    LionWebJsonChunk,
-    LionWebJsonNode,
-    LwJsonUsedLanguage
-} from "./LionWebJson.js";
+import { LionWebJsonChunk, LionWebJsonNode, LwJsonUsedLanguage } from "./LionWebJson.js"
 
 /**
  * Utility functions for LionWeb chunks
@@ -16,10 +12,10 @@ export class ChunkUtils {
     static findLwUsedLanguage(chunk: LionWebJsonChunk, key: string): LwJsonUsedLanguage | null {
         for (const language of chunk.languages) {
             if (language.key === key) {
-                return language;
+                return language
             }
         }
-        return null;
+        return null
     }
 
     /**
@@ -31,10 +27,10 @@ export class ChunkUtils {
     static findLwUsedLanguageWithVersion(chunk: LionWebJsonChunk, key: string, version: string): LwJsonUsedLanguage | null {
         for (const language of chunk.languages) {
             if (language.key === key && language.version === version) {
-                return language;
+                return language
             }
         }
-        return null;
+        return null
     }
 
     /**
@@ -45,9 +41,9 @@ export class ChunkUtils {
     static findNode(chunk: LionWebJsonChunk, id: string): LionWebJsonNode | null {
         for (const node of chunk.nodes) {
             if (node.id === id) {
-                return node;
+                return node
             }
         }
-        return null;
+        return null
     }
 }

package/src/json/JsonContext.ts

@@ -0,0 +1,31 @@
+type JsonPath = (string | number)[]
+
+export class JsonContext {
+    private parent: JsonContext | null
+    private local_path: JsonPath
+
+    concat(...items: JsonPath): JsonContext {
+        return new JsonContext(this, items)
+    }
+
+    path(): JsonPath {
+        return this.parent === null ? this.local_path : this.parent.path().concat(this.local_path)
+    }
+
+    constructor(parent: JsonContext | null, path: JsonPath) {
+        this.parent = parent
+        this.local_path = path
+    }
+
+    toString(): string {
+        let result = ""
+        this.path().forEach((part, index) => {
+            if (typeof part === "string") {
+                result += (index === 0 ? "" : ".") + part
+            } else if (typeof part === "number") {
+                result += "[" + part + "]"
+            }
+        })
+        return result
+    }
+}

package/src/json/LanguageUtils.ts

@@ -1,20 +1,19 @@
-import { LionWebJsonChunk } from "./LionWebJson.js";
-import { LionWebJsonChunkWrapper } from "./LionWebJsonChunkWrapper.js";
+import { LionWebJsonChunk } from "./LionWebJson.js"
+import { LionWebJsonChunkWrapper } from "./LionWebJsonChunkWrapper.js"
 
 /**
  * Contains methods for getting information from a LionWebJsonChunk representing a language.
  */
 export class LanguageWrapper extends LionWebJsonChunkWrapper {
-   
     constructor(languageJson: LionWebJsonChunk) {
-        super(languageJson);
+        super(languageJson)
     }
-    
+
     // inheritsFrom = (classifier: LionWebJsonNode): LionWebJsonNode[] => {
     //     if (isConcept(classifier) || isAnnotation(classifier)) {
     //         // find the language (have key and version)
     //         // find concept or annotation
-    //         // find extends/inherits property 
+    //         // find extends/inherits property
     //         return [
     //             ...(
     //                 isRef(classifier.extends)

package/src/json/LionWebJson.ts

@@ -3,48 +3,49 @@
  * @see https://lionweb-io.github.io/specification/serialization/serialization.html
  * We use types instead of classes, because the purpose is to define the Lionweb JSON to be sent over the line.
  */
-export const LION_CORE_BUILTINS_KEY = "LionCore-builtins";
-export const LION_CORE_BUILTINS_INAMED_NAME = "LionCore-builtins-INamed-name";
-export const LION_CORE_M3_KEY = "LionCore-M3";
-export const LION_CORE_M3_NAME = "LionCore_M3";
+export const LION_CORE_BUILTINS_KEY = "LionCore-builtins"
+export const LION_CORE_BUILTINS_INAMED_NAME = "LionCore-builtins-INamed-name"
+export const LION_CORE_M3_KEY = "LionCore-M3"
+export const LION_CORE_M3_NAME = "LionCore_M3"
+export const LION_CORE_M3_VERSION = "2023.1"
 
-export const LIONWEB_BOOLEAN_TYPE = "LionCore-builtins-Boolean";
-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_BOOLEAN_TYPE = "LionCore-builtins-Boolean"
+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 type Id = string;
+export type LionWebId = string
 
 export type LionWebJsonMetaPointer = {
-    language: string;
-    version: string;
-    key: string;
-};
+    language: string
+    version: string
+    key: string
+}
 
 export function isEqualMetaPointer(p1: LionWebJsonMetaPointer, p2: LionWebJsonMetaPointer): boolean {
-    return p1.key === p2.key && p1.version === p2.version && p1.language === p2.language;
+    return p1.key === p2.key && p1.version === p2.version && p1.language === p2.language
 }
 
 export type LionWebJsonChunk = {
-    serializationFormatVersion: string;
-    languages: LwJsonUsedLanguage[];
-    nodes: LionWebJsonNode[];
-};
+    serializationFormatVersion: string
+    languages: LwJsonUsedLanguage[]
+    nodes: LionWebJsonNode[]
+}
 
 export type LwJsonUsedLanguage = {
-    key: string;
-    version: string;
-};
+    key: string
+    version: string
+}
 
 export type LionWebJsonNode = {
-    id: Id;
-    classifier: LionWebJsonMetaPointer;
-    properties: LionWebJsonProperty[];
-    containments: LionWebJsonChild[];
-    references: LionWebJsonReference[];
-    annotations: Id[];
-    parent: Id | null;
-};
+    id: LionWebId
+    classifier: LionWebJsonMetaPointer
+    properties: LionWebJsonProperty[]
+    containments: LionWebJsonContainment[]
+    references: LionWebJsonReference[]
+    annotations: LionWebId[]
+    parent: LionWebId | null
+}
 
 export function createLwNode(): LionWebJsonNode {
     return {
@@ -55,25 +56,25 @@ export function createLwNode(): LionWebJsonNode {
         references: [],
         annotations: [],
         parent: null,
-    };
+    }
 }
 
 export type LionWebJsonProperty = {
-    property: LionWebJsonMetaPointer;
-    value: string;
-};
+    property: LionWebJsonMetaPointer
+    value: string
+}
 
-export type LionWebJsonChild = {
-    containment: LionWebJsonMetaPointer;
-    children: string[];
-};
+export type LionWebJsonContainment = {
+    containment: LionWebJsonMetaPointer
+    children: LionWebId[]
+}
 
 export type LionWebJsonReference = {
-    reference: LionWebJsonMetaPointer;
-    targets: LionWebJsonReferenceTarget[];
-};
+    reference: LionWebJsonMetaPointer
+    targets: LionWebJsonReferenceTarget[]
+}
 
 export type LionWebJsonReferenceTarget = {
-    resolveInfo: string;
-    reference: string;
-};
+    resolveInfo?: string
+    reference: LionWebId
+}

package/src/json/LionWebJsonChunkWrapper.ts

@@ -1,56 +1,67 @@
-import { LionWebJsonChunk, LionWebJsonNode, LionWebJsonProperty } from "./LionWebJson.js";
-import { LionWebLanguageDefinition } from "./LionWebLanguageDefinition.js";
-import { NodeUtils } from "./NodeUtils.js";
-
-export type NodeId = string;
+import {
+    isEqualMetaPointer, LION_CORE_BUILTINS_INAMED_NAME, LION_CORE_BUILTINS_KEY, LION_CORE_M3_VERSION,
+    LionWebId,
+    LionWebJsonChunk,
+    LionWebJsonContainment,
+    LionWebJsonMetaPointer,
+    LionWebJsonNode,
+    LionWebJsonProperty
+} from "./LionWebJson.js"
+import { LionWebLanguageDefinition } from "./LionWebLanguageDefinition.js"
+import { NodeUtils } from "./NodeUtils.js"
 
 /**
  * Wraps around a LionWebJsonChunk, providing access to information inside, using caches to improve performance.
+ * NB Make sure that the contents of the chunk are not changed after creating the wrapper!
  */
 export class LionWebJsonChunkWrapper {
-    jsonChunk: LionWebJsonChunk;
-    language: LionWebLanguageDefinition  | null = null;
+    jsonChunk: LionWebJsonChunk
+    language: LionWebLanguageDefinition | null = null
     /**
      * Map to get quick access to nodes by id.
      * @protected
      */
-    protected nodesIdMap: Map<NodeId, LionWebJsonNode> = new Map<NodeId, LionWebJsonNode>();
+    protected nodesIdMap: Map<LionWebId, LionWebJsonNode> = new Map<LionWebId, LionWebJsonNode>()
 
     constructor(chunk: unknown) {
-        this.jsonChunk = chunk as LionWebJsonChunk;
-        // this.prepareNodeIds();
+        this.jsonChunk = chunk as LionWebJsonChunk
+        this.prepareNodeIds()
     }
 
     /** Put all nodes in a map, validate that there are no two nodes with the same id.
      *  The check should logically be in LionWebReferenceValidator, but the created map is needed here.
      */
     prepareNodeIds() {
-        this.nodesIdMap = new Map<NodeId, LionWebJsonNode>();
-        this.jsonChunk.nodes.forEach((node) => {
-            this.nodesIdMap.set(node.id, node);
-        });
+        this.jsonChunk.nodes.forEach(node => {
+            this.nodesIdMap.set(node.id, node)
+        })
     }
 
-    getMap(): Map<NodeId, LionWebJsonNode> {
-        if (this.nodesIdMap === undefined) {
-            this.prepareNodeIds();
-        }
-        return this.nodesIdMap;
+    getNode(id: string): LionWebJsonNode | undefined {
+        return this.nodesIdMap.get(id)
     }
 
-    getNode(id: string): LionWebJsonNode | undefined {
-        return this.getMap().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);
+        return this.jsonChunk.nodes.filter(node => node.classifier.key === conceptKey)
     }
 
     allProperties(conceptNode: LionWebJsonNode): LionWebJsonProperty[] {
-        const result: LionWebJsonProperty[] = [];
-        result.push(...conceptNode.properties);
-        const extendsReference = NodeUtils.findLwReference(conceptNode, "Concept-extends");
-        if (extendsReference !==null) {
+        const result: LionWebJsonProperty[] = []
+        result.push(...conceptNode.properties)
+        const extendsReference = NodeUtils.findLwReference(conceptNode, "Concept-extends")
+        if (extendsReference !== null) {
             // extendsReference.targets.forEach(target => {
             //     // Find the extended concept
             //     if (this.language !== null) {
@@ -59,9 +70,45 @@ export class LionWebJsonChunkWrapper {
             //     }
             // });
         }
-        return result;
+        return result
     }
 
-}
-
+    asString(): string {
+        let result = ""
+        const partitions = this.jsonChunk.nodes.filter(n => n.parent === null)
+        partitions.forEach(partition => {
+            const pString = this.recursiveToString(partition, 1)
+            result += pString
+        })
+        return result
+    }
 
+    private recursiveToString(node: LionWebJsonNode | undefined, depth: number): string {
+        if (node === undefined) {
+            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 name = nameProperty === undefined ? "" : " " + nameProperty.value
+        result += Array(depth).join("    ") + "(" + node.id + ")" + name + "\n"
+        node.properties.filter(p => p !== nameProperty).forEach(property => {
+            result += Array(depth + 1).join("    ") + "*" + property.property.key + "*: " + property.value + "\n"
+        })
+        node.references.forEach(ref => {
+            result += Array(depth + 1).join("    ") + "*" + 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"
+                cont.children.forEach(ch => {
+                    result += this.recursiveToString(this.getNode(ch), depth + 1)
+                })
+            }
+        })
+        return result
+    }
+}

package/src/json/LionWebLanguageDefinition.ts

@@ -1,26 +1,22 @@
-import {
-    LION_CORE_BUILTINS_INAMED_NAME,
-    LionWebJsonMetaPointer,
-    LionWebJsonNode,
-} from "./LionWebJson.js";
-import { LionWebJsonChunkWrapper } from "./LionWebJsonChunkWrapper.js";
-import { NodeUtils } from "./NodeUtils.js";
+import { LION_CORE_BUILTINS_INAMED_NAME, LionWebJsonMetaPointer, LionWebJsonNode } from "./LionWebJson.js"
+import { LionWebJsonChunkWrapper } from "./LionWebJsonChunkWrapper.js"
+import { NodeUtils } from "./NodeUtils.js"
 
 type LanguageId = {
-    name?: string;
-    version?: string;
-    key?: string;
-};
+    name?: string
+    version?: string
+    key?: string
+}
 
-export const LIONWEB_M3_PROPERTY_KEY = "Property";
-export const LIONWEB_M3_CONCEPT_KEY = "Concept";
-export const LIONWEB_M3_INTERFACE_KEY = "Interface";
-export const LIONWEB_M3_ANNOTATION_KEY = "Annotation";
-export const LIONWEB_M3_REFERENCE_KEY = "Reference";
-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";
+export const LIONWEB_M3_PROPERTY_KEY = "Property"
+export const LIONWEB_M3_CONCEPT_KEY = "Concept"
+export const LIONWEB_M3_INTERFACE_KEY = "Interface"
+export const LIONWEB_M3_ANNOTATION_KEY = "Annotation"
+export const LIONWEB_M3_REFERENCE_KEY = "Reference"
+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
  */
@@ -57,12 +53,12 @@ export const LIONWEB_M3_PROPERTY_TYPE_KEY = "Property-type";
  * Represents a LionWeb serialiation chunk which represents a language definition / metamodel
  */
 export class LionWebLanguageDefinition {
-    languageId: LanguageId | null = null;
+    languageId: LanguageId | null = null
     /**
      * All nodes in the language
      */
-    nodeKeymap = new Map<string, LionWebJsonNode>();
-    languageChunkWrapper: LionWebJsonChunkWrapper;
+    nodeKeymap = new Map<string, LionWebJsonNode>()
+    languageChunkWrapper: LionWebJsonChunkWrapper
 
     /**
      * Assume chunk represents a language metamodel according to Lionweb M3.
@@ -70,27 +66,26 @@ export class LionWebLanguageDefinition {
      */
     constructor(chunk: LionWebJsonChunkWrapper) {
         // console.log("CHUNK " + JSON.stringify(chunk))
-        const languageNodes = chunk.findNodesOfConcept(LIONWEB_M3_LANGUAGE_KEY);
+        const languageNodes = chunk.findNodesOfConcept(LIONWEB_M3_LANGUAGE_KEY)
         if (languageNodes.length !== 1) {
             // TODO Better error handling.
-            console.error("1 Expected exactly one Language node, found " + languageNodes.length + " => " + JSON.stringify(languageNodes));
+            console.error("1 Expected exactly one Language node, found " + languageNodes.length + " => " + JSON.stringify(languageNodes))
         } else {
-            const languageNode = languageNodes[0];
-            this.setLanguage(languageNode);
+            const languageNode = languageNodes[0]
+            this.setLanguage(languageNode)
         }
-        this.languageChunkWrapper = chunk;
-
+        this.languageChunkWrapper = chunk
     }
 
     protected setLanguage(languageNode: LionWebJsonNode) {
         // Assume LwNode is a concept of type "Language"
-        const nameProp = languageNode.properties.find(prop => prop.property.key === LION_CORE_BUILTINS_INAMED_NAME);
-        const versionProp = languageNode.properties.find(prop => prop.property.key === LIONWEB_M3_LANGUAGE_VERSION_KEY);
-        const keyProp = languageNode.properties.find(prop => prop.property.key === LIONWEB_M3_IKEYED_KEY_KEY);
+        const nameProp = languageNode.properties.find(prop => prop.property.key === LION_CORE_BUILTINS_INAMED_NAME)
+        const versionProp = languageNode.properties.find(prop => prop.property.key === LIONWEB_M3_LANGUAGE_VERSION_KEY)
+        const keyProp = languageNode.properties.find(prop => prop.property.key === LIONWEB_M3_IKEYED_KEY_KEY)
         this.languageId = {
             name: nameProp?.value,
             version: versionProp?.value,
-            key: keyProp?.value
+            key: keyProp?.value,
         }
     }
 
@@ -100,26 +95,26 @@ export class LionWebLanguageDefinition {
      * @param node
      */
     setNodeByKey(key: string, node: LionWebJsonNode): void {
-        this.nodeKeymap.set(key, node);
+        this.nodeKeymap.set(key, node)
     }
 
     getNodeByKey(key: string): LionWebJsonNode | undefined {
-        return this.nodeKeymap.get(key);
+        return this.nodeKeymap.get(key)
     }
 
     getNodeByMetaPointer(metaPointer: LionWebJsonMetaPointer): LionWebJsonNode | undefined {
         // console.log("get metapointer " + JSON.stringify(metaPointer))
         const result = this.languageChunkWrapper.jsonChunk.nodes.find(n => {
             // console.log("   looking into " + JSON.stringify(n));
-            const keyProp = NodeUtils.findLwProperty(n, LIONWEB_M3_IKEYED_KEY_KEY);
+            const keyProp = NodeUtils.findLwProperty(n, LIONWEB_M3_IKEYED_KEY_KEY)
             // const versionProp = NodeUtils.findLwProperty(n, "Language-version");
 
             // return ((!!keyProp) && (keyProp.value === metaPointer.key) && (!!versionProp) && (versionProp.value === metaPointer.version));
 
             // console.log("   getNodeByMetaPointer.looking into " + node.id + " found " + JSON.stringify(keyProp));
-            return ((!!keyProp) && (keyProp.value === metaPointer.key) );
-        });
-        return result;
+            return !!keyProp && keyProp.value === metaPointer.key
+        })
+        return result
     }
 
     getPropertyByKey(key: string): LionWebJsonNode | undefined {
@@ -127,11 +122,11 @@ export class LionWebLanguageDefinition {
         const propertyNode = this.languageChunkWrapper.findNodesOfConcept(LIONWEB_M3_PROPERTY_KEY).find(n => {
             // console.log("   looking into " + JSON.stringify(n));
             const keyProp = (n as LionWebJsonNode).properties.find(prop => {
-                return prop.property.key === LIONWEB_M3_IKEYED_KEY_KEY && prop.value === key;
-            });
-            return keyProp;
-        });
-        return propertyNode;
+                return prop.property.key === LIONWEB_M3_IKEYED_KEY_KEY && prop.value === key
+            })
+            return keyProp
+        })
+        return propertyNode
     }
 
     getConceptByKey(key: string): LionWebJsonNode | undefined {
@@ -139,10 +134,10 @@ export class LionWebLanguageDefinition {
         const conceptNode = this.languageChunkWrapper.findNodesOfConcept(LIONWEB_M3_CONCEPT_KEY).find(n => {
             // console.log("   looking into " + JSON.stringify(n));
             const keyProp = n.properties.find(prop => {
-                return prop.property.key === LIONWEB_M3_IKEYED_KEY_KEY && prop.value === key;
-            });
-            return keyProp;
-        });
-        return conceptNode;
+                return prop.property.key === LIONWEB_M3_IKEYED_KEY_KEY && prop.value === key
+            })
+            return keyProp
+        })
+        return conceptNode
     }
 }

package/src/json/NodeUtils.ts

@@ -1,10 +1,10 @@
 import {
-    LionWebJsonChild,
+    LionWebJsonContainment,
     LionWebJsonNode,
     LionWebJsonProperty,
     LionWebJsonReference,
-    LionWebJsonReferenceTarget
-} from "./LionWebJson.js";
+    LionWebJsonReferenceTarget,
+} from "./LionWebJson.js"
 
 /**
  * Utility functions for LionWebJsonNode's
@@ -18,10 +18,10 @@ export class NodeUtils {
     static findLwProperty(node: LionWebJsonNode, key: string): LionWebJsonProperty | null {
         for (const property of node.properties) {
             if (property.property.key === key) {
-                return property;
+                return property
             }
         }
-        return null;
+        return null
     }
 
     /**
@@ -29,44 +29,50 @@ export class NodeUtils {
      * @param node
      * @param key
      */
-    static findLwChild(node: LionWebJsonNode, key: string): LionWebJsonChild | null {
+    static findLwChild(node: LionWebJsonNode, key: string): LionWebJsonContainment | null {
         for (const containment of node.containments) {
             if (containment.containment.key === key) {
-                return containment;
+                return containment
             }
         }
-        return null;
+        return null
     }
 
     static findLwReference(node: LionWebJsonNode, key: string): LionWebJsonReference | null {
         for (const reference of node.references) {
             if (reference.reference.key === key) {
-                return reference;
+                return reference
             }
         }
-        return null;
+        return null
     }
 
-    static findLwReferenceTarget(lwReferenceTargets: LionWebJsonReferenceTarget[], target: LionWebJsonReferenceTarget): LionWebJsonReferenceTarget | null {
+    static findLwReferenceTarget(
+        lwReferenceTargets: LionWebJsonReferenceTarget[],
+        target: LionWebJsonReferenceTarget,
+    ): LionWebJsonReferenceTarget | null {
         for (const refTarget of lwReferenceTargets) {
             if (refTarget.reference === target.reference && refTarget.resolveInfo === target.resolveInfo) {
-                return refTarget;
+                return refTarget
             }
         }
-        return null;
+        return null
     }
 
     /**
-     * Get all nodes that are children for `node`: both the containment and annotaion children
+     * Get all nodes that are children for _node_: both the containment and annotation children
      * @param node
      */
-    static allChildren(node: LionWebJsonNode): string[] {
-        const result: string[] = [];
+    static allDirectChildren(node: LionWebJsonNode): string[] {
+        const result: string[] = []
         for (const containment of node.containments) {
-            result.push(...containment.children);
+            result.push(...containment.children)
         }
-        result.push(...node.annotations);
-        return result;
+        result.push(...node.annotations)
+        return result
     }
 
+    static findContainmentContainingChild(containments: LionWebJsonContainment[], childId: string): LionWebJsonContainment | undefined {
+        return containments.find(cont => cont.children.includes(childId))
+    }
 }

package/src/json/index.ts

@@ -1,6 +1,7 @@
-export * from "./NodeUtils.js";
-export * from "./ChunkUtils.js";
-export * from "./LionWebJson.js";
-export * from "./LionWebJsonChunkWrapper.js";
-export * from "./LionWebLanguageDefinition.js";
-export * from "./LanguageUtils.js";
+export * from "./JsonContext.js"
+export * from "./NodeUtils.js"
+export * from "./ChunkUtils.js"
+export * from "./LionWebJson.js"
+export * from "./LionWebJsonChunkWrapper.js"
+export * from "./LionWebLanguageDefinition.js"
+export * from "./LanguageUtils.js"