@likec4/core 0.6.1 → 0.6.2

package/dist/compute-view/utils/sortNodes.spec.js

@@ -1,267 +0,0 @@
-import { Graph, alg } from '@dagrejs/graphlib';
-import { indexBy, pluck, toPairs } from 'rambdax';
-import { describe, expect, it } from 'vitest';
-import { commonAncestor, parentFqn } from '../../utils';
-import { sortNodes } from './sortNodes';
-describe('sortNodes', () => {
-    it('should do topological sort', () => {
-        const g = new Graph({
-            compound: true,
-            directed: true,
-            multigraph: false
-        });
-        g.setNode('customer');
-        g.setNode('cloud');
-        g.setNode('cloud.frontend');
-        g.setEdge('cloud', 'cloud.frontend');
-        g.setNode('cloud.backend');
-        g.setEdge('cloud', 'cloud.backend');
-        g.setNode('cloud.backend.graphql');
-        g.setEdge('cloud.backend', 'cloud.backend.graphql');
-        g.setNode('cloud.backend.storage');
-        g.setEdge('cloud.backend', 'cloud.backend.storage');
-        g.setEdge('cloud.backend.graphql', 'cloud.backend.storage');
-        g.setEdge('cloud.frontend', 'cloud.backend.graphql');
-        g.setEdge('cloud.frontend', 'cloud.backend');
-        g.setEdge('customer', 'cloud.frontend');
-        g.setEdge('customer', 'cloud');
-        expect(alg.topsort(g)).toEqual([
-            'customer',
-            'cloud',
-            'cloud.frontend',
-            'cloud.backend',
-            'cloud.backend.graphql',
-            'cloud.backend.storage'
-        ]);
-    });
-    const testnodes = (_nodes, _edges = []) => {
-        const nodesreg = indexBy(n => n.id, _nodes.map(nd => ({
-            parent: null,
-            children: [],
-            ...nd
-        })));
-        const edges = _edges.map(([source, target]) => {
-            let parent = commonAncestor(source, target);
-            while (parent) {
-                if (parent in nodesreg) {
-                    break;
-                }
-                parent = parentFqn(parent);
-            }
-            return {
-                parent,
-                source,
-                target
-            };
-        });
-        return sortNodes(new Map(toPairs(nodesreg)), edges);
-    };
-    const expectSorting = (_nodes, _edges = []) => expect(testnodes(_nodes, _edges).map(n => n.id));
-    describe('two nodes inside', () => {
-        const nodes = [
-            {
-                id: 'cloud'
-            },
-            {
-                id: 'customer'
-            },
-            {
-                id: 'cloud.backend',
-                parent: 'cloud'
-            },
-            {
-                id: 'cloud.frontend',
-                parent: 'cloud'
-            }
-        ];
-        it('should sort hierarchically, if no edges', () => {
-            expectSorting(nodes).toEqual(['customer', 'cloud', 'cloud.backend', 'cloud.frontend']);
-        });
-        it('should sort nested nodes using edges', () => {
-            expectSorting(nodes, [['cloud.frontend', 'cloud.backend']]).toEqual([
-                'customer',
-                'cloud',
-                'cloud.frontend',
-                'cloud.backend'
-            ]);
-        });
-        it('should sort nodes using edges', () => {
-            expectSorting(nodes, [
-                ['customer', 'cloud.frontend'],
-                ['cloud.frontend', 'cloud.backend']
-            ]).toEqual(['customer', 'cloud', 'cloud.frontend', 'cloud.backend']);
-        });
-    });
-    describe('three nodes inside', () => {
-        const nodes = [
-            {
-                id: 'cloud'
-            },
-            {
-                id: 'customer'
-            },
-            {
-                id: 'amazon'
-            },
-            {
-                id: 'cloud.db',
-                parent: 'cloud'
-            },
-            {
-                id: 'cloud.backend',
-                parent: 'cloud'
-            },
-            {
-                id: 'cloud.frontend',
-                parent: 'cloud'
-            }
-        ];
-        it('should sort hierarchically if no edges and source order', () => {
-            const sorted = testnodes(nodes);
-            expect(pluck('id', sorted)).toEqual([
-                'customer',
-                'amazon',
-                'cloud',
-                'cloud.db',
-                'cloud.backend',
-                'cloud.frontend'
-            ]);
-            const cloud = sorted[2];
-            expect(cloud).toMatchObject({
-                id: 'cloud',
-                parent: null,
-                children: ['cloud.db', 'cloud.backend', 'cloud.frontend']
-            });
-        });
-        it('should sort nested nodes using edges', () => {
-            const sorted = testnodes(nodes, [
-                ['cloud.frontend', 'cloud.backend'],
-                ['cloud.backend', 'cloud.db']
-            ]);
-            expect(pluck('id', sorted)).toEqual([
-                'customer',
-                'amazon',
-                'cloud',
-                'cloud.frontend',
-                'cloud.backend',
-                'cloud.db'
-            ]);
-            const cloud = sorted[2];
-            expect(cloud).toMatchObject({
-                id: 'cloud',
-                parent: null,
-                children: ['cloud.frontend', 'cloud.backend', 'cloud.db']
-            });
-        });
-        it('should sort nodes using edges', () => {
-            expectSorting(nodes, [
-                ['customer', 'cloud.frontend'],
-                ['cloud.frontend', 'cloud.backend'],
-                ['cloud.backend', 'cloud.db'],
-                ['cloud.db', 'amazon']
-            ]).toEqual(['customer', 'cloud', 'cloud.frontend', 'cloud.backend', 'cloud.db', 'amazon']);
-        });
-        it('should sort nodes using edges and ignore cycles', () => {
-            expectSorting(nodes, [
-                ['customer', 'cloud.frontend'],
-                ['cloud.frontend', 'cloud.backend'],
-                ['cloud.backend', 'cloud.db'],
-                ['cloud.db', 'amazon'],
-                ['amazon', 'cloud.backend']
-            ]).toEqual(['customer', 'cloud', 'cloud.frontend', 'cloud.backend', 'cloud.db', 'amazon']);
-        });
-    });
-    describe('data from test model', () => {
-        const nodes = [
-            {
-                id: 'amazon'
-            },
-            {
-                id: 'cloud'
-            },
-            {
-                id: 'customer'
-            },
-            {
-                id: 'support'
-            },
-            {
-                id: 'cloud.backend',
-                parent: 'cloud'
-            },
-            {
-                id: 'amazon.rds',
-                parent: 'amazon'
-            },
-            {
-                id: 'cloud.backend.graphql',
-                parent: 'cloud.backend'
-            },
-            {
-                id: 'cloud.backend.storage',
-                parent: 'cloud.backend'
-            },
-            {
-                id: 'cloud.frontend.adminPanel',
-                parent: 'cloud'
-            },
-            {
-                id: 'cloud.frontend.dashboard',
-                parent: 'cloud'
-            }
-        ];
-        it('should sort hierarchically, if no edges', () => {
-            expectSorting(nodes).toEqual([
-                'customer',
-                'support',
-                'amazon',
-                'amazon.rds',
-                'cloud',
-                'cloud.backend',
-                'cloud.backend.graphql',
-                'cloud.backend.storage',
-                'cloud.frontend.adminPanel',
-                'cloud.frontend.dashboard'
-            ]);
-        });
-        it('should sort using top level edges', () => {
-            expectSorting(nodes, [
-                ['amazon', 'support'],
-                ['amazon', 'customer'],
-                ['customer', 'support']
-            ]).toEqual([
-                'amazon',
-                'customer',
-                'support',
-                'amazon.rds',
-                'cloud',
-                'cloud.backend',
-                'cloud.backend.graphql',
-                'cloud.backend.storage',
-                'cloud.frontend.adminPanel',
-                'cloud.frontend.dashboard'
-            ]);
-        });
-        it('should sort using nested in/out edges', () => {
-            expectSorting(nodes, [
-                ['customer', 'cloud.frontend.dashboard'],
-                ['support', 'cloud.frontend.adminPanel'],
-                ['cloud.frontend.dashboard', 'cloud.backend.graphql'],
-                ['cloud.frontend.adminPanel', 'cloud.backend.graphql'],
-                ['cloud.backend.graphql', 'cloud.backend.storage'],
-                ['cloud.backend.storage', 'amazon.rds']
-            ]).toEqual([
-                'customer',
-                'support',
-                'cloud',
-                'cloud.frontend.dashboard',
-                'cloud.frontend.adminPanel',
-                'cloud.backend',
-                'cloud.backend.graphql',
-                'cloud.backend.storage',
-                'amazon',
-                'amazon.rds'
-            ]);
-        });
-    });
-});

package/dist/index.d.ts

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

package/dist/index.js

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

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

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

package/dist/model-index/index.js

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

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

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

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

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

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

package/dist/types/diagram.d.ts

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

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

package/dist/types/element.d.ts

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

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

package/dist/types/expression.d.ts

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

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

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

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

package/dist/types/model.d.ts

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

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