@lionweb/validation 0.6.13-beta.7 → 0.7.0-beta.0

package/src/json/ChunkUtils.ts

@@ -1,49 +0,0 @@
-import { LionWebJsonChunk, LionWebJsonNode, LwJsonUsedLanguage } from "./LionWebJson.js"
-
-/**
- * Utility functions for LionWeb chunks
- */
-export class ChunkUtils {
-    /**
-     * Find a used language in `chunk` with `key`.
-     * @param chunk
-     * @param key
-     */
-    static findLwUsedLanguage(chunk: LionWebJsonChunk, key: string): LwJsonUsedLanguage | null {
-        for (const language of chunk.languages) {
-            if (language.key === key) {
-                return language
-            }
-        }
-        return null
-    }
-
-    /**
-     * Find a used language in `chunk` with `key` and 'version'.
-     * @param chunk
-     * @param key
-     * @param version
-     */
-    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 null
-    }
-
-    /**
-     * Find node with id equals `id` in `chunk`.
-     * @param chunk
-     * @param id
-     */
-    static findNode(chunk: LionWebJsonChunk, id: string): LionWebJsonNode | null {
-        for (const node of chunk.nodes) {
-            if (node.id === id) {
-                return node
-            }
-        }
-        return null
-    }
-}

package/src/json/JsonContext.ts

@@ -1,31 +0,0 @@
-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/LionWebJson.ts

@@ -1,80 +0,0 @@
-import { LION_CORE_M3_KEY, LION_CORE_M3_VERSION } from "./M3definitions.js"
-
-/**
- * The types defining the structure of the LionWeb JSON format.
- * @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 function isLionWebM3Language(language: LwJsonUsedLanguage): boolean {
-    return language.key === LION_CORE_M3_KEY && language.version === LION_CORE_M3_VERSION
-}
-export type LionWebId = string
-
-export type LionWebJsonMetaPointer = {
-    language: string
-    version: string
-    key: string             // key of concept, property, containment, referenve or property
-}
-
-export function isEqualMetaPointer(p1: LionWebJsonMetaPointer, p2: LionWebJsonMetaPointer): boolean {
-    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[]
-    nodes: LionWebJsonNode[]
-}
-
-export type LwJsonUsedLanguage = {
-    key: string
-    version: string
-}
-
-export type LionWebJsonNode = {
-    id: LionWebId
-    classifier: LionWebJsonMetaPointer
-    properties: LionWebJsonProperty[]
-    containments: LionWebJsonContainment[]
-    references: LionWebJsonReference[]
-    annotations: LionWebId[]
-    parent: (LionWebId | null)
-}
-
-export function createLwNode(): LionWebJsonNode {
-    return {
-        id: "",
-        classifier: { language: "", version: "", key: "" },
-        properties: [],
-        containments: [],
-        references: [],
-        annotations: [],
-        parent: null,
-    }
-}
-
-export type LionWebJsonProperty = {
-    property: LionWebJsonMetaPointer
-    value: (string | null)
-}
-
-export type LionWebJsonContainment = {
-    containment: LionWebJsonMetaPointer
-    children: LionWebId[]
-}
-
-export type LionWebJsonReference = {
-    reference: LionWebJsonMetaPointer
-    targets: LionWebJsonReferenceTarget[]
-}
-
-export type LionWebJsonReferenceTarget = {
-    resolveInfo: (string | null)
-    reference: LionWebId
-}

package/src/json/LionWebJsonChunkWrapper.ts

@@ -1,136 +0,0 @@
-import {
-    isEqualMetaPointer,
-    LionWebId,
-    LionWebJsonChunk,
-    LionWebJsonContainment,
-    LionWebJsonMetaPointer,
-    LionWebJsonNode,
-    LionWebJsonReference
-} from "./LionWebJson.js"
-import { MetaPointers } from "./M3definitions.js"
-import { NodeUtils } from "./NodeUtils.js"
-
-/**
- * Wraps around a LionWebJsonChunk, providing access to information inside, might be using caches to improve performance.
- * NB Make sure that the contents of the chunk are not changed after creating the wrapper!
- * NB BE aware that with `pushChunk(...)` the original chunk will be changed.
- */
-export class LionWebJsonChunkWrapper {
-    jsonChunk: LionWebJsonChunk
-    /**
-     * Map to get quick access to nodes by id.
-     * @protected
-     */
-    protected nodesIdMap: Map<LionWebId, LionWebJsonNode> = new Map<LionWebId, LionWebJsonNode>()
-
-    /**
-     * Create a wrapper with `chunk` as its chunk
-     * @param chunk
-     */
-    constructor(chunk: LionWebJsonChunk) {
-        this.jsonChunk = chunk
-        this.prepareNodeIds(chunk)
-    }
-
-    /** 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(chunk: LionWebJsonChunk) {
-        chunk.nodes.forEach(node => {
-            this.nodesIdMap.set(node.id, node)
-        })
-    }
-
-    getNode(id: string): LionWebJsonNode | undefined {
-        return this.nodesIdMap.get(id)
-    }
-
-    findNodesOfClassifier(concept: LionWebJsonMetaPointer): LionWebJsonNode[] {
-        return this.jsonChunk.nodes.filter(node => isEqualMetaPointer(node.classifier, concept))
-    }
-
-    /**
-     * Return the target nodes inside `reference` as a list of actual nodes (LionWebJsonNode[])
-     * @param reference
-     */
-    getReferredNodes(reference: LionWebJsonReference | undefined) {
-        if (reference === undefined) {
-            return []
-        }
-        const result = reference.targets.flatMap(target => {
-            if (target.reference === null) {
-                return []
-            } else {
-                const referredNode = this.getNode(target.reference)
-                return referredNode === undefined ? [] : [referredNode]
-            }
-        })
-        return result
-    }
-
-    /**
-     * Return the target nodes inside `reference` as a list of actual nodes (LionWebJsonNode[])
-     * @param reference
-     */
-    getChildrenAsNodes(containment: LionWebJsonContainment | undefined) {
-        if (containment === undefined) {
-            return []
-        }
-        const result: LionWebJsonNode[] = []
-        containment.children.forEach(ch => {
-            const childNode = this.getNode(ch)
-            if (childNode !== undefined) {
-                result.push(childNode)
-            }
-        })
-        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 = NodeUtils.findProperty(node, MetaPointers.INamedName)
-        const name = nameProperty === undefined ? "" : " " + nameProperty.value
-        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 += this.indent(depth + 1) + "*property* " + property.property.key + ": " + property.value + "\n"
-            })
-        node.references.forEach(ref => {
-            result += this.indent(depth + 1) + "*" + ref.reference.key + "*: " + JSON.stringify(ref.targets) + "\n"
-        })
-        node.containments.forEach(cont => {
-            if (cont.children.length !== 0) {
-                result += this.indent(depth + 1) + "*" + cont.containment.key + "*" + "\n"
-                cont.children.forEach(ch => {
-                    result += this.recursiveToString(this.getNode(ch), depth + 1)
-                })
-            }
-        })
-        return result
-    }
-
-    private indent(depth: number): string {
-        return Array(depth).join("    ")
-    }
-}

package/src/json/M3definitions.ts

@@ -1,177 +0,0 @@
-/**
- * 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

@@ -1,75 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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/util/graphs.ts

@@ -1,36 +0,0 @@
-// 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]