@likec4/core 0.6.2 → 0.7.0

package/dist/__test__/data.d.ts

@@ -0,0 +1,174 @@
+import { ModelIndex } from '../model-index';
+import type { ElementKind, ElementView, Fqn, RelationID } from '../types';
+/**
+              ┌──────────────────────────────────────────────────┐
+              │                      cloud                       │
+              │  ┌───────────────────────────────────────────┐   │
+              │  │                 frontend                  │   │
+┏━━━━━━━━━━┓  │  │   ┏━━━━━━━━━━━━━┓   ┏━━━━━━━━━━━━━━━━┓    │   │   ┏━━━━━━━━━━━┓
+┃          ┃  │  │   ┃             ┃   ┃                ┃    │   │   ┃           ┃
+┃ customer ┃──┼──┼──▶┃  dashboard  ┃   ┃   adminpanel   ┃◀───┼───┼───┃  support  ┃
+┃          ┃  │  │   ┃             ┃   ┃                ┃    │   │   ┃           ┃
+┗━━━━━━━━━━┛  │  │   ┗━━━━━━┳━━━━━━┛   ┗━━━━━━━━┳━━━━━━━┛    │   │   ┗━━━━━━━━━━━┛
+              │  └──────────┼───────────────────┼────────────┘   │
+              │             ├───────────────────┘                │
+              │             │                                    │
+              │  ┌──────────┼────────────────────────────────┐   │
+              │  │          ▼       backend                  │   │
+              │  │   ┏━━━━━━━━━━━━━┓       ┏━━━━━━━━━━━━━┓   │   │
+              │  │   ┃             ┃       ┃             ┃   │   │
+              │  │   ┃  graphlql   ┃──────▶┃   storage   ┃   │   │
+              │  │   ┃             ┃       ┃             ┃   │   │
+              │  │   ┗━━━━━━━━━━━━━┛       ┗━━━━━━┳━━━━━━┛   │   │
+              │  └────────────────────────────────┼──────────┘   │
+              └───────────────────────────────────┼──────────────┘
+                                                  │
+                                        ┌─────────┼─────────┐
+                                        │ amazon  │         │
+                                        │         ▼         │
+                                        │ ┏━━━━━━━━━━━━━━┓  │
+                                        │ ┃              ┃  │
+                                        │ ┃      s3      ┃  │
+                                        │ ┃              ┃  │
+                                        │ ┗━━━━━━━━━━━━━━┛  │
+                                        └───────────────────┘
+
+specification {
+  element actor
+  element system
+  element component
+}
+
+model {
+
+  actor customer
+  actor support
+
+  system cloud {
+    component backend {
+      component graphql
+      component storage
+
+      graphql -> storage
+    }
+
+    component frontend {
+      component dashboard {
+        -> graphql
+      }
+      component adminPanel {
+        -> graphql
+      }
+    }
+  }
+
+  customer -> dashboard
+  support -> adminPanel
+
+  system amazon {
+    component s3
+
+    cloud.backend.storage -> s3
+  }
+
+}
+
+ */
+export declare const fakeElements: {
+    amazon: {
+        id: Fqn;
+        kind: ElementKind;
+        title: string;
+    };
+    cloud: {
+        id: Fqn;
+        kind: ElementKind;
+        title: string;
+    };
+    customer: {
+        id: Fqn;
+        kind: ElementKind;
+        title: string;
+    };
+    support: {
+        id: Fqn;
+        kind: ElementKind;
+        title: string;
+    };
+    'amazon.s3': {
+        id: Fqn;
+        kind: ElementKind;
+        title: string;
+    };
+    'cloud.backend': {
+        id: Fqn;
+        kind: ElementKind;
+        title: string;
+    };
+    'cloud.frontend': {
+        id: Fqn;
+        kind: ElementKind;
+        title: string;
+    };
+    'cloud.backend.graphql': {
+        id: Fqn;
+        kind: ElementKind;
+        title: string;
+    };
+    'cloud.backend.storage': {
+        id: Fqn;
+        kind: ElementKind;
+        title: string;
+    };
+    'cloud.frontend.adminPanel': {
+        id: Fqn;
+        kind: ElementKind;
+        title: string;
+    };
+    'cloud.frontend.dashboard': {
+        id: Fqn;
+        kind: ElementKind;
+        title: string;
+    };
+};
+export declare const fakeRelations: {
+    'customer:cloud.frontend.dashboard': {
+        id: RelationID;
+        source: Fqn;
+        target: Fqn;
+        title: string;
+    };
+    'support:cloud.frontend.adminPanel': {
+        id: RelationID;
+        source: Fqn;
+        target: Fqn;
+        title: string;
+    };
+    'cloud.backend.storage:amazon.s3': {
+        id: RelationID;
+        source: Fqn;
+        target: Fqn;
+        title: string;
+    };
+    'cloud.backend.graphql:cloud.backend.storage': {
+        id: RelationID;
+        source: Fqn;
+        target: Fqn;
+        title: string;
+    };
+    'cloud.frontend.dashboard:cloud.backend.graphql': {
+        id: RelationID;
+        source: Fqn;
+        target: Fqn;
+        title: string;
+    };
+    'cloud.frontend.adminPanel:cloud.backend.graphql': {
+        id: RelationID;
+        source: Fqn;
+        target: Fqn;
+        title: string;
+    };
+};
+export declare const fakeElementView: ElementView;
+export declare const fakeModel: () => ModelIndex;
+//# sourceMappingURL=data.d.ts.map

package/dist/__test__/data.js

@@ -0,0 +1,188 @@
+import { ModelIndex } from '../model-index';
+/**
+              ┌──────────────────────────────────────────────────┐
+              │                      cloud                       │
+              │  ┌───────────────────────────────────────────┐   │
+              │  │                 frontend                  │   │
+┏━━━━━━━━━━┓  │  │   ┏━━━━━━━━━━━━━┓   ┏━━━━━━━━━━━━━━━━┓    │   │   ┏━━━━━━━━━━━┓
+┃          ┃  │  │   ┃             ┃   ┃                ┃    │   │   ┃           ┃
+┃ customer ┃──┼──┼──▶┃  dashboard  ┃   ┃   adminpanel   ┃◀───┼───┼───┃  support  ┃
+┃          ┃  │  │   ┃             ┃   ┃                ┃    │   │   ┃           ┃
+┗━━━━━━━━━━┛  │  │   ┗━━━━━━┳━━━━━━┛   ┗━━━━━━━━┳━━━━━━━┛    │   │   ┗━━━━━━━━━━━┛
+              │  └──────────┼───────────────────┼────────────┘   │
+              │             ├───────────────────┘                │
+              │             │                                    │
+              │  ┌──────────┼────────────────────────────────┐   │
+              │  │          ▼       backend                  │   │
+              │  │   ┏━━━━━━━━━━━━━┓       ┏━━━━━━━━━━━━━┓   │   │
+              │  │   ┃             ┃       ┃             ┃   │   │
+              │  │   ┃  graphlql   ┃──────▶┃   storage   ┃   │   │
+              │  │   ┃             ┃       ┃             ┃   │   │
+              │  │   ┗━━━━━━━━━━━━━┛       ┗━━━━━━┳━━━━━━┛   │   │
+              │  └────────────────────────────────┼──────────┘   │
+              └───────────────────────────────────┼──────────────┘
+                                                  │
+                                        ┌─────────┼─────────┐
+                                        │ amazon  │         │
+                                        │         ▼         │
+                                        │ ┏━━━━━━━━━━━━━━┓  │
+                                        │ ┃              ┃  │
+                                        │ ┃      s3      ┃  │
+                                        │ ┃              ┃  │
+                                        │ ┗━━━━━━━━━━━━━━┛  │
+                                        └───────────────────┘
+
+specification {
+  element actor
+  element system
+  element component
+}
+
+model {
+
+  actor customer
+  actor support
+
+  system cloud {
+    component backend {
+      component graphql
+      component storage
+
+      graphql -> storage
+    }
+
+    component frontend {
+      component dashboard {
+        -> graphql
+      }
+      component adminPanel {
+        -> graphql
+      }
+    }
+  }
+
+  customer -> dashboard
+  support -> adminPanel
+
+  system amazon {
+    component s3
+
+    cloud.backend.storage -> s3
+  }
+
+}
+
+ */
+export const fakeElements = {
+    amazon: {
+        id: 'amazon',
+        kind: 'system',
+        title: 'amazon'
+    },
+    cloud: {
+        id: 'cloud',
+        kind: 'system',
+        title: 'cloud'
+    },
+    customer: {
+        id: 'customer',
+        kind: 'actor',
+        title: 'customer'
+    },
+    support: {
+        id: 'support',
+        kind: 'actor',
+        title: 'support'
+    },
+    'amazon.s3': {
+        id: 'amazon.s3',
+        kind: 'component',
+        title: 's3'
+    },
+    'cloud.backend': {
+        id: 'cloud.backend',
+        kind: 'component',
+        title: 'backend'
+    },
+    'cloud.frontend': {
+        id: 'cloud.frontend',
+        kind: 'component',
+        title: 'frontend'
+    },
+    'cloud.backend.graphql': {
+        id: 'cloud.backend.graphql',
+        kind: 'component',
+        title: 'graphql'
+    },
+    'cloud.backend.storage': {
+        id: 'cloud.backend.storage',
+        kind: 'component',
+        title: 'storage'
+    },
+    'cloud.frontend.adminPanel': {
+        id: 'cloud.frontend.adminPanel',
+        kind: 'component',
+        title: 'adminPanel'
+    },
+    'cloud.frontend.dashboard': {
+        id: 'cloud.frontend.dashboard',
+        kind: 'component',
+        title: 'dashboard'
+    }
+};
+export const fakeRelations = {
+    'customer:cloud.frontend.dashboard': {
+        id: 'customer:cloud.frontend.dashboard',
+        source: 'customer',
+        target: 'cloud.frontend.dashboard',
+        title: ''
+    },
+    'support:cloud.frontend.adminPanel': {
+        id: 'support:cloud.frontend.adminPanel',
+        source: 'support',
+        target: 'cloud.frontend.adminPanel',
+        title: ''
+    },
+    'cloud.backend.storage:amazon.s3': {
+        id: 'cloud.backend.storage:amazon.s3',
+        source: 'cloud.backend.storage',
+        target: 'amazon.s3',
+        title: ''
+    },
+    'cloud.backend.graphql:cloud.backend.storage': {
+        id: 'cloud.backend.graphql:cloud.backend.storage',
+        source: 'cloud.backend.graphql',
+        target: 'cloud.backend.storage',
+        title: ''
+    },
+    'cloud.frontend.dashboard:cloud.backend.graphql': {
+        id: 'cloud.frontend.dashboard:cloud.backend.graphql',
+        source: 'cloud.frontend.dashboard',
+        target: 'cloud.backend.graphql',
+        title: ''
+    },
+    'cloud.frontend.adminPanel:cloud.backend.graphql': {
+        id: 'cloud.frontend.adminPanel:cloud.backend.graphql',
+        source: 'cloud.frontend.adminPanel',
+        target: 'cloud.backend.graphql',
+        title: ''
+    }
+};
+export const fakeElementView = {
+    id: 'fakeView',
+    title: '',
+    viewOf: 'cloud',
+    rules: [
+        {
+            isInclude: true,
+            exprs: [{ wildcard: true }]
+        }
+    ]
+};
+export const fakeModel = () => ModelIndex.from({
+    elements: fakeElements,
+    relations: fakeRelations,
+    views: {
+        [fakeElementView.id]: fakeElementView
+    }
+});

package/dist/__test__/index.d.ts

@@ -0,0 +1,2 @@
+export * from './data';
+//# sourceMappingURL=index.d.ts.map

package/dist/__test__/index.js

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

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

@@ -0,0 +1,8 @@
+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[];
+}
+//# sourceMappingURL=EdgeBuilder.d.ts.map

package/dist/compute-view/EdgeBuilder.js

@@ -0,0 +1,34 @@
+import { equals, head, keys, pluck, reject } from 'rambdax';
+import { commonAncestor, compareFqnHierarchically } from '../utils/fqn';
+import { compareRelations } from '../utils/relations';
+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)
+            .flatMap(source => {
+            const targets = this._relationsObj[source] ?? {};
+            return keys(targets).map(target => {
+                const relations = (targets[target] ?? []).sort(compareRelations);
+                const label = head(reject(equals(''), pluck('title', relations))) ?? null;
+                return {
+                    id: `${source}:${target}`,
+                    parent: commonAncestor(source, target),
+                    source,
+                    target,
+                    label,
+                    relations: pluck('id', relations)
+                };
+            });
+        })
+            .sort(compareRelations)
+            .reverse();
+    }
+}

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

@@ -0,0 +1,12 @@
+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 {};
+//# sourceMappingURL=compute.d.ts.map

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

@@ -0,0 +1,5 @@
+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;
+//# sourceMappingURL=compute.element-view.d.ts.map

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

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

@@ -0,0 +1,3 @@
+export { computeView, computeViews } from './compute';
+export type * from '../types/computed-view';
+//# sourceMappingURL=index.d.ts.map

package/dist/compute-view/index.js

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

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

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

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,11 @@
+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