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

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]