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

package/src/languages/CompositeLionWebLanguageWrapper.ts

@@ -0,0 +1,57 @@
+import { LionWebId, LionWebJsonMetaPointer, LionWebJsonNode } from "../json/LionWebJson.js"
+import { LionWebLanguageWrapper } from "./LionWebLanguageWrapper.js"
+import { MetaPointerMap } from "./MetaPointerMap.js"
+
+/**
+ * Collection of language definitions
+ */
+export class CompositeLionWebLanguageWrapper extends LionWebLanguageWrapper {
+    metaPointerMap: MetaPointerMap = new MetaPointerMap()
+    languageMap = new Map<string, Map<string, LionWebLanguageWrapper>>()
+    languages: LionWebLanguageWrapper[] = []
+
+    addLanguage(lionWebLanguage: LionWebLanguageWrapper) {
+        let language = this.languageMap.get(lionWebLanguage.key)
+        if (language === undefined) {
+            language = new Map<string, LionWebLanguageWrapper>()
+            this.languageMap.set(lionWebLanguage.key, language)
+        }
+        const version = language.get(lionWebLanguage.version)
+        if (version === undefined) {
+            language.set(lionWebLanguage.version, lionWebLanguage)
+        } else {
+            // console.error("Language already known")
+            return
+        }
+        this.languages.push(lionWebLanguage)
+        lionWebLanguage.jsonChunk.nodes.forEach(node => {
+            this.metaPointerMap.add(lionWebLanguage.key, lionWebLanguage.version, node)
+        })
+    }
+
+    getLanguage(pointer: LionWebJsonMetaPointer): LionWebLanguageWrapper | undefined {
+        return this.languageMap.get(pointer.language)?.get(pointer.version)
+    }
+
+    /**
+     * Gets the node with _metaPointer_ in any of the known languages
+     * @param metaPointer
+     */
+    getNodeByMetaPointer(metaPointer: LionWebJsonMetaPointer): LionWebJsonNode | undefined {
+        return this.metaPointerMap.get(metaPointer)
+    }
+
+    /**
+     * Get node in any of the languages.
+     * @param nodeId
+     */
+    getNode(nodeId: LionWebId) {
+        for (const chunk of this.languages) {
+            const node = chunk.getNode(nodeId)
+            if (node !== undefined) {
+                return node
+            }
+        }
+        return undefined
+    }
+}

package/src/languages/LanguageRegistry.ts

@@ -0,0 +1,44 @@
+import { LionWebId, LionWebJsonMetaPointer, LionWebJsonNode } from "../json/LionWebJson.js"
+import { CompositeLionWebLanguageWrapper } from "./CompositeLionWebLanguageWrapper.js"
+import { LionWebLanguageWrapper } from "./LionWebLanguageWrapper.js"
+
+/**
+ * Collection of language definitions
+ */
+export class LanguageRegistry {
+    languages: CompositeLionWebLanguageWrapper = new CompositeLionWebLanguageWrapper({nodes: [], languages: [], serializationFormatVersion: "2023.1"})
+    
+    addLanguage(lionWebLanguage: LionWebLanguageWrapper) {
+        // console.log("LanguageRegistry.add: " + lionWebLanguage.name + "  " + lionWebLanguage.jsonChunk.nodes.length)
+
+        this.languages.addLanguage(lionWebLanguage)
+    }
+    
+    clear(): void {
+        this.languages = new CompositeLionWebLanguageWrapper({nodes: [], languages: [], serializationFormatVersion: "2023.1"})
+    }
+
+    getLanguage(pointer: LionWebJsonMetaPointer): LionWebLanguageWrapper | undefined {
+        return this.languages.languageMap.get(pointer.language)?.get(pointer.version)
+    }
+
+    /**
+     * Gets the node with _metaPointer_ in any of the known languages
+     * @param metaPointer
+     */
+    getNodeByMetaPointer(metaPointer: LionWebJsonMetaPointer): LionWebJsonNode | undefined {
+        return this.languages.getNodeByMetaPointer(metaPointer)
+    }
+
+    findNode(nodeId: LionWebId) {
+        for (const chunk of this.languages.languages) {
+            const node = chunk.getNode(nodeId)
+            if (node !== undefined) {
+                return node
+            }
+        }
+        return undefined
+    }
+}
+
+// export const KnownLanguages = new LanguageRegistry()

package/src/languages/LanguageUtils.ts

@@ -0,0 +1,61 @@
+import { isEqualMetaPointer, LionWebJsonNode, LionWebJsonChunk } from "../json/LionWebJson.js"
+
+import { LION_CORE_M3_KEY, MetaPointers } from "../json/M3definitions.js"
+
+import LionCore_M3 from "./LionCore-M3.json" assert { type: "json" }
+import LionCore_builtins from "./LionCore-builtins.json" assert { type: "json" }
+
+export const LionCore_M3_Json = LionCore_M3 as LionWebJsonChunk
+export const LionCore_builtins_Json = LionCore_builtins as LionWebJsonChunk
+
+export function isLionCoreLanguage(node: LionWebJsonNode) {
+    return node.classifier.language === LION_CORE_M3_KEY && node.classifier.version === "2023.1"
+}
+
+/**
+ * Does _node_ represent a language concept?
+ * @param node
+ */
+export const isConcept = (node: LionWebJsonNode): boolean => {
+    return isEqualMetaPointer(node.classifier, MetaPointers.Concept)
+}
+
+/**
+ * Does _node_ represent a language annotation?
+ * @param node
+ */
+export const isAnnotation = (node: LionWebJsonNode): boolean => {
+    return isEqualMetaPointer(node.classifier, MetaPointers.Annotation)
+}
+
+/**
+ * Does _node_ represent a language interface?
+ * @param node
+ */
+export const isInterface = (node: LionWebJsonNode): boolean => {
+    return isEqualMetaPointer(node.classifier, MetaPointers.Interface)
+}
+
+/**
+ * Does _node_ represent a language property?
+ * @param node
+ */
+export const isProperty = (node: LionWebJsonNode): boolean => {
+    return isEqualMetaPointer(node.classifier, MetaPointers.Property)
+}
+
+/**
+ * Does _node_ represent a language containment?
+ * @param node
+ */
+export const isContainment = (node: LionWebJsonNode): boolean => {
+    return isEqualMetaPointer(node.classifier, MetaPointers.Containment)
+}
+
+/**
+ * Does _node_ represent a language reference?
+ * @param node
+ */
+export const isReference = (node: LionWebJsonNode): boolean => {
+    return isEqualMetaPointer(node.classifier, MetaPointers.Reference)
+}