@lionweb/validation 0.6.13-beta.6 → 0.6.13-beta.7

package/src/json/M3definitions.ts

@@ -0,0 +1,177 @@
+/**
+ * This file contains LionWeb defined M3 keys and identifications.
+ */
+export const LION_CORE_BUILTINS_INAMED_NAME = "LionCore-builtins-INamed-name"
+export const LION_CORE_BUILTINS_KEY = "LionCore-builtins"
+
+export const LION_CORE_M3_KEY = "LionCore-M3"
+export const LION_CORE_M3_NAME = "LionCore_M3"
+
+export const LION_CORE_M3_VERSION = "2023.1"
+// Builtin datatypes
+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 M3_Keys = {
+    Property: "Property",
+    Reference: "Reference",
+    Concept: "Concept",
+    conceptExtends: "Concept-extends",
+    conceptImplements: "Concept-implements",
+    concept2: {
+        key: "Concept",
+        extends: { key: "Concept-extends" },
+        implements: { key: "Concept-implements" }
+    },
+    conceptAbstract: "Concept-abstract",
+    conceptPartition: "Concept-partition",
+    classifierFeatures: "Classifier-features",
+    Interface: "Interface",
+    InterfaceExtends: "Interface-extends",
+    Containment: "Containment",
+    Language: "Language",
+    languageVersion: "Language-version",
+    IKeyedKey: "IKeyed-key",
+    PropertyType: "Property-type",
+    Enumeration: "Enumeration",
+    EnumerationLiterals: "Enumeration-literals",
+    EnumerationLiteral: "EnumerationLiteral",
+    INamed: "LionCore-builtins-INamed",
+    INamedName: "LionCore-builtins-INamed-name",
+    Annotation: "Annotation",
+    AnnotationAnnotates: "Annotation-annotates",
+    AnnotationExtends: "Annotation-extends",
+    AnnotationImplements: "Annotation-implements",
+    Node: "LionCore-builtins-Node"
+}
+
+export const MetaPointers = {
+    Language: {
+        version: LION_CORE_M3_VERSION,
+        language: LION_CORE_M3_KEY,
+        key: M3_Keys.Language
+    },
+    LanguageVersion: {
+        version: LION_CORE_M3_VERSION,
+        language: LION_CORE_M3_KEY,
+        key: M3_Keys.languageVersion
+    },
+    ClassifierFeatures: {
+        version: LION_CORE_M3_VERSION,
+        language: LION_CORE_M3_KEY,
+        key: M3_Keys.classifierFeatures
+    },
+    Concept: {
+        version: LION_CORE_M3_VERSION,
+        language: LION_CORE_M3_KEY,
+        key: M3_Keys.concept2.key
+    },
+    ConceptAbstract: {
+        version: LION_CORE_M3_VERSION,
+        language: LION_CORE_M3_KEY,
+        key: M3_Keys.conceptAbstract
+    },
+    ConceptPartition: {
+        version: LION_CORE_M3_VERSION,
+        language: LION_CORE_M3_KEY,
+        key: M3_Keys.conceptPartition
+    },
+    ConceptExtends: {
+        version: LION_CORE_M3_VERSION,
+        language: LION_CORE_M3_KEY,
+        key: M3_Keys.concept2.extends.key
+    },
+    ConceptImplements: {
+        version: LION_CORE_M3_VERSION,
+        language: LION_CORE_M3_KEY,
+        key: M3_Keys.concept2.implements.key
+    },
+    Annotation: {
+        version: LION_CORE_M3_VERSION,
+        language: LION_CORE_M3_KEY,
+        key: M3_Keys.Annotation
+    },
+    AnnotationAnnotates: {
+        version: LION_CORE_M3_VERSION,
+        language: LION_CORE_M3_KEY,
+        key: M3_Keys.AnnotationAnnotates
+    },
+    AnnotationExtends: {
+        version: LION_CORE_M3_VERSION,
+        language: LION_CORE_M3_KEY,
+        key: M3_Keys.AnnotationExtends
+    },
+    AnnotationImplements: {
+        version: LION_CORE_M3_VERSION,
+        language: LION_CORE_M3_KEY,
+        key: M3_Keys.AnnotationImplements
+    },
+    Interface: {
+        version: LION_CORE_M3_VERSION,
+        language: LION_CORE_M3_KEY,
+        key: M3_Keys.Interface
+    },
+    InterfaceExtends: {
+        version: LION_CORE_M3_VERSION,
+        language: LION_CORE_M3_KEY,
+        key: M3_Keys.InterfaceExtends
+    },
+    Enumeration: {
+        version: LION_CORE_M3_VERSION,
+        language: LION_CORE_M3_KEY,
+        key: M3_Keys.Enumeration
+    },
+    EnumerationLiteral: {
+        version: LION_CORE_M3_VERSION,
+        language: LION_CORE_M3_KEY,
+        key: M3_Keys.EnumerationLiteral
+    },
+    EnumerationLiterals: {
+        version: LION_CORE_M3_VERSION,
+        language: LION_CORE_M3_KEY,
+        key: M3_Keys.EnumerationLiterals
+    },
+    Containment: {
+        version: LION_CORE_M3_VERSION,
+        language: LION_CORE_M3_KEY,
+        key: M3_Keys.Containment
+    },
+    Property: {
+        version: LION_CORE_M3_VERSION,
+        language: LION_CORE_M3_KEY,
+        key: M3_Keys.Property
+    },
+    PropertyType: {
+        version: LION_CORE_M3_VERSION,
+        language: LION_CORE_M3_KEY,
+        key: M3_Keys.PropertyType
+    },
+    Reference: {
+        version: LION_CORE_M3_VERSION,
+        language: LION_CORE_M3_KEY,
+        key: M3_Keys.Reference
+    },
+    IKeyedKey: {
+        language: LION_CORE_M3_KEY,
+        version: LION_CORE_M3_VERSION,
+        key: M3_Keys.IKeyedKey
+    },
+    // Builtins:
+    Node: {
+        language: LION_CORE_BUILTINS_KEY,
+        version: LION_CORE_M3_VERSION,
+        key: M3_Keys.Node
+    },
+    INamed: {
+        language: LION_CORE_BUILTINS_KEY,
+        version: LION_CORE_M3_VERSION,
+        key: M3_Keys.INamed
+    },
+    INamedName: {
+        language: LION_CORE_BUILTINS_KEY,
+        version: LION_CORE_M3_VERSION,
+        key: M3_Keys.INamedName
+    }
+}

package/src/json/NodeUtils.ts

@@ -0,0 +1,75 @@
+import {
+    isEqualMetaPointer,
+    isEqualReferenceTarget,
+    LionWebJsonContainment, LionWebJsonMetaPointer,
+    LionWebJsonNode,
+    LionWebJsonProperty,
+    LionWebJsonReference,
+    LionWebJsonReferenceTarget
+} from "./LionWebJson.js"
+
+/**
+ * Utility functions for LionWebJsonNode's
+ */
+export class NodeUtils {
+    /**
+     * Find property with key equals `key` in `node`.
+     * @param node
+     * @param key
+     */
+    static findProperty(node: LionWebJsonNode, property: LionWebJsonMetaPointer): LionWebJsonProperty | undefined {
+        if (node === undefined) {
+            return undefined
+        }
+        return node.properties.find(
+            prop => isEqualMetaPointer(prop.property, property)
+        )
+    }
+
+    /**
+     * Find containment child with key equals `key` in `node`.
+     * @param node
+     * @param key
+     */
+    static findChild(node: LionWebJsonNode, key: string): LionWebJsonContainment | undefined {
+        if (node === undefined) {
+            return undefined
+        }
+        for (const containment of node.containments) {
+            if (containment.containment.key === key) {
+                return containment
+            }
+        }
+        return undefined
+    }
+
+    static findContainment(node: LionWebJsonNode, containment: LionWebJsonMetaPointer): LionWebJsonContainment | undefined {
+        if (node === undefined) {
+            return undefined
+        }
+        return node.containments.find(cont => isEqualMetaPointer(cont.containment, containment))
+    }
+
+    static findReference(node: LionWebJsonNode, reference: LionWebJsonMetaPointer): LionWebJsonReference | undefined {
+        if (node === undefined) {
+            return undefined
+        }
+        return node.references.find(ref => isEqualMetaPointer(ref.reference, reference))
+    }
+
+    static findReferenceTarget(
+        referenceTargets: LionWebJsonReferenceTarget[],
+        target: LionWebJsonReferenceTarget,
+    ): LionWebJsonReferenceTarget | undefined {
+        for (const refTarget of referenceTargets) {
+            if (isEqualReferenceTarget(refTarget, target)) {
+                return refTarget
+            }
+        }
+        return undefined
+    }
+    
+    static findContainmentContainingChild(containments: LionWebJsonContainment[], childId: string): LionWebJsonContainment | undefined {
+        return containments.find(cont => cont.children.includes(childId))
+    }
+}

package/src/json/index.ts

@@ -0,0 +1,6 @@
+export * from "./JsonContext.js"
+export * from "./NodeUtils.js"
+export * from "./ChunkUtils.js"
+export * from "./LionWebJson.js"
+export * from "./LionWebJsonChunkWrapper.js"
+export * from "./M3definitions.js"

package/src/languages/CompositeLionWebLanguageWrapper.ts

@@ -1,4 +1,4 @@
-import { LionWebId, LionWebJsonMetaPointer, LionWebJsonNode } from "@lionweb/json"
+import { LionWebId, LionWebJsonMetaPointer, LionWebJsonNode } from "../json/LionWebJson.js"
 import { LionWebLanguageWrapper } from "./LionWebLanguageWrapper.js"
 import { MetaPointerMap } from "./MetaPointerMap.js"
 

package/src/languages/LanguageRegistry.ts

@@ -1,4 +1,4 @@
-import { LionWebId, LionWebJsonMetaPointer, LionWebJsonNode } from "@lionweb/json"
+import { LionWebId, LionWebJsonMetaPointer, LionWebJsonNode } from "../json/LionWebJson.js"
 import { CompositeLionWebLanguageWrapper } from "./CompositeLionWebLanguageWrapper.js"
 import { LionWebLanguageWrapper } from "./LionWebLanguageWrapper.js"
 

package/src/languages/LanguageUtils.ts

@@ -1,11 +1,11 @@
-import { isEqualMetaPointer, LionWebJsonChunk, LionWebJsonNode } from "@lionweb/json"
-import { LION_CORE_M3_KEY, MetaPointers } from "@lionweb/json-utils"
+import { isEqualMetaPointer, LionWebJsonNode, LionWebJsonChunk } from "../json/LionWebJson.js"
+import { LION_CORE_M3_KEY, MetaPointers } from "../json/M3definitions.js"
 
-import { createRequire } from "module"
+import { createRequire } from 'module';
 
-const require = createRequire(import.meta.url)
-const LionCore_M3 = require("./LionCore-M3.json")
-const LionCore_builtins = require("./LionCore-builtins.json")
+const require = createRequire(import.meta.url);
+const LionCore_M3 = require('./LionCore-M3.json');
+const LionCore_builtins = require('./LionCore-builtins.json');
 
 export const LionCore_M3_Json = LionCore_M3 as LionWebJsonChunk
 export const LionCore_builtins_Json = LionCore_builtins as LionWebJsonChunk

package/src/languages/LionWebLanguageWrapper.ts

@@ -1,6 +1,10 @@
-import { LionWebJsonChunk, LionWebJsonNode, LionWebKey } from "@lionweb/json"
-import { LionWebJsonChunkWrapper, MetaPointers, NodeUtils } from "@lionweb/json-utils"
-import { visitAndMap } from "@lionweb/ts-utils"
+import {
+    LionWebJsonChunkWrapper,
+    MetaPointers,
+    NodeUtils
+} from "../json/index.js"
+import { LionWebJsonChunk, LionWebJsonNode } from "../json/LionWebJson.js"
+import { visitAndMap } from "../util/graphs.js"
 import { isAnnotation, isConcept, isContainment, isInterface, isProperty, isReference } from "./LanguageUtils.js"
 
 interface LionWebLanguageWrapperInterface {
@@ -20,8 +24,8 @@ interface LionWebLanguageWrapperInterface {
 export class LionWebLanguageWrapper extends LionWebJsonChunkWrapper implements LionWebLanguageWrapperInterface {
     name: string
     version: string
-    key: LionWebKey
-
+    key: string
+    
     constructor(chunk: LionWebJsonChunk) {
         super(chunk)
         const languageNode: LionWebJsonNode = this.findNodesOfClassifier(MetaPointers.Language)[0]

package/src/languages/MetaPointerMap.ts

@@ -1,13 +1,12 @@
-import { LionWebJsonMetaPointer, LionWebJsonNode, LionWebKey } from "@lionweb/json"
-import { MetaPointers, NodeUtils } from "@lionweb/json-utils"
+import { LionWebJsonMetaPointer, LionWebJsonNode, MetaPointers, NodeUtils } from "../json/index.js"
 
 export class MetaPointerMap {
     /**
      * Map from languageKey => languageVersion => key => LionWebJsonNode
      */
     map: Map<string, Map<string, Map<string, LionWebJsonNode>>> = new Map<string, Map<string, Map<string, LionWebJsonNode>>>()
-
-    add(languageKey: LionWebKey, languageVersion: string, node: LionWebJsonNode): void {
+    
+    add(languageKey: string, languageVersion: string, node: LionWebJsonNode): void {
         const keyProperty = NodeUtils.findProperty(node, MetaPointers.IKeyedKey)
         if (keyProperty === undefined) {
             console.log("MetaPointerMap.add: trying to add node without key property.")
@@ -18,9 +17,9 @@ export class MetaPointerMap {
             console.log("MetaPointerMap.add: trying to add node without key property being empty or null.")
             return
         }
-        this.set({ language: languageKey, version: languageVersion, key: key }, node)
+        this.set({language: languageKey, version: languageVersion, key: key}, node)
     }
-
+    
     set(mp: LionWebJsonMetaPointer, node: LionWebJsonNode): void {
         let language = this.map.get(mp.language)
         if (language === undefined) {
@@ -34,7 +33,7 @@ export class MetaPointerMap {
         }
         version.set(mp.key, node)
     }
-
+    
     get(mp: LionWebJsonMetaPointer): LionWebJsonNode | undefined {
         return this.map.get(mp.language)?.get(mp.version)?.get(mp.key)
     }

package/src/runners/FileUtils.ts

@@ -1,7 +1,7 @@
 import fs from "fs"
 import { LanguageRegistry } from "../languages/index.js"
-import { ValidationResult } from "../validators/generic/ValidationResult.js"
 import { LionWebValidator } from "../validators/LionWebValidator.js"
+import { ValidationResult } from "../validators/generic/ValidationResult.js"
 import { getFilesRecursive, printIssues } from "./Utils.js"
 
 export function validateFile(file: string, registry: LanguageRegistry): void {

package/src/runners/RunCheckFolderWithLanguage.ts

@@ -28,7 +28,7 @@ if (languageValidator.validationResult.hasErrors()) {
 for (const modelFile of getFilesRecursive(folder, [])) {
     const jsonString1 = fs.readFileSync(modelFile, "utf-8")
     const jsonModel = JSON.parse(jsonString1)
-    const modelValidator = new LionWebValidator(jsonModel, registry)
+    const modelValidator = new LionWebValidator(jsonModel, registry )
 
     modelValidator.validateAll()
     if (modelValidator.validationResult.hasErrors()) {

package/src/runners/RunLioncoreDiff.ts

@@ -1,6 +1,6 @@
-import { LionWebJsonChunk } from "@lionweb/json"
-import { LionWebJsonDiff } from "@lionweb/json-diff"
 import fs from "fs"
+import { LionWebJsonDiff } from "../diff/index.js"
+import { LionWebJsonChunk } from "../json/LionWebJson.js"
 
 const file1 = process.argv[2]
 const file2 = process.argv[3]

package/src/util/graphs.ts

@@ -0,0 +1,36 @@
+// NB This is an almost identical copy of packages/core/utils/recursion.ts
+//    Copied to avoid package dependencies
+/**
+ * Type def. of a generic "flatMap" function.
+ */
+export type ResultMapper<T, R> = (t: T) => R[]
+
+/**
+ * Returns a function that performs a "flatMap" on a graph that's specified as a start vertex. and a function that computes (outgoing) edges.
+ * The "flatMap" is performed depth-first, and doesn't loop on cycles.
+ * 
+ * @param mapper The function that calculates the result values
+ * @param nextVertices  The function that calculates the next edges to visit.
+ * @returns A function that takes a starting vertex and resursively calculates the result values for each vertex visited.
+ */
+export const visitAndMap =
+    <T, R>(mapper: ResultMapper<T, R>, nextVertices: (t: T) => T[]): ResultMapper<T, R> =>
+    (startVertex: T): R[] => {
+        const visited: T[] = []
+        const rs: R[] = []
+        const recurse = (t: T) => {
+            if (visited.indexOf(t) > -1) {
+                return
+            }
+            visited.push(t)
+            rs.push(...mapper(t))
+            nextVertices(t).forEach(recurse)
+        }
+        recurse(startVertex)
+        return rs
+    }
+
+/** 
+ * A mapper function that returns the node itself as result
+ */
+export const selfMapper = <T>(t: T) => [t]

package/src/validators/LionWebChunkDefinitions.ts

@@ -1,5 +1,10 @@
-import { MAY_BE_NULL, PrimitiveDef, PropertyDef, TypeDefinition } from "./generic/ValidationTypes.js"
-import { validateId, validateKey, validateSerializationFormatVersion, validateVersion } from "./ValidationFunctions.js"
+import {
+    validateId,
+    validateKey,
+    validateSerializationFormatVersion,
+    validateVersion
+} from "./ValidationFunctions.js"
+import { MAY_BE_NULL, PropertyDef, PropertyDefinition } from "./generic/ValidationTypes.js"
 
 /**
  * The structure below defines the structure of a LionWeb Chunk by defining all the properties.
@@ -7,13 +12,13 @@ import { validateId, validateKey, validateSerializationFormatVersion, validateVe
  *   - be fed to the SyntaxValidator to validate an object sat runtime.
  *   - used to generate all the types for a LionWebChunk.
  */
-export const expectedTypes: Map<string, TypeDefinition> = new Map<string, TypeDefinition>([
+export const expectedTypes: Map<string, PropertyDefinition[]> = new Map([
     [
         "LionWebMetaPointer",
         [
-            PropertyDef({ property: "key", expectedType: "LionWebKey" }),
-            PropertyDef({ property: "version", expectedType: "LionWebVersion" }),
-            PropertyDef({ property: "language", expectedType: "LionWebKey" })
+            PropertyDef({ property: "key", expectedType: "string", validate: validateKey }),
+            PropertyDef({ property: "version", expectedType: "string", validate: validateVersion }),
+            PropertyDef({ property: "language", expectedType: "string", validate: validateKey })
         ]
     ],
     [
@@ -21,13 +26,13 @@ export const expectedTypes: Map<string, TypeDefinition> = new Map<string, TypeDe
         [
             PropertyDef({ property: "kind", expectedType: "string" }),
             PropertyDef({ property: "message", expectedType: "string" }),
-            PropertyDef({ property: "data", expectedType: "object", mayBeNull: true, isOptional: true })
+            PropertyDef({ property: "data", expectedType: "object", mayBeNull: true })
         ]
     ],
     [
         "LionWebChunk",
         [
-            PropertyDef({ property: "serializationFormatVersion", expectedType: "LionWebSerializationFormatVersion" }),
+            PropertyDef({ property: "serializationFormatVersion", expectedType: "string", validate: validateSerializationFormatVersion }),
             PropertyDef({ property: "languages", expectedType: "LionWebUsedLanguage", isList: true }),
             PropertyDef({ property: "nodes", expectedType: "LionWebNode", isList: true })
         ]
@@ -35,20 +40,20 @@ export const expectedTypes: Map<string, TypeDefinition> = new Map<string, TypeDe
     [
         "LionWebUsedLanguage",
         [
-            PropertyDef({ property: "key", expectedType: "LionWebKey" }),
-            PropertyDef({ property: "version", expectedType: "LionWebVersion" })
+            PropertyDef({ property: "key", expectedType: "string", validate: validateKey }),
+            PropertyDef({ property: "version", expectedType: "string", validate: validateVersion })
         ]
     ],
     [
         "LionWebNode",
         [
-            PropertyDef({ property: "id", expectedType: "LionWebId" }),
+            PropertyDef({ property: "id", expectedType: "string", validate: validateId }),
             PropertyDef({ property: "classifier", expectedType: "LionWebMetaPointer" }),
             PropertyDef({ property: "properties", expectedType: "LionWebProperty", isList: true }),
             PropertyDef({ property: "containments", expectedType: "LionWebContainment", isList: true }),
             PropertyDef({ property: "references", expectedType: "LionWebReference", isList: true }),
-            PropertyDef({ property: "annotations", expectedType: "LionWebId", isList: true }),
-            PropertyDef({ property: "parent", expectedType: "LionWebId", mayBeNull: MAY_BE_NULL }),
+            PropertyDef({ property: "annotations", expectedType: "string", isList: true, validate: validateId }),
+            PropertyDef({ property: "parent", expectedType: "string", mayBeNull: MAY_BE_NULL, validate: validateId }),
         ]
     ],
     [
@@ -62,7 +67,7 @@ export const expectedTypes: Map<string, TypeDefinition> = new Map<string, TypeDe
         "LionWebContainment",
         [
             PropertyDef({ property: "containment", expectedType: "LionWebMetaPointer" }),
-            PropertyDef({ property: "children", expectedType: "LionWebId", isList: true }),
+            PropertyDef({ property: "children", expectedType: "string", isList: true, validate: validateId }),
         ]
     ],
     [
@@ -76,37 +81,24 @@ export const expectedTypes: Map<string, TypeDefinition> = new Map<string, TypeDe
         "LionWebReferenceTarget",
         [
             PropertyDef({ property: "resolveInfo", expectedType: "string", mayBeNull: MAY_BE_NULL }),
-            PropertyDef({ property: "reference", expectedType: "LionWebId", mayBeNull: MAY_BE_NULL }),
+            PropertyDef({ property: "reference", expectedType: "string", mayBeNull: MAY_BE_NULL, validate: validateId }),
         ]
     ],
     /**
-     * Elements without properties are assumed to be JSON/JS primitive values, and tested using `typeof`
-     * and the (optional) validate function.
+     * Elements without properties are assumed to be JSON/JS primitive values, and tested using `typeof`.
      */
     [
-        "LionWebId",
-        PrimitiveDef({ primitiveType: "string", validate: validateId }),
-    ],
-    [
-        "LionWebKey",
-        PrimitiveDef({ primitiveType: "string", validate: validateKey }),
-    ],
-    [
-        "LionWebVersion",
-        PrimitiveDef({ primitiveType: "string", validate: validateVersion }),
+        "string",
+        []
     ],
     [
-        "LionWebSerializationFormatVersion",
-        PrimitiveDef({ primitiveType: "string", validate: validateSerializationFormatVersion }),
+        "number",
+        []
     ],
     [
-        "string",
-        PrimitiveDef({ primitiveType: "string" }),
+        "boolean",
+        []
     ],
-    [
-        "object",
-        PrimitiveDef({ primitiveType: "object" }),
-    ]
 ])
 
 

package/src/validators/LionWebLanguageReferenceValidator.ts

@@ -1,35 +1,37 @@
-import { isEqualMetaPointer, LionWebJsonContainment, LionWebJsonNode, LionWebJsonProperty, LionWebJsonReference } from "@lionweb/json"
-import {
-    JsonContext,
-    LION_CORE_BUILTINS_INAMED_NAME,
-    LIONWEB_BOOLEAN_TYPE, LIONWEB_INTEGER_TYPE, LIONWEB_JSON_TYPE, LIONWEB_STRING_TYPE,
-    LionWebJsonChunkWrapper,
-    M3_Keys,
-    MetaPointers,
-    NodeUtils
-} from "@lionweb/json-utils"
 import {
     Language_ContainmentMetaPointerNotInClass_Issue,
-    Language_IncorrectPropertyMetaPointer_Issue,
-    Language_PropertyMetaPointerNotInClass_Issue,
-    Language_PropertyValue_Issue,
-    Language_ReferenceMetaPointerNotInClass_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_IncorrectReferenceMetaPointer_Issue,
-    Language_UnknownContainment_Issue,
-    Language_UnknownProperty_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 {
+    LionWebJsonContainment,
+    LionWebJsonProperty,
+    LionWebJsonReference,
+} from "../json/LionWebJson.js"
+import { LionWebJsonChunkWrapper } from "../json/LionWebJsonChunkWrapper.js"
 // import {
 //     KnownLanguages, LanguageRegistry
 // } from "../languages/LanguageRegistry.js"
+import {
+    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 { ValidationResult } from "./generic/ValidationResult.js"
 import { validateBoolean, validateInteger, validateJSON } from "./ValidationFunctions.js"
-
+import { ValidationResult } from "./generic/ValidationResult.js"
 
 /**
  * Check against the language definition

package/src/validators/LionWebLanguageValidator.ts

@@ -1,7 +1,9 @@
-import { isEqualMetaPointer, LionWebJsonChunk, LionWebJsonNode } from "@lionweb/json"
-import { isLionWebM3Language, JsonContext, LionWebJsonChunkWrapper, MetaPointers } from "@lionweb/json-utils"
 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 { isLionWebM3Language, LionWebJsonChunk } from "../json/LionWebJson.js"
+import { LionWebJsonChunkWrapper } from "../json/LionWebJsonChunkWrapper.js"
 import { isConcept, LanguageRegistry } from "../languages/index.js"
 import { ValidationResult } from "./generic/ValidationResult.js"