@likec4/core 0.6.3 → 0.18.0

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

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

@@ -1,4 +1,6 @@
-export type * as likec4 from './types';
-export { computeView } from './compute-view';
+export type * from './types';
+export * from './compute-view';
 export * from './utils';
 export * from './model-index';
+export * from './colors';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

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

package/dist/model-index/{model-index.d.ts → ModelIndex.d.ts}

@@ -28,3 +28,4 @@ export declare class ModelIndex {
     defaultViewOf: (id: Fqn) => ViewID[];
 }
 export {};
+//# sourceMappingURL=ModelIndex.d.ts.map

package/dist/model-index/{model-index.js → ModelIndex.js}

@@ -38,9 +38,9 @@ export class ModelIndex {
         }
         for (const { id, viewOf } of Object.values(views)) {
             if (viewOf) {
-                const views = index._defaultElementView.get(viewOf) ?? [];
-                views.push(id);
-                index._defaultElementView.set(viewOf, views);
+                const viewsOf = index._defaultElementView.get(viewOf) ?? [];
+                viewsOf.push(id);
+                index._defaultElementView.set(viewOf, viewsOf);
             }
         }
         return index;

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

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

package/dist/model-index/index.js

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

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

@@ -28,3 +28,4 @@ export interface ComputedView<Node extends ComputedNode = ComputedNode, Edge ext
     nodes: Node[];
     edges: Edge[];
 }
+//# sourceMappingURL=computed-view.d.ts.map

package/dist/types/diagram.d.ts

@@ -24,4 +24,11 @@ export interface DiagramEdge extends ComputedEdge {
 export interface DiagramView extends ComputedView<DiagramNode, DiagramEdge> {
     width: number;
     height: number;
+    boundingBox: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
 }
+//# sourceMappingURL=diagram.d.ts.map

package/dist/types/element.d.ts

@@ -2,8 +2,8 @@ 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 type ThemeColor = 'amber' | 'blue' | 'gray' | 'slate' | 'green' | 'indigo' | 'muted' | 'primary' | 'red' | 'secondary' | 'sky';
+export type ElementShape = 'rectangle' | 'person' | 'browser' | 'mobile' | 'cylinder' | 'storage' | 'queue';
 export declare const DefaultThemeColor: ThemeColor;
 export declare const DefaultElementShape: ElementShape;
 export interface ElementStyle {
@@ -24,3 +24,4 @@ export interface Element {
     readonly shape?: ElementShape;
     readonly color?: ThemeColor;
 }
+//# sourceMappingURL=element.d.ts.map

package/dist/types/expression.d.ts

@@ -41,3 +41,4 @@ export type AnyRelationExpression = RelationExpr | InOutExpr | IncomingExpr | Ou
 export declare function isAnyRelation(expr: Expression): expr is AnyRelationExpression;
 export type Expression = ElementExpression | AnyRelationExpression;
 export {};
+//# sourceMappingURL=expression.d.ts.map

package/dist/types/index.d.ts

@@ -8,3 +8,4 @@ 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/model.d.ts

@@ -7,3 +7,4 @@ export interface LikeC4Model {
     relations: Record<RelationID, Relation>;
     views: Record<ViewID, ComputedView>;
 }
+//# sourceMappingURL=model.d.ts.map

package/dist/types/opaque.d.ts

@@ -100,3 +100,4 @@ type WontWork = UnwrapOpaque<string>;
 */
 export type UnwrapOpaque<OpaqueType extends Tagged<unknown>> = OpaqueType extends Opaque<infer Type, OpaqueType[typeof tag]> ? Type : OpaqueType;
 export {};
+//# sourceMappingURL=opaque.d.ts.map

package/dist/types/relation.d.ts

@@ -8,3 +8,4 @@ export interface Relation {
     readonly title: string;
     readonly tags?: Tag[];
 }
+//# sourceMappingURL=relation.d.ts.map

package/dist/types/view.d.ts

@@ -27,3 +27,4 @@ export interface ElementView {
     readonly description?: string;
     readonly rules: ViewRule[];
 }
+//# sourceMappingURL=view.d.ts.map

package/dist/utils/compute-node-levels.d.ts

@@ -0,0 +1,8 @@
+import type { ComputedView } from '../types/computed-view';
+type NodeLevelDepth = {
+    level: number;
+    depth: number;
+};
+export declare const computeNodeLevels: ({ nodes }: ComputedView) => Record<import("..").Fqn, NodeLevelDepth>;
+export {};
+//# sourceMappingURL=compute-node-levels.d.ts.map

package/dist/utils/compute-node-levels.js

@@ -0,0 +1,31 @@
+import invariant from 'tiny-invariant';
+export const computeNodeLevels = ({ nodes }) => {
+    const nodeLevels = {};
+    const compute = (node, level) => {
+        let levels = nodeLevels[node.id];
+        if (levels) {
+            return levels;
+        }
+        if (node.children.length === 0) {
+            levels = { level, depth: 0 };
+            nodeLevels[node.id] = levels;
+            return levels;
+        }
+        let depth = 1;
+        for (const childId of node.children) {
+            const child = nodes.find(n => n.id === childId);
+            invariant(child, `Child ${childId} not found`);
+            const { depth: childDepth } = compute(child, level + 1);
+            depth = Math.max(childDepth + 1, depth);
+        }
+        levels = { level, depth };
+        nodeLevels[node.id] = levels;
+        return levels;
+    };
+    for (const node of nodes) {
+        if (!node.parent) {
+            compute(node, 0);
+        }
+    }
+    return nodeLevels;
+};

package/dist/utils/fqn.d.ts

@@ -2,9 +2,12 @@ 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 isDescendantOf(ancestors: Element[]): (e: Element) => boolean;
+export declare function notDescendantOf(ancestors: Element[]): (e: 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;
+//# sourceMappingURL=fqn.d.ts.map

package/dist/utils/fqn.js

@@ -1,3 +1,4 @@
+import { anyPass } from 'rambdax';
 import { isString } from './guards';
 export function nameFromFqn(fqn) {
     const lastDot = fqn.lastIndexOf('.');
@@ -18,7 +19,26 @@ export function isSameHierarchy(...args) {
     const another = isString(args[1]) ? args[1] : args[1].id;
     return one === another || another.startsWith(one + '.') || one.startsWith(another + '.');
 }
+export function isDescendantOf(ancestors) {
+    const predicates = ancestors.flatMap(a => [
+        (e) => e.id === a.id,
+        (e) => isAncestor(a, e)
+    ]);
+    return anyPass(predicates);
+}
+export function notDescendantOf(ancestors) {
+    const isDescendant = isDescendantOf(ancestors);
+    return (e) => !isDescendant(e);
+}
 export function commonAncestor(first, second) {
+    const parentA = parentFqn(first);
+    const parentB = parentFqn(second);
+    if (parentA === parentB) {
+        return parentA;
+    }
+    if (!parentA || !parentB) {
+        return null;
+    }
     const a = first.split('.');
     const b = second.split('.');
     let ancestor = null;
@@ -40,7 +60,8 @@ export const compareFqnHierarchically = (a, b) => {
     const depthA = a.split('.').length;
     const depthB = b.split('.').length;
     if (depthA === depthB) {
-        return a.localeCompare(b);
+        // return a.localeCompare(b)
+        return 0;
     }
     else {
         return depthA - depthB;

package/dist/utils/guards.d.ts

@@ -1,3 +1,4 @@
 export declare function isString(value: unknown): value is string;
 export declare function failExpectedNever(arg: never): never;
 export declare function ignoreNeverInRuntime(arg: never): void;
+//# sourceMappingURL=guards.d.ts.map

package/dist/utils/index.d.ts

@@ -1,3 +1,5 @@
 export * from './fqn';
 export * from './guards';
+export * from './compute-node-levels';
 export * as Relations from './relations';
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/index.js

@@ -1,3 +1,4 @@
 export * from './fqn';
 export * from './guards';
+export * from './compute-node-levels';
 export * as Relations from './relations';

package/dist/utils/relations.d.ts

@@ -1,4 +1,4 @@
-import type { Fqn } from '../types';
+import type { Fqn, Element } from '../types';
 type Relation = {
     source: Fqn;
     target: Fqn;
@@ -13,4 +13,6 @@ export declare const isAnyBetween: (source: Fqn, target: Fqn) => import("rambdax
 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 declare const hasRelation: (rel: Relation) => (element: Element) => boolean;
 export {};
+//# sourceMappingURL=relations.d.ts.map

package/dist/utils/relations.js

@@ -1,5 +1,5 @@
 import { either } from 'rambdax';
-import { compareFqnHierarchically } from './fqn';
+import { compareFqnHierarchically, isAncestor } from './fqn';
 export const compareRelations = (a, b) => {
     return (compareFqnHierarchically(a.source, b.source) || compareFqnHierarchically(a.target, b.target));
 };
@@ -13,7 +13,8 @@ export const isBetween = (source, target) => {
     const sourcePrefix = source + '.';
     const targetPrefix = target + '.';
     return (rel) => {
-        return ((rel.source + '.').startsWith(sourcePrefix) && (rel.target + '.').startsWith(targetPrefix));
+        return ((rel.source === source || (rel.source + '.').startsWith(sourcePrefix)) &&
+            (rel.target === target || (rel.target + '.').startsWith(targetPrefix)));
     };
 };
 export const isAnyBetween = (source, target) => {
@@ -22,15 +23,20 @@ export const isAnyBetween = (source, target) => {
 export const isIncoming = (target) => {
     const targetPrefix = target + '.';
     return (rel) => {
-        return (!(rel.source + '.').startsWith(targetPrefix) && (rel.target + '.').startsWith(targetPrefix));
+        return (!(rel.source + '.').startsWith(targetPrefix) && (rel.target === target || (rel.target + '.').startsWith(targetPrefix)));
     };
 };
 export const isOutgoing = (source) => {
     const sourcePrefix = source + '.';
     return (rel) => {
-        return ((rel.source + '.').startsWith(sourcePrefix) && !(rel.target + '.').startsWith(sourcePrefix));
+        return ((rel.source === source || (rel.source + '.').startsWith(sourcePrefix)) && !(rel.target + '.').startsWith(sourcePrefix));
     };
 };
 export const isAnyInOut = (source) => {
     return either(isIncoming(source), isOutgoing(source));
 };
+export const hasRelation = (rel) => {
+    return (element) => {
+        return isAncestor(rel.source, element.id) || isAncestor(rel.target, element.id);
+    };
+};

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "@likec4/core",
-  "version": "0.6.3",
+  "version": "0.18.0",
   "license": "MIT",
   "bugs": "https://github.com/likec4/likec4/issues",
-  "homepage": "https://like-c4.dev",
+  "homepage": "https://likec4.dev",
   "author": "Denis Davydkov <denis@davydkov.com>",
   "files": [
-    "dist"
+    "dist",
+    "!dist/__test__",
+    "!**/*.spec.*",
+    "!**/*.map"
   ],
   "repository": {
     "type": "git",
@@ -14,77 +17,84 @@
     "directory": "packages/core"
   },
   "scripts": {
-    "compile": "tsc --emitDeclarationOnly",
-    "build:release": "tsc -p tsconfig.esm.json",
+    "compile": "tsc --noEmit",
     "build": "tsc",
     "dev": "tsc --watch",
     "lint": "run -T eslint src/ --fix",
-    "test": "vitest run",
-    "test:watch": "vitest",
+    "test": "run -T vitest run",
+    "test:watch": "run -T vitest",
     "clean": "run -T rimraf dist"
   },
-  "main": "./dist/index.js",
+  "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "type": "module",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
-      "require": "./dist/index.cjs"
+      "default": "./dist/index.js"
     },
     "./types": {
       "types": "./dist/types/index.d.ts",
       "import": "./dist/types/index.js",
-      "require": "./dist/types/index.cjs"
+      "default": "./dist/types/index.js"
+    },
+    "./colors": {
+      "types": "./dist/colors.d.ts",
+      "import": "./dist/colors.js",
+      "default": "./dist/colors.js"
     },
     "./utils": {
       "types": "./dist/utils/index.d.ts",
       "import": "./dist/utils/index.js",
-      "require": "./dist/utils/index.cjs"
+      "default": "./dist/utils/index.js"
     },
     "./compute-view": {
       "types": "./dist/compute-view/index.d.ts",
       "import": "./dist/compute-view/index.js",
-      "require": "./dist/compute-view/index.cjs"
+      "default": "./dist/compute-view/index.js"
     }
   },
   "sideEffects": false,
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
     "access": "public",
-    "main": "./dist/index.js",
+    "module": "./dist/index.js",
     "types": "./dist/index.d.ts",
     "exports": {
       ".": {
         "types": "./dist/index.d.ts",
         "import": "./dist/index.js",
-        "require": "./dist/index.cjs"
+        "default": "./dist/index.js"
       },
       "./types": {
         "types": "./dist/types/index.d.ts",
         "import": "./dist/types/index.js",
-        "require": "./dist/types/index.cjs"
+        "default": "./dist/types/index.js"
+      },
+      "./colors": {
+        "types": "./dist/colors.d.ts",
+        "import": "./dist/colors.js",
+        "default": "./dist/colors.js"
       },
       "./utils": {
         "types": "./dist/utils/index.d.ts",
         "import": "./dist/utils/index.js",
-        "require": "./dist/utils/index.cjs"
+        "default": "./dist/utils/index.js"
       },
       "./compute-view": {
         "types": "./dist/compute-view/index.d.ts",
         "import": "./dist/compute-view/index.js",
-        "require": "./dist/compute-view/index.cjs"
+        "default": "./dist/compute-view/index.js"
       }
     }
   },
   "dependencies": {
     "@dagrejs/graphlib": "^2.1.12",
-    "rambdax": "^9.1.0",
+    "rambdax": "^9.1.1",
     "tiny-invariant": "^1.3.1"
   },
   "devDependencies": {
-    "typescript": "^5.0.4",
-    "vite": "^4.2.2",
-    "vitest": "^0.30.1"
+    "typescript": "^5.1.3"
   }
 }

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

@@ -1,168 +0,0 @@
-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/utils/evaluate-expression.d.ts

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