@lionweb/validation 0.6.1-beta.0 → 0.6.1-beta.1

package/src/validators/LionWebLanguageReferenceValidator.ts

@@ -1,30 +1,35 @@
+import {
+    Language_ContainmentMetaPointerNotInClass_Issue,
+    Language_IncorrectPropertyMetaPointer_Issue, Language_PropertyMetaPointerNotInClass_Issue,
+    Language_PropertyValue_Issue, Language_ReferenceMetaPointerNotInClass_Issue,
+    Language_UnknownConcept_Issue
+} from "../issues/index.js"
 import {
     Language_IncorrectContainmentMetaPointer_Issue,
-    Language_IncorrectPropertyMetaPointer_Issue,
     Language_IncorrectReferenceMetaPointer_Issue,
-    Language_UnknownConcept_Issue,
-    Language_UnknownContainment_Issue,
-    Language_UnknownProperty_Issue,
-    Language_UnknownReference_Issue,
+    Language_UnknownContainment_Issue, Language_UnknownProperty_Issue,
+    Language_UnknownReference_Issue
 } from "../issues/LanguageIssues.js"
+import { isEqualMetaPointer, LionWebJsonNode, MetaPointers, NodeUtils } from "../json/index.js"
 import { JsonContext } from "../json/JsonContext.js"
 import {
-    LION_CORE_BUILTINS_INAMED_NAME,
-    LIONWEB_BOOLEAN_TYPE,
-    LIONWEB_INTEGER_TYPE,
-    LIONWEB_JSON_TYPE,
-    LIONWEB_STRING_TYPE,
     LionWebJsonContainment,
     LionWebJsonProperty,
     LionWebJsonReference,
 } from "../json/LionWebJson.js"
 import { LionWebJsonChunkWrapper } from "../json/LionWebJsonChunkWrapper.js"
+// import {
+//     KnownLanguages, LanguageRegistry
+// } from "../languages/LanguageRegistry.js"
 import {
-    LIONWEB_M3_CONCEPT_KEY,
-    LIONWEB_M3_PROPERTY_KEY,
-    LIONWEB_M3_PROPERTY_TYPE_KEY,
-    LionWebLanguageDefinition,
-} from "../json/LionWebLanguageDefinition.js"
+    LION_CORE_BUILTINS_INAMED_NAME,
+    LIONWEB_BOOLEAN_TYPE,
+    LIONWEB_INTEGER_TYPE,
+    LIONWEB_JSON_TYPE,
+    LIONWEB_STRING_TYPE,
+    M3_Keys
+} from "../json/M3definitions.js"
+import { LanguageRegistry } from "../languages/index.js"
 import { SimpleFieldValidator } from "./SimpleFieldValidator.js"
 import { ValidationResult } from "./ValidationResult.js"
 
@@ -33,12 +38,10 @@ import { ValidationResult } from "./ValidationResult.js"
  */
 export class LionWebLanguageReferenceValidator {
     validationResult: ValidationResult
-    language: LionWebLanguageDefinition
     simpleFieldValidator: SimpleFieldValidator
 
-    constructor(validationResult: ValidationResult, lang: LionWebLanguageDefinition) {
+    constructor(validationResult: ValidationResult, private registry: LanguageRegistry) {
         this.validationResult = validationResult
-        this.language = lang
         this.simpleFieldValidator = new SimpleFieldValidator(this.validationResult)
     }
 
@@ -48,52 +51,65 @@ export class LionWebLanguageReferenceValidator {
 
     // TODO test reference and children implementation
     validate(obj: LionWebJsonChunkWrapper): void {
-        if (this.language === undefined || this.language === null) {
-            return
-        }
         obj.jsonChunk.nodes.forEach((node, nodeIndex) => {
             const nodeContext = new JsonContext(null, ["node", nodeIndex])
-            const jsonConcept = this.language.getNodeByMetaPointer(node.classifier)
-            if (jsonConcept === null || jsonConcept === undefined) {
+            const nodeConcept = this.registry.getNodeByMetaPointer(node.classifier)
+            if (nodeConcept === undefined && nodeContext !== undefined) {
                 this.validationResult.issue(new Language_UnknownConcept_Issue(nodeContext, node.classifier))
                 return
             }
             node.properties.forEach((property, propIndex) => {
-                this.validateProperty(property, nodeContext.concat("properties", propIndex))
+                this.validateProperty(node, nodeConcept, property, nodeContext.concat("properties", propIndex))
             })
             node.containments.forEach((containment, childIndex) => {
-                this.validateContainment(containment, nodeContext.concat("containments", childIndex))
+                this.validateContainment(node, nodeConcept, containment, nodeContext.concat("containments", childIndex))
             })
             node.references.forEach((reference, refIndex) => {
-                this.validateReference(reference, nodeContext.concat("references", refIndex))
+                this.validateReference(node, nodeConcept, reference, nodeContext.concat("references", refIndex))
             })
         })
     }
 
-    private validateContainment(child: LionWebJsonContainment, context: JsonContext) {
-        const type = this.language.getNodeByMetaPointer(child.containment)
-        if (type === null || type === undefined) {
-            this.validationResult.issue(new Language_UnknownContainment_Issue(context, child.containment))
+    private validateContainment(node: LionWebJsonNode, nodeConcept: LionWebJsonNode | undefined, containment: LionWebJsonContainment, context: JsonContext) {
+        const metaConcept = this.registry.getNodeByMetaPointer(containment.containment)
+        if (metaConcept === null || metaConcept === undefined) {
+            this.validationResult.issue(new Language_UnknownContainment_Issue(context, containment.containment))
             return
         }
-        if (type.classifier.key !== LIONWEB_M3_CONCEPT_KEY) {
-            this.validationResult.issue(new Language_IncorrectContainmentMetaPointer_Issue(context, child.containment, type.classifier.key))
+        if (metaConcept.classifier.key !== M3_Keys.Containment) {
+            this.validationResult.issue(new Language_IncorrectContainmentMetaPointer_Issue(context, containment.containment, metaConcept.classifier.key))
+        }
+        if (nodeConcept !== undefined) {
+            const cons = this.registry.languages.allContainments(nodeConcept)
+            if (!cons.includes(metaConcept)) {
+                this.validationResult.issue(new Language_ContainmentMetaPointerNotInClass_Issue(context, containment.containment, nodeConcept))
+                return
+            }
         }
         // TODO check type of children
     }
 
-    private validateReference(ref: LionWebJsonReference, context: JsonContext) {
-        const type = this.language.getNodeByMetaPointer(ref.reference)
-        if (type === null || type === undefined) {
+    private validateReference(node: LionWebJsonNode, nodeConcept: LionWebJsonNode | undefined, ref: LionWebJsonReference, context: JsonContext) {
+        const referenceDefinition = this.registry.getNodeByMetaPointer(ref.reference)
+        if (referenceDefinition === null || referenceDefinition === undefined) {
             this.validationResult.issue(new Language_UnknownReference_Issue(context, ref.reference))
             return
         }
-        if (type.classifier.key !== LIONWEB_M3_CONCEPT_KEY) {
-            this.validationResult.issue(new Language_IncorrectReferenceMetaPointer_Issue(context, ref.reference, type.classifier.key))
+        if (referenceDefinition.classifier.key !== M3_Keys.Reference) {
+            this.validationResult.issue(new Language_IncorrectReferenceMetaPointer_Issue(context, ref.reference, referenceDefinition.classifier.key))
+        }
+        if (nodeConcept !== undefined) {
+            const refs = this.registry.languages.allReferenceDefinitions(nodeConcept)
+            if (!refs.includes(referenceDefinition)) {
+                this.validationResult.issue(new Language_ReferenceMetaPointerNotInClass_Issue(context, ref.reference, nodeConcept))
+                return
+            }
         }
+
         // TODO Check type of reference (if possible)
 
         // TODO Check for duplicate targets?
+        // No, already done without language check
         // If so, what to check because there can be either or both a `resolveInfo` and a `reference`
     }
 
@@ -101,28 +117,35 @@ export class LionWebLanguageReferenceValidator {
      * Checks wwhether the value of `prop1` is correct in relation with its property definition in the referred language.
      * @param prop
      */
-    validateProperty(prop: LionWebJsonProperty, context: JsonContext): void {
+    validateProperty(node: LionWebJsonNode, nodeConcept: LionWebJsonNode | undefined, prop: LionWebJsonProperty, context: JsonContext): void {
         if (prop.value === null) {
             return
         }
-        const type = this.language.getNodeByMetaPointer(prop.property)
-        if (type === null || type === undefined) {
+        const propertyDefinition = this.registry.getNodeByMetaPointer(prop.property)
+        if ( propertyDefinition === undefined) {
             this.validationResult.issue(new Language_UnknownProperty_Issue(context, prop.property))
             return
         }
-        if (type.classifier.key !== LIONWEB_M3_PROPERTY_KEY) {
-            this.validationResult.issue(new Language_IncorrectPropertyMetaPointer_Issue(context, prop.property, type.classifier.key))
+        if (propertyDefinition.classifier.key !== M3_Keys.Property) {
+            this.validationResult.issue(new Language_IncorrectPropertyMetaPointer_Issue(context, prop.property, propertyDefinition.classifier.key))
             return
         }
-        // TODO check for property to exist inside the concept in the language
-        //      Need to find inherited and implemented properties as well: complex!
-
-        const refType = type.references.find(ref => ref.reference.key === LIONWEB_M3_PROPERTY_TYPE_KEY)
-        const propertyName = type.properties.find(p => p.property.key === LION_CORE_BUILTINS_INAMED_NAME)?.value
+        if (nodeConcept !== undefined) {
+            const props = this.registry.languages.allProperties(nodeConcept)
+            if (!props.includes(propertyDefinition)) {
+                this.validationResult.issue(new Language_PropertyMetaPointerNotInClass_Issue(context, prop.property, nodeConcept))
+                return
+            }
+        }
+        
+        const refType = NodeUtils.findReference(propertyDefinition, MetaPointers.PropertyType)
+        // const refType = propertyDefinition.references.find(ref => isEqualMetaPointer(ref.reference, MetaPointers.PropertyType))
+        const propertyName = propertyDefinition.properties.find(p => p.property.key === LION_CORE_BUILTINS_INAMED_NAME)?.value
         // console.log("Fount type should be " + refType.targets[0].reference);
         if (propertyName !== undefined) {
             if (refType !== null && refType !== undefined) {
-                switch (refType.targets[0].reference) {
+                const typeReferenceId = refType.targets[0].reference
+                switch (typeReferenceId) {
                     case LIONWEB_BOOLEAN_TYPE:
                         this.simpleFieldValidator.validateBoolean(prop, propertyName, context)
                         break
@@ -130,10 +153,49 @@ export class LionWebLanguageReferenceValidator {
                         this.simpleFieldValidator.validateInteger(prop, propertyName, context)
                         break
                     case LIONWEB_STRING_TYPE:
+                        // Each string is correct and having another JSOn type is already captured
                         break
                     case LIONWEB_JSON_TYPE:
                         this.simpleFieldValidator.validateJSON(prop, propertyName, context)
                         break
+                    default: {
+                        // Check for enumeration
+                        // console.log("validateProperty: 0")
+                        const propTypeReference = NodeUtils.findReference(propertyDefinition, MetaPointers.PropertyType)
+                        if (propTypeReference === undefined) {
+                            // console.log("validateProperty: 1")
+                            break
+                        }
+                        const propType =  this.registry.findNode(propTypeReference.targets[0].reference)
+                        if (propType === undefined) {
+                            // console.log("validateProperty: 1.4 for " + prop.value + " ==> " + propTypeReference.targets[0].reference)
+                            break
+                        }
+                        let match = false
+                        if (isEqualMetaPointer(propType.classifier, MetaPointers.Enumeration)) {
+                            const literalsContainment = NodeUtils.findContainment(propType, MetaPointers.EnumerationLiterals)
+                            if (literalsContainment === undefined) {
+                                // console.log("validateProperty: 2")
+                                break;
+                            }
+                            const literals = literalsContainment.children.map(child => this.registry.findNode(child))
+                            match = literals.some(lit => {
+                                if (lit === undefined) {
+                                    // console.log("validateProperty: 3")
+                                    return false
+                                }
+                                const litKeyProp = NodeUtils.findProperty(lit, MetaPointers.IKeyedKey)
+                                if (litKeyProp === undefined) {
+                                    // console.log("validateProperty: 4")
+                                    return false
+                                }
+                                return prop.value === litKeyProp.value
+                            })
+                        }
+                        if (!match) {
+                            this.validationResult.issue(new Language_PropertyValue_Issue(context, prop.property.key, prop.value, propType.classifier.key))
+                        }
+                    }
                 }
             } else {
                 // TODO refType not found, but

package/src/validators/LionWebLanguageValidator.ts

@@ -1,39 +1,80 @@
-import { IncorrectLionCoreVersion_Issue, NotLionCoreLanguageKey_Issue, NumberOfLanguagesUsed_Issue } from "../issues/LanguageIssues.js"
+import { GenericIssue } from "../issues/index.js"
+import { MissingM3Language_Issue } from "../issues/LanguageIssues.js"
+import { isEqualMetaPointer, LionWebJsonNode, MetaPointers } from "../json/index.js"
 import { JsonContext } from "../json/JsonContext.js"
-import { LionWebJsonChunk } from "../json/LionWebJson.js"
+import { isLionWebM3Language, LionWebJsonChunk } from "../json/LionWebJson.js"
 import { LionWebJsonChunkWrapper } from "../json/LionWebJsonChunkWrapper.js"
+import { isConcept, LanguageRegistry } from "../languages/index.js"
 import { ValidationResult } from "./ValidationResult.js"
 
+/**
+ * Validates whether a chunk is a valid language definition
+ */
 export class LionWebLanguageValidator {
     validationResult: ValidationResult
+    chunkWrapper: LionWebJsonChunkWrapper | undefined
+    // availableLanguages: LionWebLanguageDefinition[] = []
 
-    constructor() {
-        this.validationResult = new ValidationResult()
+    constructor(validationResult: ValidationResult, private registry: LanguageRegistry) {
+        this.validationResult = validationResult
+        this.chunkWrapper = undefined
     }
 
     /**
-     * check JSON as in `check`, but also check whether the metamoddel is a Language.
+     * Check whether the metamodel is a Language.
+     * Assumption is that _chunk_ is already validated as a correct :LionWebJsonChunk
      * @param obj
      */
-    checkLanguage(chunk: LionWebJsonChunk) {
-        // TODO Vaalidate syntax first via LionWebSyntaxValidator !!!
-        if (chunk.languages.length !== 1) {
-            // Check whether the LionCore M3 is the only used language, then this is a language model.
-            this.validationResult.issue(new NumberOfLanguagesUsed_Issue(new JsonContext(null, ["languages"]), chunk.languages.length))
-            return
-        }
-        const usedLanguage = chunk.languages[0]
-        if (usedLanguage.key !== "LionCore-M3") {
-            this.validationResult.issue(new NotLionCoreLanguageKey_Issue(new JsonContext(null, ["languages", 0]), usedLanguage.key))
-        }
-        if (usedLanguage.version !== "1") {
-            this.validationResult.issue(new IncorrectLionCoreVersion_Issue(new JsonContext(null, ["languages", 0]), usedLanguage.version))
+    validateLanguage(chunk: LionWebJsonChunk) {
+        this.chunkWrapper = new LionWebJsonChunkWrapper(chunk)
+        const usedM3Language = chunk.languages.find(lang => isLionWebM3Language(lang))
+        if (usedM3Language === undefined) {
+            this.validationResult.issue(new MissingM3Language_Issue(new JsonContext(null, ["languages"])))
         }
-        const chunkWrapper = new LionWebJsonChunkWrapper(chunk)
-        const languageNodes = chunkWrapper.findNodesOfConcept("Language")
+
+        const languageNodes = this.chunkWrapper.findNodesOfClassifier(MetaPointers.Language)
         if (languageNodes.length !== 1) {
             // TODO Better error handling.
-            console.error("Expected exactly one Language node, found " + languageNodes.length + " => " + JSON.stringify(languageNodes))
+            console.error("Error: xpected exactly one Language node, found " + languageNodes.length + " => " + JSON.stringify(languageNodes))
         }
+        chunk.nodes.forEach((node, index) => {
+            if (!isConcept(node)) {
+                this.validationResult.issue(new GenericIssue(new JsonContext(null, ["nodes", index]), `node ${node.id} is not a concept`))
+            } else {
+                this.validateConcept(node)
+            }
+        })
+    }
+
+    validateConcept(node: LionWebJsonNode): void {
+        node.properties.forEach(prop => {
+            const properties = this.chunkWrapper?.findNodesOfClassifier(MetaPointers.Property)
+            const matchedProperty = properties?.find(p => isEqualMetaPointer(p.classifier, prop.property))
+            // DUMMY
+            return matchedProperty !== undefined
+        })
+    }
+
+    validateNode(node: LionWebJsonNode): void {
+        const classifier = this.registry.getNodeByMetaPointer(node.classifier)
+        if (classifier === undefined) {
+            this.validationResult.issue(
+                new GenericIssue(new JsonContext(null, ["nodes"]), `Classifier ${node.classifier.key} not found for node ${node.id}`)
+            )
+            return
+        }
+        this.validateProperties(node, classifier)
+    }
+    
+    validateProperties(node: LionWebJsonNode, classifier: LionWebJsonNode): void {
+        node.properties.forEach(actualProp => {
+            const propClassifier = this.registry.getNodeByMetaPointer(actualProp.property)
+            if (propClassifier === undefined) {
+                this.validationResult.issue(
+                    new GenericIssue(new JsonContext(null, ["nodes", "properties"]), 
+                        `Property ${actualProp.property.key} not found for classifier ${classifier.id}`)
+                )
+            }
+        })
     }
 }

package/src/validators/LionWebReferenceValidator.ts

@@ -9,7 +9,6 @@ import {
 import { JsonContext } from "../json/JsonContext.js"
 import { ChunkUtils } from "../json/ChunkUtils.js"
 import {
-    LION_CORE_BUILTINS_KEY,
     LionWebJsonContainment,
     LionWebJsonChunk,
     LionWebJsonMetaPointer,
@@ -106,10 +105,6 @@ export class LionWebReferenceValidator {
      */
     validateLanguageReference(chunk: LionWebJsonChunkWrapper, metaPointer: LionWebJsonMetaPointer, context: JsonContext) {
         const lang = ChunkUtils.findLwUsedLanguageWithVersion(chunk.jsonChunk, metaPointer.language, metaPointer.version)
-        if (metaPointer.language === LION_CORE_BUILTINS_KEY) {
-            // Ok, builtin
-            return
-        }
         if (lang === undefined || lang === null) {
             this.validationResult.issue(new Reference_LanguageUnknown_Issue(context, metaPointer))
         } else {

package/src/validators/LionWebSyntaxValidator.ts

@@ -41,7 +41,7 @@ const MAY_BE_NULL = true
 const NOT_NULL = false
 
 /**
- * LionWebCheck can chack whether objects are LionWeb JSON objects.
+ * LionWebCheck can check whether objects are structurally LionWeb JSON objects.
  * The check can be on a single object, or recursively on an object and its children.
  */
 export class LionWebSyntaxValidator {
@@ -62,7 +62,7 @@ export class LionWebSyntaxValidator {
     /**
      * Check whether `obj` is a JSON object that conforms to the serialization syntax of LionCore.
      * All errors found will be pushed into the `errors` array, if its length is not 0, the check has failed.
-     * @param obj
+     * @param obj 
      */
     validate(obj: unknown) {
         this.validateLwChunk(obj, new JsonContext(null, ["$"]))

package/src/validators/LionWebValidator.ts

@@ -1,6 +1,6 @@
 import { LionWebJsonChunk } from "../json/LionWebJson.js"
 import { LionWebJsonChunkWrapper } from "../json/LionWebJsonChunkWrapper.js"
-import { LionWebLanguageDefinition } from "../json/LionWebLanguageDefinition.js"
+import { LanguageRegistry } from "../languages/index.js"
 import { LionWebLanguageReferenceValidator } from "./LionWebLanguageReferenceValidator.js"
 import { LionWebReferenceValidator } from "./LionWebReferenceValidator.js"
 import { LionWebSyntaxValidator } from "./LionWebSyntaxValidator.js"
@@ -12,7 +12,6 @@ import { ValidationResult } from "./ValidationResult.js"
  */
 export class LionWebValidator {
     object: unknown
-    language: LionWebLanguageDefinition | null = null
 
     chunk: unknown
     validationResult: ValidationResult
@@ -21,9 +20,8 @@ export class LionWebValidator {
     syntaxCorrect: boolean = false
     referencesCorrect: boolean = false
 
-    constructor(json: unknown, lang: LionWebLanguageDefinition | null) {
+    constructor(json: unknown, private registry: LanguageRegistry) {
         this.object = json
-        this.language = lang
         this.validationResult = new ValidationResult()
         this.syntaxValidator = new LionWebSyntaxValidator(this.validationResult)
         this.referenceValidator = new LionWebReferenceValidator(this.validationResult)
@@ -63,11 +61,9 @@ export class LionWebValidator {
             // console.log("validateForLanguage not executed because there are reference errors.")
             return
         }
-        if (this.language !== null && this.language !== undefined) {
-            const languageReferenceValidator = new LionWebLanguageReferenceValidator(this.validationResult, this.language)
-            // when syntax is correct we know the chunk is actually a chunk!
-            languageReferenceValidator.validate(this.chunk as LionWebJsonChunkWrapper)
-        }
+        const languageReferenceValidator = new LionWebLanguageReferenceValidator(this.validationResult, this.registry)
+        // when syntax is correct we know the chunk is actually a chunk!
+        languageReferenceValidator.validate(this.chunk as LionWebJsonChunkWrapper)
     }
 
     // setLanguage(json: LionwebLanguageDefinition) {

package/structure.puml

@@ -0,0 +1,25 @@
+@startuml
+skinparam linetype ortho
+
+class LionWebChunkWrapper {
+}
+
+class LionWebLanguageWrapper {
+    superClassifiers(...): Classifier[]
+    allSuperClassifiers(...): Classifier[]
+    properties(...): Property[]
+    allProperties(...): Property[]
+    ...()
+}
+
+class CompositeLionWebLanguageWrapper {
+}
+
+class LanguageRegistry {
+}
+
+LionWebChunkWrapper <|-- LionWebLanguageWrapper
+LionWebLanguageWrapper <|-- CompositeLionWebLanguageWrapper
+CompositeLionWebLanguageWrapper --> "0..*" LionWebLanguageWrapper
+LanguageRegistry --> "1" CompositeLionWebLanguageWrapper
+@enduml

package/dist/json/LanguageUtils.d.ts

@@ -1,9 +0,0 @@
-import { LionWebJsonChunk } from "./LionWebJson.js";
-import { LionWebJsonChunkWrapper } from "./LionWebJsonChunkWrapper.js";
-/**
- * Contains methods for getting information from a LionWebJsonChunk representing a language.
- */
-export declare class LanguageWrapper extends LionWebJsonChunkWrapper {
-    constructor(languageJson: LionWebJsonChunk);
-}
-//# sourceMappingURL=LanguageUtils.d.ts.map

package/dist/json/LanguageUtils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"LanguageUtils.d.ts","sourceRoot":"","sources":["../../src/json/LanguageUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AACnD,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAA;AAEtE;;GAEG;AACH,qBAAa,eAAgB,SAAQ,uBAAuB;gBAC5C,YAAY,EAAE,gBAAgB;CAuB7C"}

package/dist/json/LanguageUtils.js

@@ -1,30 +0,0 @@
-import { LionWebJsonChunkWrapper } from "./LionWebJsonChunkWrapper.js";
-/**
- * Contains methods for getting information from a LionWebJsonChunk representing a language.
- */
-export class LanguageWrapper extends LionWebJsonChunkWrapper {
-    constructor(languageJson) {
-        super(languageJson);
-    }
-}
-//
-// function isLionCoreLanguage(node: LionWebJsonNode) {
-//     return node.classifier.language === LION_CORE_M3_KEY
-//         && node.classifier.version === "2023.1";
-// }
-//
-// const isConcept = (node: LionWebJsonNode): boolean => {
-//     return isLionCoreLanguage(node)
-//         && node.classifier.key === LIONWEB_M3_CONCEPT_KEY;
-// }
-//
-// const isAnnotation = (node: LionWebJsonNode): boolean => {
-//     return isLionCoreLanguage(node)
-//         && node.classifier.key === LIONWEB_M3_ANNOTATION_KEY;
-// }
-//
-// const isInterface = (node: LionWebJsonNode): boolean => {
-//     return isLionCoreLanguage(node)
-//         && node.classifier.key === LIONWEB_M3_INTERFACE_KEY;
-// }
-//# sourceMappingURL=LanguageUtils.js.map

package/dist/json/LanguageUtils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"LanguageUtils.js","sourceRoot":"","sources":["../../src/json/LanguageUtils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAA;AAEtE;;GAEG;AACH,MAAM,OAAO,eAAgB,SAAQ,uBAAuB;IACxD,YAAY,YAA8B;QACtC,KAAK,CAAC,YAAY,CAAC,CAAA;IACvB,CAAC;CAqBJ;AAED,EAAE;AACF,uDAAuD;AACvD,2DAA2D;AAC3D,mDAAmD;AACnD,IAAI;AACJ,EAAE;AACF,0DAA0D;AAC1D,sCAAsC;AACtC,6DAA6D;AAC7D,IAAI;AACJ,EAAE;AACF,6DAA6D;AAC7D,sCAAsC;AACtC,gEAAgE;AAChE,IAAI;AACJ,EAAE;AACF,4DAA4D;AAC5D,sCAAsC;AACtC,+DAA+D;AAC/D,IAAI"}

package/dist/json/LionWebLanguageDefinition.d.ts

@@ -1,48 +0,0 @@
-import { LionWebJsonMetaPointer, LionWebJsonNode } from "./LionWebJson.js";
-import { LionWebJsonChunkWrapper } from "./LionWebJsonChunkWrapper.js";
-type LanguageId = {
-    name?: string;
-    version?: string;
-    key?: string;
-};
-export declare const LIONWEB_M3_PROPERTY_KEY = "Property";
-export declare const LIONWEB_M3_CONCEPT_KEY = "Concept";
-export declare const LIONWEB_M3_INTERFACE_KEY = "Interface";
-export declare const LIONWEB_M3_ANNOTATION_KEY = "Annotation";
-export declare const LIONWEB_M3_REFERENCE_KEY = "Reference";
-export declare const LIONWEB_M3_LANGUAGE_KEY = "Language";
-export declare const LIONWEB_M3_LANGUAGE_VERSION_KEY = "Language-version";
-export declare const LIONWEB_M3_IKEYED_KEY_KEY = "IKeyed-key";
-export declare const LIONWEB_M3_PROPERTY_TYPE_KEY = "Property-type";
-/**
- * Collection of language definitions
- */
-/**
- * Represents a LionWeb serialiation chunk which represents a language definition / metamodel
- */
-export declare class LionWebLanguageDefinition {
-    languageId: LanguageId | null;
-    /**
-     * All nodes in the language
-     */
-    nodeKeymap: Map<string, LionWebJsonNode>;
-    languageChunkWrapper: LionWebJsonChunkWrapper;
-    /**
-     * Assume chunk represents a language metamodel according to Lionweb M3.
-     * @param chunk
-     */
-    constructor(chunk: LionWebJsonChunkWrapper);
-    protected setLanguage(languageNode: LionWebJsonNode): void;
-    /**
-     * Store the node `node` under `key`.
-     * @param key
-     * @param node
-     */
-    setNodeByKey(key: string, node: LionWebJsonNode): void;
-    getNodeByKey(key: string): LionWebJsonNode | undefined;
-    getNodeByMetaPointer(metaPointer: LionWebJsonMetaPointer): LionWebJsonNode | undefined;
-    getPropertyByKey(key: string): LionWebJsonNode | undefined;
-    getConceptByKey(key: string): LionWebJsonNode | undefined;
-}
-export {};
-//# sourceMappingURL=LionWebLanguageDefinition.d.ts.map

package/dist/json/LionWebLanguageDefinition.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"LionWebLanguageDefinition.d.ts","sourceRoot":"","sources":["../../src/json/LionWebLanguageDefinition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkC,sBAAsB,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAC1G,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAA;AAGtE,KAAK,UAAU,GAAG;IACd,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,GAAG,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AAED,eAAO,MAAM,uBAAuB,aAAa,CAAA;AACjD,eAAO,MAAM,sBAAsB,YAAY,CAAA;AAC/C,eAAO,MAAM,wBAAwB,cAAc,CAAA;AACnD,eAAO,MAAM,yBAAyB,eAAe,CAAA;AACrD,eAAO,MAAM,wBAAwB,cAAc,CAAA;AACnD,eAAO,MAAM,uBAAuB,aAAa,CAAA;AACjD,eAAO,MAAM,+BAA+B,qBAAqB,CAAA;AACjE,eAAO,MAAM,yBAAyB,eAAe,CAAA;AACrD,eAAO,MAAM,4BAA4B,kBAAkB,CAAA;AAE3D;;GAEG;AA8BH;;GAEG;AACH,qBAAa,yBAAyB;IAClC,UAAU,EAAE,UAAU,GAAG,IAAI,CAAO;IACpC;;OAEG;IACH,UAAU,+BAAqC;IAC/C,oBAAoB,EAAE,uBAAuB,CAAA;IAE7C;;;OAGG;gBACS,KAAK,EAAE,uBAAuB;IAa1C,SAAS,CAAC,WAAW,CAAC,YAAY,EAAE,eAAe;IAYnD;;;;OAIG;IACH,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,eAAe,GAAG,IAAI;IAItD,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;IAItD,oBAAoB,CAAC,WAAW,EAAE,sBAAsB,GAAG,eAAe,GAAG,SAAS;IAetF,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;IAY1D,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;CAW5D"}