@likec4/core 0.7.0 → 0.18.0

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

@@ -1,168 +0,0 @@
-import { anyPass, filter, head } from 'rambdax';
-import { DefaultElementShape, DefaultThemeColor } from '../types';
-import * as Expression from '../types/expression';
-import { isViewRuleAutoLayout, isViewRuleExpression, isViewRuleStyle } from '../types/view';
-import { Relations, compareByFqnHierarchically, failExpectedNever, isSameHierarchy, parentFqn } from '../utils';
-import { EdgeBuilder } from './EdgeBuilder';
-import { anyPossibleRelations } from './utils/anyPossibleRelations';
-import { evaluateExpression } from './utils/evaluate-expression';
-import { sortNodes } from './utils/sortNodes';
-function updateSetWith(set, elements, addToSet = true) {
-    for (const e of elements) {
-        addToSet ? set.add(e) : set.delete(e);
-    }
-}
-function transformToNodes(elementsIterator, index, currentViewid) {
-    return Array.from(elementsIterator)
-        .sort(compareByFqnHierarchically)
-        .reduce((map, { id, title, color, shape, description }) => {
-        let parent = parentFqn(id);
-        while (parent) {
-            if (map.has(parent)) {
-                break;
-            }
-            parent = parentFqn(parent);
-        }
-        const navigateTo = head(index.defaultViewOf(id).filter(v => v !== currentViewid));
-        map.set(id, Object.assign({
-            id,
-            parent,
-            title,
-            color: color ?? DefaultThemeColor,
-            shape: shape ?? DefaultElementShape,
-            children: []
-        }, description ? { description } : {}, navigateTo ? { navigateTo } : {}));
-        if (parent) {
-            map.get(parent)?.children.push(id);
-        }
-        return map;
-    }, new Map());
-}
-function applyViewRuleStyles(rules, nodes) {
-    for (const rule of rules) {
-        const predicates = [];
-        if (!rule.style.color && !rule.style.shape) {
-            // skip empty
-            continue;
-        }
-        for (const target of rule.targets) {
-            if (Expression.isWildcard(target)) {
-                predicates.push(() => true);
-                break;
-            }
-            if (Expression.isElementRef(target)) {
-                const { element, isDescedants } = target;
-                predicates.push(isDescedants ? n => n.id.startsWith(element + '.') : n => n.id === element);
-                continue;
-            }
-            failExpectedNever(target);
-        }
-        filter(anyPass(predicates), nodes).forEach(n => {
-            n.shape = rule.style.shape ?? n.shape;
-            n.color = rule.style.color ?? n.color;
-        });
-    }
-    return nodes;
-}
-export function computeElementView(view, index) {
-    const relations = new Set();
-    const elements = new Set();
-    const neighbours = new Set();
-    const rootElement = view.viewOf ?? null;
-    const rulesInclude = view.rules.filter(isViewRuleExpression);
-    if (rootElement && rulesInclude.length == 0) {
-        elements.add(index.find(rootElement));
-    }
-    for (const { isInclude, exprs } of rulesInclude) {
-        for (const expr of exprs) {
-            let { elements: newElements, neighbours: newNeighbours, relations: newRelations } = evaluateExpression(index, expr, rootElement);
-            if (isInclude) {
-                const filters = [];
-                // When include element(s) without newNeighbours, include in-out relations
-                if (elements.size > 0 &&
-                    newElements.length > 0 &&
-                    newNeighbours.length === 0 &&
-                    Expression.isElement(expr)) {
-                    for (const e of elements) {
-                        for (const newE of newElements) {
-                            if (!isSameHierarchy(e, newE)) {
-                                filters.push(Relations.isAnyBetween(e.id, newE.id));
-                            }
-                        }
-                    }
-                }
-                // // When include elements by tag or kind, include in-out relations
-                // if (elements.size > 0 && newElements.length > 0 && (Expression.isElementKind(expr) || Expression.isElementTag(expr))) {
-                //   for (const e of elements) {
-                //     for (const newE of newElements) {
-                //       if (e.id !== newE.id && !isAncestor(e, newE) && !isAncestor(newE, e)) {
-                //         filters.push(isAnyRelationBetween(e.id, newE.id))
-                //       }
-                //     }
-                //   }
-                // }
-                if (filters.length > 0) {
-                    newRelations = newRelations.concat(index.filterRelations(anyPass(filters)));
-                }
-            }
-            else {
-                if (Expression.isAnyRelation(expr)) {
-                    // Exclude only relations, but not elements and neighbours
-                    newNeighbours = [];
-                    newElements = [];
-                }
-                else {
-                    newNeighbours = newNeighbours.concat(newElements);
-                    // Also exclude nested elements from current neighbours
-                    // for (const n of neighbours) {
-                    //   if (newNeighbours.some(e => n.id.startsWith(e.id + '.'))) {
-                    //     newNeighbours.push(n)
-                    //   }
-                    // }
-                    // Do not exclude relations
-                    newRelations = [];
-                }
-            }
-            updateSetWith(elements, newElements, isInclude);
-            updateSetWith(relations, newRelations, isInclude);
-            updateSetWith(neighbours, newNeighbours, isInclude);
-        }
-    }
-    const elementsIds = new Set([...elements].map(e => e.id));
-    const edgeBuilder = new EdgeBuilder();
-    const resolvedRelations = [...relations];
-    for (const [source, target] of anyPossibleRelations([...elements, ...neighbours])) {
-        if (!elementsIds.has(source.id) && !elementsIds.has(target.id)) {
-            continue;
-        }
-        const findPredicate = Relations.isBetween(source.id, target.id);
-        let idx = resolvedRelations.findIndex(findPredicate);
-        while (idx >= 0) {
-            const [rel] = resolvedRelations.splice(idx, 1);
-            if (rel) {
-                elements.add(source);
-                elements.add(target);
-                edgeBuilder.add(source.id, target.id, rel);
-            }
-            idx = resolvedRelations.findIndex(findPredicate);
-        }
-    }
-    const nodesreg = transformToNodes(elements, index, view.id);
-    const edges = edgeBuilder.build().map(edge => {
-        while (edge.parent) {
-            if (nodesreg.has(edge.parent)) {
-                break;
-            }
-            edge.parent = parentFqn(edge.parent);
-        }
-        return edge;
-    });
-    const nodes = applyViewRuleStyles(view.rules.filter(isViewRuleStyle), sortNodes(nodesreg, edges));
-    const autoLayoutRule = view.rules.find(isViewRuleAutoLayout);
-    return {
-        ...view,
-        autoLayout: autoLayoutRule?.autoLayout ?? 'TB',
-        nodes,
-        edges
-    };
-}

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

@@ -1,11 +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 {};
-//# sourceMappingURL=evaluate-expression.d.ts.map

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