@likec4/core 0.6.1 → 0.6.2

package/dist/compute-view/compute.element-view.spec.js

@@ -1,175 +0,0 @@
-import { expect, test } from 'vitest';
-import { fakeModel } from '../__test__';
-import { computeElementView } from './compute.element-view';
-test('index view', () => {
-    const { nodes, edges } = computeElementView({
-        id: 'index',
-        title: '',
-        rules: [
-            {
-                isInclude: true,
-                exprs: [
-                    {
-                        wildcard: true
-                    }
-                ]
-            }
-        ]
-    }, fakeModel());
-    expect(nodes.map(n => n.id)).toEqual(['support', 'customer', 'cloud', 'amazon']);
-    expect(edges.map(e => e.id)).toEqual(['support:cloud', 'customer:cloud', 'cloud:amazon']);
-});
-test('view of cloud', () => {
-    const view = computeElementView({
-        id: 'cloud',
-        title: '',
-        viewOf: 'cloud',
-        rules: [
-            {
-                isInclude: true,
-                exprs: [
-                    {
-                        wildcard: true
-                    }
-                ]
-            }
-        ]
-    }, fakeModel());
-    const { nodes, edges } = view;
-    expect(nodes.map(n => n.id)).toEqual([
-        'support',
-        'customer',
-        'cloud',
-        'cloud.frontend',
-        'cloud.backend',
-        'amazon'
-    ]);
-    expect(edges.map(e => e.id)).toEqual([
-        'cloud.frontend:cloud.backend',
-        'cloud.backend:amazon',
-        'support:cloud.frontend',
-        'customer:cloud.frontend'
-    ]);
-    expect(view).toMatchSnapshot();
-});
-test('view with 3 levels', () => {
-    const view = computeElementView({
-        id: 'cloud3levels',
-        title: '',
-        viewOf: 'cloud',
-        rules: [
-            {
-                isInclude: true,
-                exprs: [
-                    // include *
-                    { wildcard: true },
-                    // include cloud.frontend.*
-                    { element: 'cloud.frontend', isDescedants: true },
-                    // include cloud.backend.*
-                    { element: 'cloud.backend', isDescedants: true }
-                ]
-            },
-            {
-                isInclude: false,
-                exprs: [
-                    // exclude cloud.frontend
-                    { element: 'cloud.frontend', isDescedants: false }
-                ]
-            }
-        ]
-    }, fakeModel());
-    expect(view.nodes.map(n => n.id)).toEqual([
-        'support',
-        'customer',
-        'cloud',
-        'cloud.frontend.dashboard',
-        'cloud.frontend.adminPanel',
-        'cloud.backend',
-        'cloud.backend.graphql',
-        'cloud.backend.storage',
-        'amazon'
-    ]);
-    expect(view).toMatchSnapshot();
-});
-test('view of amazon', () => {
-    const { nodes, edges } = computeElementView({
-        id: 'amazon',
-        title: '',
-        viewOf: 'amazon',
-        rules: [
-            {
-                isInclude: true,
-                exprs: [
-                    // include *
-                    { wildcard: true },
-                    // include cloud
-                    { element: 'cloud', isDescedants: false },
-                    // include cloud.* -> amazon
-                    {
-                        source: { element: 'cloud', isDescedants: true },
-                        target: { element: 'amazon', isDescedants: false }
-                    }
-                ]
-            }
-        ]
-    }, fakeModel());
-    expect(nodes.map(n => n.id)).toEqual(['cloud', 'cloud.backend', 'amazon', 'amazon.s3']);
-    expect(edges.map(e => e.id)).toEqual(['cloud.backend:amazon.s3']);
-});
-test('index view with applied styles', () => {
-    const { nodes } = computeElementView({
-        id: 'index',
-        rules: [
-            {
-                isInclude: true,
-                exprs: [{ wildcard: true }, { element: 'cloud.backend', isDescedants: false }]
-            },
-            // all elements
-            // color: secondary
-            {
-                targets: [{ wildcard: true }],
-                style: {
-                    color: 'secondary',
-                    shape: 'storage'
-                }
-            },
-            // cloud
-            // color: muted
-            {
-                targets: [{ element: 'cloud', isDescedants: false }],
-                style: {
-                    color: 'muted'
-                }
-            },
-            // cloud.*
-            // shape: browser
-            {
-                targets: [{ element: 'cloud', isDescedants: true }],
-                style: {
-                    shape: 'browser'
-                }
-            }
-        ]
-    }, fakeModel());
-    const amazon = nodes.find(n => n.id === 'amazon');
-    const customer = nodes.find(n => n.id === 'customer');
-    const cloud = nodes.find(n => n.id === 'cloud');
-    const backend = nodes.find(n => n.id === 'cloud.backend');
-    expect(amazon).toMatchObject({
-        color: 'secondary',
-        shape: 'storage'
-    });
-    expect(customer).toMatchObject({
-        color: 'secondary',
-        shape: 'storage'
-    });
-    expect(cloud).toMatchObject({
-        color: 'muted',
-        shape: 'storage'
-    });
-    expect(backend).toMatchObject({
-        parent: 'cloud',
-        color: 'secondary',
-        shape: 'browser'
-    });
-});

package/dist/compute-view/index.d.ts

@@ -1,2 +0,0 @@
-export { computeView, computeViews } from './compute-view';
-export type * from '../types/computed-view';

package/dist/compute-view/index.js

@@ -1 +0,0 @@
-export { computeView, computeViews } from './compute-view';

package/dist/compute-view/utils/anyPossibleRelations.d.ts

@@ -1,2 +0,0 @@
-import type { Element } from '../../types';
-export declare function anyPossibleRelations(elements: Element[]): Generator<[source: Element, target: Element]>;

package/dist/compute-view/utils/anyPossibleRelations.js

@@ -1,12 +0,0 @@
-import { prop, uniqBy } from 'rambdax';
-import { compareByFqnHierarchically, isAncestor } from '../../utils/fqn';
-export function* anyPossibleRelations(elements) {
-    const uniqElements = uniqBy(prop('id'), elements).sort(compareByFqnHierarchically).reverse();
-    for (const source of uniqElements) {
-        for (const target of uniqElements) {
-            if (source !== target && !isAncestor(source, target) && !isAncestor(target, source)) {
-                yield [source, target];
-            }
-        }
-    }
-}

package/dist/compute-view/utils/evaluate-expression.d.ts

@@ -1,10 +0,0 @@
-import type { ModelIndex } from '../../model-index';
-import type { Element, Fqn, Relation, Expression } from '../../types';
-export declare const keepLeafs: (elements: Element[]) => Element[];
-interface EvaluateViewExpressionResult {
-    elements: Element[];
-    neighbours: Element[];
-    relations: Relation[];
-}
-export declare function evaluateExpression(index: ModelIndex, expr: Expression, rootElement: Fqn | null): EvaluateViewExpressionResult;
-export {};

package/dist/compute-view/utils/evaluate-expression.js

@@ -1,186 +0,0 @@
-import { anyPass, map, pluck, uniq } from 'rambdax';
-import * as Expr from '../../types/expression';
-import { failExpectedNever, isAncestor } from '../../utils';
-import { isBetween, isIncoming, isInside, isOutgoing } from '../../utils/relations';
-import { anyPossibleRelations } from './anyPossibleRelations';
-const dropNested = (elements) => {
-    return elements.reduce((acc, current) => {
-        if (acc.length === 0)
-            return [current];
-        // current is a child   of some in acc
-        if (acc.some(p => p.id === current.id || isAncestor(p, current))) {
-            return acc;
-        }
-        return [
-            // drop children of current
-            ...acc.filter(e => !isAncestor(current, e)),
-            current
-        ];
-    }, []);
-};
-export const keepLeafs = (elements) => {
-    return elements.reduce((acc, current) => {
-        if (acc.length === 0)
-            return [current];
-        // current is an ancestor of some in acc
-        if (acc.some(p => p.id === current.id || isAncestor(current, p))) {
-            return acc;
-        }
-        return [
-            // drop ancestors of current
-            ...acc.filter(e => !isAncestor(e, current)),
-            current
-        ];
-    }, []);
-};
-const evaluateElementExpression = (index, expr, rootElement = null) => {
-    let elements = [];
-    let neighbours = [];
-    let relations = [];
-    // const inOutRelations = (elements: Element[]) => {
-    //   if (elements.length == 0) return []
-    //   const filters = dropNested(elements).map(e => isAnyInOut(e.id))
-    //   return index.filterRelations(anyPass(filters))
-    // }
-    const allRelationsBetween = (elements) => {
-        if (elements.length <= 1)
-            return [];
-        const filters = [];
-        for (const [source, target] of anyPossibleRelations(elements)) {
-            filters.push(isBetween(source.id, target.id));
-        }
-        return filters.length ? index.filterRelations(anyPass(filters)) : [];
-    };
-    // WildcardExpression
-    if (Expr.isWildcard(expr)) {
-        if (rootElement) {
-            elements = [index.find(rootElement), ...index.children(rootElement)];
-            neighbours = [
-                ...index.siblings(rootElement),
-                ...index.ancestors(rootElement).flatMap(a => [...index.siblings(a.id)])
-            ];
-            relations = index.filterRelations(anyPass([isInside(rootElement), isIncoming(rootElement), isOutgoing(rootElement)]));
-        }
-        else {
-            elements = index.rootElements();
-            neighbours = elements;
-            relations = allRelationsBetween(elements);
-        }
-        return {
-            elements,
-            neighbours,
-            relations
-        };
-    }
-    // Identifier
-    if (Expr.isElementRef(expr)) {
-        elements = expr.isDescedants ? index.children(expr.element) : [index.find(expr.element)];
-        if (expr.isDescedants) {
-            relations = index.filterRelations(isInside(expr.element));
-            //   relations = index.filterRelations(anyPass([
-            //     isBetween(expr.element),
-            //     isIncoming(expr.element),
-            //     isOutgoing(expr.element),
-            //   ]))
-            // } else {
-            //   relations = index.filterRelations(anyPass([
-            //     isIncoming(expr.element),
-            //     isOutgoing(expr.element)
-            //   ]))
-        }
-        return {
-            elements,
-            neighbours,
-            relations
-        };
-    }
-    failExpectedNever(expr);
-};
-export function evaluateExpression(index, expr, rootElement) {
-    const elements = [];
-    let neighbours = [];
-    let relations = [];
-    if (Expr.isInOut(expr)) {
-        const targets = evaluateElementExpression(index, expr.inout).elements;
-        for (const target of targets) {
-            const incoming = index.filterRelations(isIncoming(target.id));
-            const outgoing = index.filterRelations(isOutgoing(target.id));
-            if (incoming.length + outgoing.length > 0) {
-                elements.push(target);
-                neighbours = neighbours.concat(map(index.find, [...pluck('source', incoming), ...pluck('target', outgoing)]));
-                relations = relations.concat([...incoming, ...outgoing]);
-            }
-        }
-        return {
-            elements: uniq(elements),
-            neighbours: dropNested(neighbours),
-            relations: uniq(relations)
-        };
-    }
-    if (Expr.isIncoming(expr)) {
-        const targets = evaluateElementExpression(index, expr.incoming).elements;
-        for (const target of targets) {
-            const incoming = index.filterRelations(isIncoming(target.id));
-            if (incoming.length > 0) {
-                elements.push(target);
-                neighbours = neighbours.concat(map(index.find, pluck('source', incoming)));
-                relations = relations.concat(incoming);
-            }
-        }
-        return {
-            elements: uniq(elements),
-            neighbours: dropNested(neighbours),
-            relations: uniq(relations)
-        };
-    }
-    if (Expr.isOutgoing(expr)) {
-        const sources = evaluateElementExpression(index, expr.outgoing).elements;
-        for (const source of sources) {
-            const outgoing = index.filterRelations(isOutgoing(source.id));
-            if (outgoing.length > 0) {
-                elements.push(source);
-                neighbours = neighbours.concat(map(index.find, pluck('target', outgoing)));
-                relations = relations.concat(outgoing);
-            }
-        }
-        return {
-            elements: uniq(elements),
-            neighbours: dropNested(neighbours),
-            relations: uniq(relations)
-        };
-    }
-    if (Expr.isRelation(expr)) {
-        const isSourceWildcard = Expr.isWildcard(expr.source);
-        const isTargetWildcard = Expr.isWildcard(expr.target);
-        if (isSourceWildcard && !isTargetWildcard) {
-            return evaluateExpression(index, {
-                incoming: expr.target
-            }, rootElement);
-        }
-        if (!isSourceWildcard && isTargetWildcard) {
-            return evaluateExpression(index, {
-                outgoing: expr.source
-            }, rootElement);
-        }
-        const sources = evaluateElementExpression(index, expr.source).elements;
-        const targets = evaluateElementExpression(index, expr.target).elements;
-        for (const source of sources) {
-            for (const target of targets) {
-                if (isAncestor(source.id, target.id) || isAncestor(target.id, source.id)) {
-                    continue;
-                }
-                const foundRelations = index.filterRelations(isBetween(source.id, target.id));
-                if (foundRelations.length > 0) {
-                    relations = relations.concat(foundRelations);
-                    neighbours.push(source, target);
-                }
-            }
-        }
-        return {
-            elements,
-            neighbours: uniq(neighbours),
-            relations: uniq(relations)
-        };
-    }
-    return evaluateElementExpression(index, expr, rootElement);
-}

package/dist/compute-view/utils/sortNodes.d.ts

@@ -1,2 +0,0 @@
-import type { ComputedEdge, ComputedNode, Fqn } from '../../types';
-export declare function sortNodes(_nodes: Map<Fqn, ComputedNode>, edges: ComputedEdge[]): ComputedNode[];

package/dist/compute-view/utils/sortNodes.js

@@ -1,42 +0,0 @@
-import { Graph, alg } from '@dagrejs/graphlib';
-export function sortNodes(_nodes, edges) {
-    const g = new Graph({
-        compound: true,
-        directed: true,
-        multigraph: false
-    });
-    for (const nd of _nodes.values()) {
-        g.setNode(nd.id);
-        // console.log(`add ${nd.id}`)
-        if (nd.parent) {
-            g.setEdge(nd.parent, nd.id);
-            // console.log(`${nd.parent} -> ${nd.id}`)
-        }
-    }
-    for (const edge of edges) {
-        const source = _nodes.get(edge.source);
-        let target = _nodes.get(edge.target);
-        while (source && target) {
-            if (!g.hasEdge(source.id, target.id)) {
-                g.setEdge(source.id, target.id);
-                // console.log(`${source.id} -> ${target.id}`)
-                if (!alg.isAcyclic(g)) {
-                    g.removeEdge(source.id, target.id);
-                    // console.log(`remove ${source.id} -> ${target.id}`)
-                }
-            }
-            if (target.parent && target.parent !== edge.parent) {
-                target = _nodes.get(target.parent);
-            }
-            else {
-                target = undefined;
-            }
-        }
-    }
-    const sorted = alg.topsort(g);
-    const nodes = sorted.map(id => _nodes.get(id));
-    for (const node of nodes) {
-        node.children = nodes.flatMap(n => (n.parent === node.id ? n.id : []));
-    }
-    return nodes;
-}

package/dist/compute-view/utils/sortNodes.spec.d.ts

@@ -1 +0,0 @@
-export {};