@likec4/core 0.6.2 → 0.7.0

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,3 @@
+import type { ComputedEdge, ComputedNode, Fqn } from '../../types';
+export declare function sortNodes(_nodes: Map<Fqn, ComputedNode>, edges: ComputedEdge[]): ComputedNode[];
+//# sourceMappingURL=sortNodes.d.ts.map

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,5 @@
+export type * from './types';
+export * from './compute-view';
+export * from './utils';
+export * from './model-index';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

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

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

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

package/dist/model-index/ModelIndex.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/model-index/index.d.ts

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

package/dist/model-index/index.js

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

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

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

package/dist/types/computed-view.js

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

package/dist/types/diagram.d.ts

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

package/dist/types/diagram.js

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

package/dist/types/element.d.ts

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

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

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,11 @@
+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';
+//# sourceMappingURL=index.d.ts.map

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,10 @@
+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>;
+}
+//# sourceMappingURL=model.d.ts.map

package/dist/types/model.js

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