@likec4/core 0.2.0

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

@@ -0,0 +1,7 @@
+import type { Fqn, Relation } from '../types';
+import type { ComputedEdge } from '../types/computed-view';
+export declare class EdgeBuilder {
+    private _relationsObj;
+    add(source: Fqn, target: Fqn, relation: Relation): this;
+    build(): ComputedEdge[];
+}

package/dist/compute-view/EdgeBuilder.js

@@ -0,0 +1,31 @@
+import { equals, keys, pluck, reject } from 'rambdax';
+import { commonAncestor, compareFqnHierarchically } from '../utils';
+export class EdgeBuilder {
+    _relationsObj = {};
+    add(source, target, relation) {
+        const bySource = this._relationsObj[source] ?? {};
+        const relations = bySource[target] ?? [];
+        relations.push(relation);
+        bySource[target] = relations;
+        this._relationsObj[source] = bySource;
+        return this;
+    }
+    build() {
+        return keys(this._relationsObj).sort(compareFqnHierarchically).reverse().flatMap(source => {
+            const targets = this._relationsObj[source] ?? {};
+            return keys(targets).sort(compareFqnHierarchically).reverse().map(target => {
+                const relations = targets[target] ?? [];
+                const titles = reject(equals(''), pluck('title', relations));
+                const label = titles.length === 1 ? titles[0] : null;
+                return {
+                    id: `${source}:${target}`,
+                    parent: commonAncestor(source, target),
+                    source,
+                    target,
+                    label,
+                    relations: pluck('id', relations)
+                };
+            });
+        });
+    }
+}

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

@@ -0,0 +1,11 @@
+import { ModelIndex } from '../model-index';
+import type { Element, ElementView, Fqn, LikeC4Model, Relation, RelationID, ViewID } from '../types';
+import type { ComputedView } from '../types/computed-view';
+export declare function computeView(view: ElementView, index: ModelIndex): ComputedView;
+type InputModel = {
+    elements: Record<Fqn, Element>;
+    relations: Record<RelationID, Relation>;
+    views: Record<ViewID, ElementView>;
+};
+export declare function computeViews(model: InputModel): LikeC4Model;
+export {};

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

@@ -0,0 +1,14 @@
+import { map } from 'rambdax';
+import { ModelIndex } from '../model-index';
+import { computeElementView } from './compute.element-view';
+export function computeView(view, index) {
+    return computeElementView(view, index);
+}
+export function computeViews(model) {
+    const index = ModelIndex.from(model);
+    return {
+        elements: model.elements,
+        relations: model.relations,
+        views: map(v => computeElementView(v, index), model.views)
+    };
+}

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

@@ -0,0 +1,4 @@
+import type { ModelIndex } from '../model-index';
+import { type ElementView } from '../types';
+import type { ComputedView } from '../types/computed-view';
+export declare function computeElementView(view: ElementView, index: ModelIndex): ComputedView;

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

@@ -0,0 +1,163 @@
+import { anyPass, filter } from 'rambdax';
+import { DefaultElementShape, DefaultThemeColor } from '../types';
+import * as Expression from '../types/expression';
+import { 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) {
+    return [...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 = index.defaultViewOf(id);
+        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);
+    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));
+    return {
+        ...view,
+        nodes,
+        edges
+    };
+}

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

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

package/dist/compute-view/index.js

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

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

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

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

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

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

@@ -0,0 +1,201 @@
+import { anyPass, map, pluck, uniq } from 'rambdax';
+import * as Expr from '../../types/expression';
+import { failExpectedNever, isAncestor } from '../../utils';
+import { isBetween, isIncoming, 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([
+                isBetween(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(isBetween(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

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

@@ -0,0 +1,42 @@
+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/index.d.ts

@@ -0,0 +1,4 @@
+export type * as likec4 from './types';
+export { computeView } from './compute-view';
+export * from './utils';
+export * from './model-index';

package/dist/index.js

@@ -0,0 +1,3 @@
+export { computeView } from './compute-view';
+export * from './utils';
+export * from './model-index';

package/dist/model-index/index.d.ts

@@ -0,0 +1 @@
+export * from './model-index';

package/dist/model-index/index.js

@@ -0,0 +1 @@
+export * from './model-index';

package/dist/model-index/model-index.d.ts

@@ -0,0 +1,30 @@
+import type { Predicate } from 'rambdax';
+import type { Element, ElementView, Fqn, Relation, RelationID, ViewID } from '../types';
+type ModelInput = {
+    elements: Record<Fqn, Element>;
+    relations: Record<RelationID, Relation>;
+    views: Record<ViewID, ElementView>;
+};
+export declare class ModelIndex {
+    private root;
+    private _elements;
+    private _relations;
+    private _defaultElementView;
+    get relations(): Relation[];
+    filterRelations: (predicate: Predicate<Relation>) => Relation[];
+    static from({ elements, relations, views }: ModelInput): ModelIndex;
+    addElement(el: Element): void;
+    private locateTrie;
+    find: (id: Fqn) => Element;
+    children: (id: Fqn) => Element[];
+    siblings: (id: Fqn) => Element[];
+    /**
+     * Ancestors from closest parent to root
+     */
+    ancestors: (id: Fqn) => Element[];
+    rootElements(): Element[];
+    get elements(): Element[];
+    addRelation(rel: Relation): void;
+    defaultViewOf: (id: Fqn) => ViewID | undefined;
+}
+export {};