@likec4/core 0.25.0 → 0.26.0

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

@@ -1,6 +1,6 @@
 import { anyPass, filter, head, uniq, isNil } from 'rambdax';
 import { DefaultThemeColor, DefaultElementShape, } from '../types';
-import * as Expression from '../types/expression';
+import * as Expr from '../types/expression';
 import { isViewRuleAutoLayout, isViewRuleExpression, isViewRuleStyle } from '../types/view';
 import { compareByFqnHierarchically, failExpectedNever, ignoreNeverInRuntime, isAncestor, isSameHierarchy, parentFqn, Relations } from '../utils';
 import { hasRelation, isAnyInOut, isBetween, isIncoming, isInside, isOutgoing } from '../utils/relations';
@@ -9,7 +9,7 @@ import { sortNodes } from './utils/sortNodes';
 import { ComputeCtx } from './compute-ctx';
 import { anyPossibleRelations } from './utils/anyPossibleRelations';
 import invariant from 'tiny-invariant';
-function transformToNodes(elementsIterator, index, currentViewid) {
+function transformToNodes(elementsIterator) {
     return Array.from(elementsIterator)
         .sort(compareByFqnHierarchically)
         .reduce((map, { id, kind, title, color, shape, description }) => {
@@ -20,7 +20,6 @@ function transformToNodes(elementsIterator, index, currentViewid) {
             }
             parent = parentFqn(parent);
         }
-        const navigateTo = head(index.defaultViewOf(id).filter(v => v !== currentViewid));
         if (parent) {
             const parentNd = map.get(parent);
             invariant(parentNd, `parent node ${parent} not found`);
@@ -35,7 +34,6 @@ function transformToNodes(elementsIterator, index, currentViewid) {
             shape: shape ?? DefaultElementShape,
             children: [],
             ...(description ? { description } : {}),
-            ...(navigateTo ? { navigateTo } : {})
         };
         map.set(id, node);
         return map;
@@ -49,21 +47,21 @@ function applyViewRuleStyles(rules, nodes) {
             continue;
         }
         for (const target of rule.targets) {
-            if (Expression.isWildcard(target)) {
+            if (Expr.isWildcard(target)) {
                 predicates.push(() => true);
                 break;
             }
-            if (Expression.isElementKindExpr(target)) {
+            if (Expr.isElementKindExpr(target)) {
                 predicates.push(target.isEqual ? n => n.kind === target.elementKind : n => n.kind !== target.elementKind);
                 continue;
             }
-            if (Expression.isElementTagExpr(target)) {
+            if (Expr.isElementTagExpr(target)) {
                 predicates.push(target.isEqual
                     ? ({ tags }) => !!tags && tags.includes(target.elementTag)
                     : ({ tags }) => isNil(tags) || !tags.includes(target.elementTag));
                 continue;
             }
-            if (Expression.isElementRef(target)) {
+            if (Expr.isElementRef(target)) {
                 const { element, isDescedants } = target;
                 predicates.push(isDescedants ? n => n.id.startsWith(element + '.') : n => n.id === element);
                 continue;
@@ -113,7 +111,7 @@ const excludeElementRef = (ctx, expr) => {
 };
 const asElementPredicate = (expr) => {
     if (expr.isEqual) {
-        if (Expression.isElementKindExpr(expr)) {
+        if (Expr.isElementKindExpr(expr)) {
             return e => e.kind === expr.elementKind;
         }
         else {
@@ -121,7 +119,7 @@ const asElementPredicate = (expr) => {
         }
     }
     else {
-        if (Expression.isElementKindExpr(expr)) {
+        if (Expr.isElementKindExpr(expr)) {
             return e => e.kind !== expr.elementKind;
         }
         else {
@@ -196,7 +194,7 @@ const excludeWildcardRef = (ctx, _expr) => {
     }
 };
 const resolveElements = (ctx, expr) => {
-    if (Expression.isWildcard(expr)) {
+    if (Expr.isWildcard(expr)) {
         if (ctx.root) {
             return [ctx.index.find(ctx.root)];
         }
@@ -204,7 +202,7 @@ const resolveElements = (ctx, expr) => {
             return ctx.index.rootElements();
         }
     }
-    if (Expression.isElementKindExpr(expr)) {
+    if (Expr.isElementKindExpr(expr)) {
         return ctx.index.elements.filter(el => {
             if (expr.isEqual) {
                 return el.kind === expr.elementKind;
@@ -212,7 +210,7 @@ const resolveElements = (ctx, expr) => {
             return el.kind !== expr.elementKind;
         });
     }
-    if (Expression.isElementTagExpr(expr)) {
+    if (Expr.isElementTagExpr(expr)) {
         return ctx.index.elements.filter(el => {
             const tags = el.tags;
             if (expr.isEqual) {
@@ -229,7 +227,7 @@ const resolveElements = (ctx, expr) => {
     }
 };
 const includeIncomingExpr = (ctx, expr) => {
-    if (Expression.isWildcard(expr.incoming) && !ctx.root) {
+    if (Expr.isWildcard(expr.incoming) && !ctx.root) {
         return ctx;
     }
     const elements = resolveElements(ctx, expr.incoming);
@@ -251,7 +249,7 @@ const includeIncomingExpr = (ctx, expr) => {
     });
 };
 const excludeIncomingExpr = (ctx, expr) => {
-    if (Expression.isWildcard(expr.incoming) && !ctx.root) {
+    if (Expr.isWildcard(expr.incoming) && !ctx.root) {
         return ctx;
     }
     const elements = resolveElements(ctx, expr.incoming);
@@ -268,7 +266,7 @@ const excludeIncomingExpr = (ctx, expr) => {
     return ctx;
 };
 const includeOutgoingExpr = (ctx, expr) => {
-    if (Expression.isWildcard(expr.outgoing) && !ctx.root) {
+    if (Expr.isWildcard(expr.outgoing) && !ctx.root) {
         return ctx;
     }
     const elements = resolveElements(ctx, expr.outgoing);
@@ -290,7 +288,7 @@ const includeOutgoingExpr = (ctx, expr) => {
     });
 };
 const excludeOutgoingExpr = (ctx, expr) => {
-    if (Expression.isWildcard(expr.outgoing) && !ctx.root) {
+    if (Expr.isWildcard(expr.outgoing) && !ctx.root) {
         return ctx;
     }
     const elements = resolveElements(ctx, expr.outgoing);
@@ -307,7 +305,7 @@ const excludeOutgoingExpr = (ctx, expr) => {
     return ctx;
 };
 const includeInOutExpr = (ctx, expr) => {
-    if (Expression.isWildcard(expr.inout) && !ctx.root) {
+    if (Expr.isWildcard(expr.inout) && !ctx.root) {
         return ctx;
     }
     const targets = resolveElements(ctx, expr.inout);
@@ -329,7 +327,7 @@ const includeInOutExpr = (ctx, expr) => {
     });
 };
 const excludeInOutExpr = (ctx, expr) => {
-    if (Expression.isWildcard(expr.inout) && !ctx.root) {
+    if (Expr.isWildcard(expr.inout) && !ctx.root) {
         return ctx;
     }
     const targets = resolveElements(ctx, expr.inout);
@@ -403,31 +401,31 @@ export function computeElementView(view, index) {
     }
     for (const { isInclude, exprs } of rulesInclude) {
         for (const expr of exprs) {
-            if (Expression.isElementKindExpr(expr) || Expression.isElementTagExpr(expr)) {
+            if (Expr.isElementKindExpr(expr) || Expr.isElementTagExpr(expr)) {
                 ctx = isInclude ? includeElementKindOrTag(ctx, expr) : excludeElementKindOrTag(ctx, expr);
                 continue;
             }
-            if (Expression.isElementRef(expr)) {
+            if (Expr.isElementRef(expr)) {
                 ctx = isInclude ? includeElementRef(ctx, expr) : excludeElementRef(ctx, expr);
                 continue;
             }
-            if (Expression.isWildcard(expr)) {
+            if (Expr.isWildcard(expr)) {
                 ctx = isInclude ? includeWildcardRef(ctx, expr) : excludeWildcardRef(ctx, expr);
                 continue;
             }
-            if (Expression.isIncoming(expr)) {
+            if (Expr.isIncoming(expr)) {
                 ctx = isInclude ? includeIncomingExpr(ctx, expr) : excludeIncomingExpr(ctx, expr);
                 continue;
             }
-            if (Expression.isOutgoing(expr)) {
+            if (Expr.isOutgoing(expr)) {
                 ctx = isInclude ? includeOutgoingExpr(ctx, expr) : excludeOutgoingExpr(ctx, expr);
                 continue;
             }
-            if (Expression.isInOut(expr)) {
+            if (Expr.isInOut(expr)) {
                 ctx = isInclude ? includeInOutExpr(ctx, expr) : excludeInOutExpr(ctx, expr);
                 continue;
             }
-            if (Expression.isRelation(expr)) {
+            if (Expr.isRelation(expr)) {
                 ctx = isInclude ? includeRelationExpr(ctx, expr) : excludeRelationExpr(ctx, expr);
                 continue;
             }
@@ -453,7 +451,7 @@ export function computeElementView(view, index) {
             idx = resolvedRelations.findIndex(findPredicate);
         }
     }
-    const nodesreg = transformToNodes(elements, index, view.id);
+    const nodesreg = transformToNodes(elements);
     const edges = edgeBuilder.build().map(edge => {
         while (edge.parent) {
             if (nodesreg.has(edge.parent)) {

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

@@ -1,10 +1,10 @@
 import { ModelIndex } from '../model-index';
-import type { Element, ElementView, Fqn, Relation, RelationID, ViewID, ComputeResult } from '../types';
-export declare function computeView<V extends ElementView>(view: V, index: ModelIndex): ComputeResult<V>;
+import type { ComputeResult, Element, ElementView, Fqn, Relation, RelationID, ViewID } from '../types';
+export declare function computeView<V extends ElementView>(view: V, index: ModelIndex): ComputeResult<V> | null;
 type InputModel<V extends ElementView> = {
     elements: Record<Fqn, Element>;
     relations: Record<RelationID, Relation>;
-    views: Record<ViewID, V>;
+    views: V[];
 };
 type OutputModel<V extends ElementView> = {
     elements: Record<Fqn, Element>;
@@ -12,5 +12,6 @@ type OutputModel<V extends ElementView> = {
     views: Record<ViewID, ComputeResult<V>>;
 };
 export declare function computeViews<V extends ElementView>(model: InputModel<V>): OutputModel<V>;
+export declare function assignNavigateTo<V extends ElementView, R extends ComputeResult<V>[]>(views: R): R;
 export {};
 //# sourceMappingURL=compute.d.ts.map

package/dist/compute-view/compute.js

@@ -1,15 +1,43 @@
-import { map } from 'rambdax';
+import { compact, find, map, mapToObj } from 'remeda';
 import { ModelIndex } from '../model-index';
 import { computeElementView } from './compute-element-view';
 export function computeView(view, index) {
-    return computeElementView(view, index);
+    try {
+        return computeElementView(view, index);
+    }
+    catch (e) {
+        console.error(e);
+        return null;
+    }
 }
 export function computeViews(model) {
     const index = ModelIndex.from(model);
+    const computedViews = compact(map(model.views, view => computeView(view, index)));
     return {
         elements: model.elements,
         relations: model.relations,
-        views: map(v => computeElementView(v, index), model.views)
+        views: mapToObj(computedViews, view => [view.id, view])
     };
 }
+export function assignNavigateTo(views) {
+    const allElementViews = new Map();
+    for (const { id, viewOf } of views) {
+        if (viewOf) {
+            const viewsOf = allElementViews.get(viewOf) ?? [];
+            viewsOf.push(id);
+            allElementViews.set(viewOf, viewsOf);
+        }
+    }
+    // set default navigateTo
+    for (const { id, nodes } of views) {
+        for (const node of nodes) {
+            // find first element view that is not the current one
+            const navigateTo = find(allElementViews.get(node.id) ?? [], v => v !== id);
+            if (navigateTo) {
+                node.navigateTo = navigateTo;
+            }
+        }
+    }
+    return views;
+}
 //# sourceMappingURL=compute.js.map

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

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

package/dist/compute-view/index.js

@@ -1,2 +1,2 @@
-export { computeView, computeViews } from './compute';
+export { computeView, computeViews, assignNavigateTo } from './compute';
 //# sourceMappingURL=index.js.map

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

@@ -1,18 +1,15 @@
-import type { Predicate } from 'rambdax';
-import type { Element, ElementView, Fqn, Relation, RelationID, ViewID } from '../types';
+import type { Element, Fqn, Relation, RelationID } from '../types';
 type ModelInput = {
     elements: Record<Fqn, Element>;
     relations: Record<RelationID, Relation>;
-    views: Record<ViewID, ElementView>;
 };
-export declare class ModelIndex {
+export default 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;
+    filterRelations: (predicate: (r: Relation) => boolean) => Relation[];
+    static from({ elements, relations }: ModelInput): ModelIndex;
     addElement(el: Element): void;
     private locateTrie;
     find: (id: Fqn) => Element;
@@ -25,7 +22,6 @@ export declare class ModelIndex {
     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

@@ -1,4 +1,4 @@
-import { values } from 'rambdax';
+import { values } from 'remeda';
 import invariant from 'tiny-invariant';
 import { parentFqn } from '../utils/fqn';
 function childrenOf(trie) {
@@ -13,39 +13,34 @@ function childrenOf(trie) {
 function asPath(id) {
     return id.split('.');
 }
-export class ModelIndex {
+export default class ModelIndex {
     root = {
         children: {}
     };
-    _elements = new Set();
+    _elements = new Map();
     _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()];
+        return Array.from(this._relations.values());
     }
     filterRelations = (predicate) => {
-        return [...this._relations.values()].filter(predicate);
+        return this.relations.filter(predicate);
     };
-    static from({ elements, relations, views }) {
+    static from({ elements, relations }) {
         const index = new ModelIndex();
-        for (const el of Object.values(elements)) {
+        for (const el of values(elements)) {
             index.addElement(el);
         }
-        for (const rel of Object.values(relations)) {
+        for (const rel of values(relations)) {
             index.addRelation(rel);
         }
-        for (const { id, viewOf } of Object.values(views)) {
-            if (viewOf) {
-                const viewsOf = index._defaultElementView.get(viewOf) ?? [];
-                viewsOf.push(id);
-                index._defaultElementView.set(viewOf, viewsOf);
-            }
-        }
         return index;
     }
     addElement(el) {
+        if (this._elements.has(el.id)) {
+            throw new Error(`Element already exists with id ${el.id}`);
+        }
         const path = asPath(el.id);
         let scope = this.root;
         for (const name of path) {
@@ -56,7 +51,7 @@ export class ModelIndex {
             scope = next;
         }
         scope.el = el;
-        this._elements.add(el);
+        this._elements.set(el.id, el);
     }
     locateTrie = (id) => {
         let scope = this.root;
@@ -68,11 +63,11 @@ export class ModelIndex {
         return scope;
     };
     find = (id) => {
-        const trie = this.locateTrie(id);
-        if (!trie.el) {
-            throw new Error(`Invalid index, element not found at path ${id}`);
+        const el = this._elements.get(id);
+        if (!el) {
+            throw new Error(`Element not found ${id}`);
         }
-        return trie.el;
+        return el;
     };
     children = (id) => {
         return childrenOf(this.locateTrie(id));
@@ -98,7 +93,9 @@ export class ModelIndex {
         let trie = this.root;
         while (name) {
             const next = trie.children[name];
-            invariant(next, `Invalid index, Element not found at path ${name} of ${id}`);
+            if (!next) {
+                throw new Error(`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}`);
@@ -121,15 +118,19 @@ export class ModelIndex {
         return childrenOf(this.root);
     }
     get elements() {
-        return [...this._elements];
+        return Array.from(this._elements.values());
     }
     // hasElement(fqn: Fqn): boolean {
     //   return fqn in this._elements
     // }
     addRelation(rel) {
         // Validate source and target
-        this.locateTrie(rel.source);
-        this.locateTrie(rel.target);
+        if (!this._elements.has(rel.source)) {
+            throw new Error(`Invalid index, source of relation not found ${rel.source}`);
+        }
+        if (!this._elements.has(rel.target)) {
+            throw new Error(`Invalid index, target of relation not found ${rel.target}`);
+        }
         this._relations.set(rel.id, rel);
         // for (const tag of rel.tags) {
         //   const tagged = this._taggedRelations.get(tag) ?? new Set()
@@ -137,8 +138,5 @@ export class ModelIndex {
         //   this._taggedRelations.set(tag, tagged)
         // }
     }
-    defaultViewOf = (id) => {
-        return this._defaultElementView.get(id) ?? [];
-    };
 }
 //# sourceMappingURL=ModelIndex.js.map

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

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

package/dist/model-index/index.js

@@ -1,2 +1,2 @@
-export * from './ModelIndex';
+export { default as ModelIndex } from './ModelIndex';
 //# sourceMappingURL=index.js.map

package/dist/utils/fqn.js

@@ -1,4 +1,4 @@
-import { anyPass } from 'rambdax';
+import { anyPass } from 'remeda';
 import { isString } from './guards';
 export function nameFromFqn(fqn) {
     const lastDot = fqn.lastIndexOf('.');

package/dist/utils/relations.d.ts

@@ -3,16 +3,17 @@ type Relation = {
     source: Fqn;
     target: Fqn;
 };
+type RelationPredicate = (rel: Relation) => boolean;
 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 declare const isInside: (parent: Fqn) => RelationPredicate;
+export declare const isBetween: (source: Fqn, target: Fqn) => RelationPredicate;
+export declare const isAnyBetween: (source: Fqn, target: Fqn) => RelationPredicate;
+export declare const isIncoming: (target: Fqn) => RelationPredicate;
+export declare const isOutgoing: (source: Fqn) => RelationPredicate;
+export declare const isAnyInOut: (source: Fqn) => RelationPredicate;
 export declare const hasRelation: (rel: Relation) => (element: Element) => boolean;
 export {};
 //# sourceMappingURL=relations.d.ts.map

package/dist/utils/relations.js

@@ -1,4 +1,4 @@
-import { either } from 'rambdax';
+import { anyPass } from 'remeda';
 import { compareFqnHierarchically, isAncestor } from './fqn';
 export const compareRelations = (a, b) => {
     return (compareFqnHierarchically(a.source, b.source) || compareFqnHierarchically(a.target, b.target));
@@ -18,7 +18,7 @@ export const isBetween = (source, target) => {
     };
 };
 export const isAnyBetween = (source, target) => {
-    return either(isBetween(source, target), isBetween(target, source));
+    return anyPass([isBetween(source, target), isBetween(target, source)]);
 };
 export const isIncoming = (target) => {
     const targetPrefix = target + '.';
@@ -33,7 +33,7 @@ export const isOutgoing = (source) => {
     };
 };
 export const isAnyInOut = (source) => {
-    return either(isIncoming(source), isOutgoing(source));
+    return anyPass([isIncoming(source), isOutgoing(source)]);
 };
 export const hasRelation = (rel) => {
     return (element) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@likec4/core",
-  "version": "0.25.0",
+  "version": "0.26.0",
   "license": "MIT",
   "bugs": "https://github.com/likec4/likec4/issues",
   "homepage": "https://likec4.dev",
@@ -92,6 +92,7 @@
   "dependencies": {
     "@dagrejs/graphlib": "^2.1.13",
     "rambdax": "^9.1.1",
+    "remeda": "^1.23.0",
     "tiny-invariant": "^1.3.1"
   },
   "devDependencies": {