@lionweb/validation 0.6.13-beta.2 → 0.6.13-beta.5

package/src/diff/changes/ContainmentChange.ts

@@ -1,32 +0,0 @@
-import { JsonContext } from "../../issues/index.js"
-import { LionWebJsonContainment, LionWebJsonMetaPointer, LionWebJsonNode } from "../../json/index.js"
-import { Change, Missing } from "./Change.js"
-
-export abstract class ContainmentChange extends Change {
-    constructor(
-        public context: JsonContext,
-        public parentNode: LionWebJsonNode,
-        public containment: LionWebJsonMetaPointer,
-        public afterContainment: LionWebJsonContainment | undefined,
-        public childId: string,
-        public missing = Missing.NotMissing
-    ) {
-        super(context)
-    }
-}
-
-export class ChildAdded extends ContainmentChange {
-    readonly changeType = "ChildAdded"
-    protected msg = () => `Node "${this.parentNode.id}" added child "${this.childId}" to containment ${this.containment.key}`
-}
-
-export class ChildRemoved extends ContainmentChange {
-    readonly changeType = "ChildRemoved"
-    protected msg = () => `Node "${this.parentNode.id}" removed child "${this.childId}" from containment "${this.containment.key}"`
-}
-
-export class ChildOrderChanged extends ContainmentChange {
-    readonly changeType = "ChildOrderChanged"
-    protected msg = () => `Node "${this.parentNode.id}" changed order of children in containment "${this.containment.key}"`
-}
-

package/src/diff/changes/NodeChange.ts

@@ -1,63 +0,0 @@
-import { JsonContext } from "../../issues/index.js"
-import { LionWebJsonMetaPointer, LionWebJsonNode } from "../../json/index.js"
-import { Change, ChangeType } from "./Change.js"
-
-export class NodeClassifierChanged extends Change {
-    readonly changeType: ChangeType = "NodeClassifierChanged"
-
-    constructor(
-        public context: JsonContext,
-        public node: LionWebJsonNode,
-        public oldClassifier: LionWebJsonMetaPointer,
-        public newClassifier: LionWebJsonMetaPointer,
-    ) {
-        super(context)
-    }
-
-    protected msg = () => `Object ${this.node.id} has classifier changed from ${this.oldClassifier.key} to ${this.newClassifier.key}`
-}
-
-export class ParentChanged extends Change {
-    readonly changeType = "ParentChanged"
-
-    constructor(
-        public context: JsonContext,
-        public node: LionWebJsonNode,
-        public beforeParentId: string | null,
-        public afterParentId: string | null,
-    ) {
-        super(context)
-    }
-
-    protected msg = () => `Node "${this.node.id}" changed parent from "${this.beforeParentId}" to "${this.afterParentId}`
-}
-
-export abstract class AnnotationChange extends Change {
-    constructor(
-        ctx: JsonContext,
-        public nodeBefore: LionWebJsonNode,
-        public nodeAfter: LionWebJsonNode,
-        public annotationId: string,
-        public index: number
-    ) {
-        super(ctx)
-    }
-}
-
-export class AnnotationRemoved extends AnnotationChange {
-    readonly changeType = "AnnotationRemoved"
-
-    protected msg = () => `Node "${this.nodeBefore.id}" removed annotation "${this.annotationId}"`
-}
-
-export class AnnotationAdded extends AnnotationChange {
-    readonly changeType = "AnnotationAdded"
-
-    protected msg = () => `Node "${this.nodeAfter.id}" added annotation "${this.annotationId}"`
-}
-
-
-export class AnnotationOrderChanged extends AnnotationChange {
-    readonly changeType = "AnnotationOrderChanged"
-    protected msg = () => `Node "${this.nodeAfter.id}" changed order of annotations`
-}

package/src/diff/changes/PropertyChange.ts

@@ -1,31 +0,0 @@
-import { JsonContext } from "../../issues/index.js"
-import { LionWebJsonMetaPointer, LionWebJsonNode } from "../../json/index.js"
-import { Change, Missing } from "./Change.js"
-
-
-export abstract class PropertyChange extends Change {
-    constructor(
-        public context: JsonContext,
-        public nodeId: string,
-        public property: LionWebJsonMetaPointer,
-        public oldValue: string | null,
-        public newValue: string | null,
-        public missing: Missing = Missing.NotMissing
-    ) {
-        super(context) 
-    }
-}
-
-export class PropertyValueChanged extends PropertyChange {
-    readonly changeType = "PropertyValueChanged"
-    protected msg = () => `Node "${this.nodeId} changed value of property "${this.property.key}" from "${this.oldValue}" to "${this.newValue}"`
-}
-
-export class PropertyAdded extends Change {
-    readonly changeType = "PropertyAdded";
-    constructor(ctx: JsonContext, public node: LionWebJsonNode, public property: LionWebJsonMetaPointer) {
-        super(ctx)
-    }
-
-    protected msg = () => `Node "${this.node.id}" containment added: "${JSON.stringify(this.property)}"`
-}

package/src/diff/changes/ReferenceChange.ts

@@ -1,34 +0,0 @@
-import { JsonContext } from "../../issues/index.js"
-import { LionWebJsonNode, LionWebJsonReference, LionWebJsonReferenceTarget } from "../../json/index.js"
-import { Change, Missing } from "./Change.js"
-
-export abstract class ReferenceChange extends Change {
-    constructor(
-        public context: JsonContext,
-        public node: LionWebJsonNode,
-        public beforeReference: LionWebJsonReference | undefined,
-        public afterReference: LionWebJsonReference | undefined,
-        public target: LionWebJsonReferenceTarget,
-        public missing = Missing.NotMissing
-    ) {
-        super(context)
-    }
-}
-
-export class TargetAdded extends ReferenceChange {
-    readonly changeType = "TargetAdded"
-    protected msg = () =>
-        `Node "${this.node.id}" added target "${this.target.reference}" to reference "${this?.afterReference?.reference?.key}"`
-}
-
-export class TargetRemoved extends ReferenceChange {
-    readonly changeType = "TargetRemoved"
-    protected msg = () =>
-        `Node "${this.node.id}" removed target "${this.target.reference}" from reference "${this?.beforeReference?.reference?.key}"`
-}
-
-export class TargetOrderChanged extends ReferenceChange {
-    readonly changeType = "TargetOrderChanged"
-    protected msg = () => `Node "${this.node.id}" changed order of targets in reference "${this.afterReference?.reference?.key}"`
-}
-

package/src/diff/changes/index.ts

@@ -1,6 +0,0 @@
-export * from "./Change.js"
-export * from "./ChunkChange.js"
-export * from "./ContainmentChange.js"
-export * from "./NodeChange.js"
-export * from "./PropertyChange.js"
-export * from "./ReferenceChange.js"

package/src/diff/index.ts

@@ -1,3 +0,0 @@
-export * from "./changes/index.js"
-export * from "./DiffResult.js"
-export * from "./LionWebJsonDiff.js"

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
-    }
-}