@likec4/core 0.6.2 → 0.6.3

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,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-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,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 [...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/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,186 @@
+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

@@ -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[];
+}
+export {};

package/dist/model-index/model-index.js

@@ -0,0 +1,143 @@
+import { values } from 'rambdax';
+import invariant from 'tiny-invariant';
+import { parentFqn } from '../utils/fqn';
+function childrenOf(trie) {
+    const children = [];
+    for (const { el } of values(trie.children)) {
+        if (el) {
+            children.push(el);
+        }
+    }
+    return children;
+}
+function asPath(id) {
+    return id.split('.');
+}
+export class ModelIndex {
+    root = {
+        children: {}
+    };
+    _elements = new Set();
+    _relations = new Map();
+    _defaultElementView = new Map();
+    // private _taggedElements = new Map<Tag, Set<Element>>()
+    // private _taggedRelations = new Map<Tag, Set<Relation>>()
+    get relations() {
+        return [...this._relations.values()];
+    }
+    filterRelations = (predicate) => {
+        return [...this._relations.values()].filter(predicate);
+    };
+    static from({ elements, relations, views }) {
+        const index = new ModelIndex();
+        for (const el of Object.values(elements)) {
+            index.addElement(el);
+        }
+        for (const rel of Object.values(relations)) {
+            index.addRelation(rel);
+        }
+        for (const { id, viewOf } of Object.values(views)) {
+            if (viewOf) {
+                const views = index._defaultElementView.get(viewOf) ?? [];
+                views.push(id);
+                index._defaultElementView.set(viewOf, views);
+            }
+        }
+        return index;
+    }
+    addElement(el) {
+        const path = asPath(el.id);
+        let scope = this.root;
+        for (const name of path) {
+            const next = scope.children[name] ?? {
+                children: {}
+            };
+            scope.children[name] = next;
+            scope = next;
+        }
+        scope.el = el;
+        this._elements.add(el);
+    }
+    locateTrie = (id) => {
+        let scope = this.root;
+        for (const name of asPath(id)) {
+            const next = scope.children[name];
+            invariant(next, `Invalid index, Element not found at path ${name} of ${id}`);
+            scope = next;
+        }
+        return scope;
+    };
+    find = (id) => {
+        const trie = this.locateTrie(id);
+        if (!trie.el) {
+            throw new Error(`Invalid index, element not found at path ${id}`);
+        }
+        return trie.el;
+    };
+    children = (id) => {
+        return childrenOf(this.locateTrie(id));
+    };
+    siblings = (id) => {
+        const parent = parentFqn(id);
+        const trie = parent ? this.locateTrie(parent) : this.root;
+        return childrenOf(trie).filter(e => e.id !== id);
+    };
+    /**
+     * Ancestors from closest parent to root
+     */
+    ancestors = (id) => {
+        const path = asPath(id);
+        const ancestors = [];
+        // The root
+        if (path.length === 1) {
+            return ancestors;
+        }
+        // Remove the element itself
+        path.pop();
+        let name = path.shift();
+        let trie = this.root;
+        while (name) {
+            const next = trie.children[name];
+            invariant(next, `Invalid index, Element not found at path ${name} of ${id}`);
+            trie = next;
+            if (!trie.el) {
+                throw new Error(`invalid index, no element ${name} found in ${id}`);
+            }
+            ancestors.unshift(trie.el);
+            name = path.shift();
+        }
+        return ancestors;
+    };
+    // tagged = (tag?: Tag): TaggedResult => {
+    //   return tag ? {
+    //     elements: [...this._taggedElements.get(tag)?.values() ?? []],
+    //     relations: [...this._taggedRelations.get(tag)?.values() ?? []],
+    //   } : {
+    //     elements: uniq([...this._taggedElements.values()].flatMap(s => [...s.values()])),
+    //     relations: uniq([...this._taggedRelations.values()].flatMap(s => [...s.values()]))
+    //   }
+    // }
+    rootElements() {
+        return childrenOf(this.root);
+    }
+    get elements() {
+        return [...this._elements];
+    }
+    // hasElement(fqn: Fqn): boolean {
+    //   return fqn in this._elements
+    // }
+    addRelation(rel) {
+        // Validate source and target
+        this.locateTrie(rel.source);
+        this.locateTrie(rel.target);
+        this._relations.set(rel.id, rel);
+        // for (const tag of rel.tags) {
+        //   const tagged = this._taggedRelations.get(tag) ?? new Set()
+        //   tagged.add(rel)
+        //   this._taggedRelations.set(tag, tagged)
+        // }
+    }
+    defaultViewOf = (id) => {
+        return this._defaultElementView.get(id) ?? [];
+    };
+}

package/dist/types/computed-view.d.ts

@@ -0,0 +1,30 @@
+import type { Opaque } from './opaque';
+import type { ElementShape, Fqn, ThemeColor } from './element';
+import type { RelationID } from './relation';
+import type { ElementView, ViewID, ViewRuleAutoLayout } from './view';
+export type NodeId = Fqn;
+export type EdgeId = Opaque<string, 'EdgeId'>;
+export interface ComputedNode {
+    id: NodeId;
+    parent: NodeId | null;
+    title: string;
+    description?: string;
+    technology?: string;
+    children: NodeId[];
+    shape: ElementShape;
+    color: ThemeColor;
+    navigateTo?: ViewID;
+}
+export interface ComputedEdge {
+    id: EdgeId;
+    parent: NodeId | null;
+    source: NodeId;
+    target: NodeId;
+    label: string | null;
+    relations: RelationID[];
+}
+export interface ComputedView<Node extends ComputedNode = ComputedNode, Edge extends ComputedEdge = ComputedEdge> extends ElementView {
+    autoLayout: ViewRuleAutoLayout['autoLayout'];
+    nodes: Node[];
+    edges: Edge[];
+}

package/dist/types/computed-view.js

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

package/dist/types/diagram.d.ts

@@ -0,0 +1,27 @@
+import type { ComputedEdge, ComputedNode, ComputedView } from './computed-view';
+export type Point = [x: number, y: number];
+export interface DiagramLabel {
+    align: 'left' | 'right' | 'center';
+    fontStyle?: 'bold' | 'normal';
+    fontSize: number;
+    pt: Point;
+    width: number;
+    text: string;
+}
+export interface DiagramNode extends ComputedNode {
+    size: {
+        width: number;
+        height: number;
+    };
+    labels: DiagramLabel[];
+    position: Point;
+}
+export interface DiagramEdge extends ComputedEdge {
+    points: Point[];
+    headArrow?: Point[];
+    labels: DiagramLabel[];
+}
+export interface DiagramView extends ComputedView<DiagramNode, DiagramEdge> {
+    width: number;
+    height: number;
+}

package/dist/types/diagram.js

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

package/dist/types/element.d.ts

@@ -0,0 +1,26 @@
+import type { Opaque } from './opaque';
+export type Fqn = Opaque<string, 'Fqn'>;
+export declare function Fqn(name: string, parent?: Fqn | null): Fqn;
+export type ElementKind = Opaque<string, 'ElementKind'>;
+export type ThemeColor = 'primary' | 'secondary' | 'muted';
+export type ElementShape = 'rectangle' | 'person' | 'browser' | 'cylinder' | 'storage' | 'queue';
+export declare const DefaultThemeColor: ThemeColor;
+export declare const DefaultElementShape: ElementShape;
+export interface ElementStyle {
+    shape?: ElementShape;
+}
+export type Tag = Opaque<string, 'Tag'>;
+export interface TagSpec {
+    readonly id: Tag;
+    readonly style: ElementStyle;
+}
+export interface Element {
+    readonly id: Fqn;
+    readonly kind: ElementKind;
+    readonly title: string;
+    readonly description?: string;
+    readonly technology?: string;
+    readonly tags?: Tag[];
+    readonly shape?: ElementShape;
+    readonly color?: ThemeColor;
+}

package/dist/types/element.js

@@ -0,0 +1,5 @@
+export function Fqn(name, parent) {
+    return (parent ? parent + '.' + name : name);
+}
+export const DefaultThemeColor = 'primary';
+export const DefaultElementShape = 'rectangle';

package/dist/types/expression.d.ts

@@ -0,0 +1,43 @@
+import type { Fqn } from './element';
+interface BaseExr {
+    element?: never;
+    isDescedants?: never;
+    wildcard?: never;
+    source?: never;
+    target?: never;
+    inout?: never;
+    incoming?: never;
+    outgoing?: never;
+}
+export interface ElementRefExpr extends Omit<BaseExr, 'element' | 'isDescedants'> {
+    element: Fqn;
+    isDescedants: boolean;
+}
+export declare function isElementRef(expr: Expression): expr is ElementRefExpr;
+export interface WildcardExpr extends Omit<BaseExr, 'wildcard'> {
+    wildcard: true;
+}
+export declare function isWildcard(expr: Expression): expr is WildcardExpr;
+export type ElementExpression = ElementRefExpr | WildcardExpr;
+export declare function isElement(expr: Expression): expr is ElementExpression;
+export interface RelationExpr extends Omit<BaseExr, 'source' | 'target'> {
+    source: ElementExpression;
+    target: ElementExpression;
+}
+export declare function isRelation(expr: Expression): expr is RelationExpr;
+export interface InOutExpr extends Omit<BaseExr, 'inout'> {
+    inout: ElementExpression;
+}
+export declare function isInOut(expr: Expression): expr is InOutExpr;
+export interface IncomingExpr extends Omit<BaseExr, 'incoming'> {
+    incoming: ElementExpression;
+}
+export declare function isIncoming(expr: Expression): expr is IncomingExpr;
+export interface OutgoingExpr extends Omit<BaseExr, 'outgoing'> {
+    outgoing: ElementExpression;
+}
+export declare function isOutgoing(expr: Expression): expr is OutgoingExpr;
+export type AnyRelationExpression = RelationExpr | InOutExpr | IncomingExpr | OutgoingExpr;
+export declare function isAnyRelation(expr: Expression): expr is AnyRelationExpression;
+export type Expression = ElementExpression | AnyRelationExpression;
+export {};

package/dist/types/expression.js

@@ -0,0 +1,24 @@
+export function isElementRef(expr) {
+    return 'element' in expr && 'isDescedants' in expr;
+}
+export function isWildcard(expr) {
+    return 'wildcard' in expr;
+}
+export function isElement(expr) {
+    return isElementRef(expr) || isWildcard(expr);
+}
+export function isRelation(expr) {
+    return 'source' in expr && 'target' in expr;
+}
+export function isInOut(expr) {
+    return 'inout' in expr;
+}
+export function isIncoming(expr) {
+    return 'incoming' in expr;
+}
+export function isOutgoing(expr) {
+    return 'outgoing' in expr;
+}
+export function isAnyRelation(expr) {
+    return isRelation(expr) || isInOut(expr) || isIncoming(expr) || isOutgoing(expr);
+}

package/dist/types/index.d.ts

@@ -0,0 +1,10 @@
+export { Fqn, DefaultThemeColor, DefaultElementShape } from './element';
+export { isViewRuleExpression, isViewRuleStyle } from './view';
+export type * from './opaque';
+export type * from './element';
+export type * from './relation';
+export type * from './model';
+export type * from './view';
+export type * from './expression';
+export type * from './computed-view';
+export type * from './diagram';

package/dist/types/index.js

@@ -0,0 +1,2 @@
+export { Fqn, DefaultThemeColor, DefaultElementShape } from './element';
+export { isViewRuleExpression, isViewRuleStyle } from './view';

package/dist/types/model.d.ts

@@ -0,0 +1,9 @@
+import type { Fqn, Element } from './element';
+import type { RelationID, Relation } from './relation';
+import type { ViewID } from './view';
+import type { ComputedView } from '../compute-view';
+export interface LikeC4Model {
+    elements: Record<Fqn, Element>;
+    relations: Record<RelationID, Relation>;
+    views: Record<ViewID, ComputedView>;
+}

package/dist/types/model.js

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

package/dist/types/opaque.d.ts

@@ -0,0 +1,102 @@
+declare const tag: unique symbol;
+declare type Tagged<Token> = {
+    readonly [tag]: Token;
+};
+/**
+Create an opaque type, which hides its internal details from the public, and can only be created by being used explicitly.
+
+The generic type parameter can be anything. It doesn't have to be an object.
+
+[Read more about opaque types.](https://codemix.com/opaque-types-in-javascript/)
+
+There have been several discussions about adding this feature to TypeScript via the `opaque type` operator, similar to how Flow does it. Unfortunately, nothing has (yet) moved forward:
+    - [Microsoft/TypeScript#202](https://github.com/microsoft/TypeScript/issues/202)
+    - [Microsoft/TypeScript#15408](https://github.com/Microsoft/TypeScript/issues/15408)
+    - [Microsoft/TypeScript#15807](https://github.com/Microsoft/TypeScript/issues/15807)
+
+@example
+```
+import type {Opaque} from 'type-fest';
+
+type AccountNumber = Opaque<number, 'AccountNumber'>;
+type AccountBalance = Opaque<number, 'AccountBalance'>;
+
+// The `Token` parameter allows the compiler to differentiate between types, whereas "unknown" will not. For example, consider the following structures:
+type ThingOne = Opaque<string>;
+type ThingTwo = Opaque<string>;
+
+// To the compiler, these types are allowed to be cast to each other as they have the same underlying type. They are both `string & { __opaque__: unknown }`.
+// To avoid this behaviour, you would instead pass the "Token" parameter, like so.
+type NewThingOne = Opaque<string, 'ThingOne'>;
+type NewThingTwo = Opaque<string, 'ThingTwo'>;
+
+// Now they're completely separate types, so the following will fail to compile.
+function createNewThingOne (): NewThingOne {
+    // As you can see, casting from a string is still allowed. However, you may not cast NewThingOne to NewThingTwo, and vice versa.
+    return 'new thing one' as NewThingOne;
+}
+
+// This will fail to compile, as they are fundamentally different types.
+const thingTwo = createNewThingOne() as NewThingTwo;
+
+// Here's another example of opaque typing.
+function createAccountNumber(): AccountNumber {
+    return 2 as AccountNumber;
+}
+
+function getMoneyForAccount(accountNumber: AccountNumber): AccountBalance {
+    return 4 as AccountBalance;
+}
+
+// This will compile successfully.
+getMoneyForAccount(createAccountNumber());
+
+// But this won't, because it has to be explicitly passed as an `AccountNumber` type.
+getMoneyForAccount(2);
+
+// You can use opaque values like they aren't opaque too.
+const accountNumber = createAccountNumber();
+
+// This will not compile successfully.
+const newAccountNumber = accountNumber + 2;
+
+// As a side note, you can (and should) use recursive types for your opaque types to make them stronger and hopefully easier to type.
+type Person = {
+    id: Opaque<number, Person>;
+    name: string;
+};
+```
+
+@category Type
+*/
+export type Opaque<Type, Token = unknown> = Type & Tagged<Token>;
+/**
+Revert an opaque type back to its original type by removing the readonly `[tag]`.
+
+Why is this necessary?
+
+1. Use an `Opaque` type as object keys
+2. Prevent TS4058 error: "Return type of exported function has or is using name X from external module Y but cannot be named"
+
+@example
+```
+import type {Opaque, UnwrapOpaque} from 'type-fest';
+
+type AccountType = Opaque<'SAVINGS' | 'CHECKING', 'AccountType'>;
+
+const moneyByAccountType: Record<UnwrapOpaque<AccountType>, number> = {
+    SAVINGS: 99,
+    CHECKING: 0.1
+};
+
+// Without UnwrapOpaque, the following expression would throw a type error.
+const money = moneyByAccountType.SAVINGS; // TS error: Property 'SAVINGS' does not exist
+
+// Attempting to pass an non-Opaque type to UnwrapOpaque will raise a type error.
+type WontWork = UnwrapOpaque<string>;
+```
+
+@category Type
+*/
+export type UnwrapOpaque<OpaqueType extends Tagged<unknown>> = OpaqueType extends Opaque<infer Type, OpaqueType[typeof tag]> ? Type : OpaqueType;
+export {};

package/dist/types/opaque.js

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

package/dist/types/relation.d.ts

@@ -0,0 +1,10 @@
+import type { Opaque } from './opaque';
+import type { Fqn, Tag } from './element';
+export type RelationID = Opaque<string, 'RelationID'>;
+export interface Relation {
+    readonly id: RelationID;
+    readonly source: Fqn;
+    readonly target: Fqn;
+    readonly title: string;
+    readonly tags?: Tag[];
+}

package/dist/types/relation.js

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

package/dist/types/view.d.ts

@@ -0,0 +1,29 @@
+import type { Opaque } from './opaque';
+import type { ElementShape, Fqn, ThemeColor } from './element';
+import type { ElementExpression, Expression } from './expression';
+export type ViewID = Opaque<string, 'ViewID'>;
+export interface ViewRuleExpression {
+    isInclude: boolean;
+    exprs: Expression[];
+}
+export declare function isViewRuleExpression(rule: ViewRule): rule is ViewRuleExpression;
+export interface ViewRuleStyle {
+    targets: ElementExpression[];
+    style: {
+        color?: ThemeColor;
+        shape?: ElementShape;
+    };
+}
+export declare function isViewRuleStyle(rule: ViewRule): rule is ViewRuleStyle;
+export interface ViewRuleAutoLayout {
+    autoLayout: 'TB' | 'BT' | 'LR' | 'RL';
+}
+export declare function isViewRuleAutoLayout(rule: ViewRule): rule is ViewRuleAutoLayout;
+export type ViewRule = ViewRuleExpression | ViewRuleStyle | ViewRuleAutoLayout;
+export interface ElementView {
+    readonly id: ViewID;
+    readonly viewOf?: Fqn;
+    readonly title?: string;
+    readonly description?: string;
+    readonly rules: ViewRule[];
+}

package/dist/types/view.js

@@ -0,0 +1,9 @@
+export function isViewRuleExpression(rule) {
+    return 'exprs' in rule && 'isInclude' in rule;
+}
+export function isViewRuleStyle(rule) {
+    return 'style' in rule && 'targets' in rule;
+}
+export function isViewRuleAutoLayout(rule) {
+    return 'autoLayout' in rule;
+}

package/dist/utils/fqn.d.ts

@@ -0,0 +1,10 @@
+import type { Element, Fqn } from '../types';
+export declare function nameFromFqn(fqn: Fqn): string;
+export declare function isAncestor(...args: [ancestor: Fqn, another: Fqn] | [ancestor: Element, another: Element]): boolean;
+export declare function isSameHierarchy(...args: [one: Fqn, another: Fqn] | [one: Element, another: Element]): boolean;
+export declare function commonAncestor(first: Fqn, second: Fqn): Fqn | null;
+export declare function parentFqn(fqn: Fqn): Fqn | null;
+export declare const compareFqnHierarchically: (a: string, b: string) => number;
+export declare const compareByFqnHierarchically: <T extends {
+    id: Fqn;
+}>(a: T, b: T) => number;

package/dist/utils/fqn.js

@@ -0,0 +1,51 @@
+import { isString } from './guards';
+export function nameFromFqn(fqn) {
+    const lastDot = fqn.lastIndexOf('.');
+    if (lastDot > 0) {
+        return fqn.slice(lastDot + 1);
+    }
+    else {
+        return fqn;
+    }
+}
+export function isAncestor(...args) {
+    const ancestor = isString(args[0]) ? args[0] : args[0].id;
+    const another = isString(args[1]) ? args[1] : args[1].id;
+    return another.startsWith(ancestor + '.');
+}
+export function isSameHierarchy(...args) {
+    const one = isString(args[0]) ? args[0] : args[0].id;
+    const another = isString(args[1]) ? args[1] : args[1].id;
+    return one === another || another.startsWith(one + '.') || one.startsWith(another + '.');
+}
+export function commonAncestor(first, second) {
+    const a = first.split('.');
+    const b = second.split('.');
+    let ancestor = null;
+    while (a.length > 1 && b.length > 1 && !!a[0] && a[0] === b[0]) {
+        ancestor = (ancestor ? `${ancestor}.${a[0]}` : a[0]);
+        a.shift();
+        b.shift();
+    }
+    return ancestor;
+}
+export function parentFqn(fqn) {
+    const lastDot = fqn.lastIndexOf('.');
+    if (lastDot > 0) {
+        return fqn.substring(0, lastDot);
+    }
+    return null;
+}
+export const compareFqnHierarchically = (a, b) => {
+    const depthA = a.split('.').length;
+    const depthB = b.split('.').length;
+    if (depthA === depthB) {
+        return a.localeCompare(b);
+    }
+    else {
+        return depthA - depthB;
+    }
+};
+export const compareByFqnHierarchically = (a, b) => {
+    return compareFqnHierarchically(a.id, b.id);
+};

package/dist/utils/guards.d.ts

@@ -0,0 +1,3 @@
+export declare function isString(value: unknown): value is string;
+export declare function failExpectedNever(arg: never): never;
+export declare function ignoreNeverInRuntime(arg: never): void;

package/dist/utils/guards.js

@@ -0,0 +1,10 @@
+export function isString(value) {
+    return typeof value === 'string';
+}
+export function failExpectedNever(arg) {
+    throw new Error(`Unexpected value: ${JSON.stringify(arg)}`);
+}
+export function ignoreNeverInRuntime(arg) {
+    console.warn(`Unexpected and ignored value: ${JSON.stringify(arg)}`);
+    // throw new Error(`Unexpected value: ${arg}`);
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,3 @@
+export * from './fqn';
+export * from './guards';
+export * as Relations from './relations';

package/dist/utils/index.js

@@ -0,0 +1,3 @@
+export * from './fqn';
+export * from './guards';
+export * as Relations from './relations';

package/dist/utils/relations.d.ts

@@ -0,0 +1,16 @@
+import type { Fqn } from '../types';
+type Relation = {
+    source: Fqn;
+    target: Fqn;
+};
+export declare const compareRelations: <T extends {
+    source: Fqn;
+    target: Fqn;
+}>(a: T, b: T) => number;
+export declare const isInside: (parent: Fqn) => (rel: Relation) => boolean;
+export declare const isBetween: (source: Fqn, target: Fqn) => (rel: Relation) => boolean;
+export declare const isAnyBetween: (source: Fqn, target: Fqn) => import("rambdax").Predicate<Relation>;
+export declare const isIncoming: (target: Fqn) => (rel: Relation) => boolean;
+export declare const isOutgoing: (source: Fqn) => (rel: Relation) => boolean;
+export declare const isAnyInOut: (source: Fqn) => import("rambdax").Predicate<Relation>;
+export {};

package/dist/utils/relations.js

@@ -0,0 +1,36 @@
+import { either } from 'rambdax';
+import { compareFqnHierarchically } from './fqn';
+export const compareRelations = (a, b) => {
+    return (compareFqnHierarchically(a.source, b.source) || compareFqnHierarchically(a.target, b.target));
+};
+export const isInside = (parent) => {
+    const prefix = parent + '.';
+    return (rel) => {
+        return rel.source.startsWith(prefix) && rel.target.startsWith(prefix);
+    };
+};
+export const isBetween = (source, target) => {
+    const sourcePrefix = source + '.';
+    const targetPrefix = target + '.';
+    return (rel) => {
+        return ((rel.source + '.').startsWith(sourcePrefix) && (rel.target + '.').startsWith(targetPrefix));
+    };
+};
+export const isAnyBetween = (source, target) => {
+    return either(isBetween(source, target), isBetween(target, source));
+};
+export const isIncoming = (target) => {
+    const targetPrefix = target + '.';
+    return (rel) => {
+        return (!(rel.source + '.').startsWith(targetPrefix) && (rel.target + '.').startsWith(targetPrefix));
+    };
+};
+export const isOutgoing = (source) => {
+    const sourcePrefix = source + '.';
+    return (rel) => {
+        return ((rel.source + '.').startsWith(sourcePrefix) && !(rel.target + '.').startsWith(sourcePrefix));
+    };
+};
+export const isAnyInOut = (source) => {
+    return either(isIncoming(source), isOutgoing(source));
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@likec4/core",
-  "version": "0.6.2",
+  "version": "0.6.3",
   "license": "MIT",
   "bugs": "https://github.com/likec4/likec4/issues",
   "homepage": "https://like-c4.dev",