@likec4/core 0.31.0 → 0.32.0

package/README.md

@@ -1,3 +1,14 @@
-# @likec4/core
+# LikeC4 Core
 
-Core likec4 types, errors, functions and utilities.
+[docs](https://likec4.dev/docs/) | [example](https://likec4.dev/examples/bigbank/likec4/)
+
+```bash
+npm install @likec4/core
+```
+
+Package contains:
+
+- types
+- view computation
+- utilities and guards
+- errors

package/dist/colors.d.ts

@@ -55,20 +55,20 @@ export declare const Colors: {
     readonly red: {
         readonly fill: "#ef4444";
         readonly stroke: "#dc2626";
-        readonly hiContrast: "#fef2f2";
-        readonly loContrast: "#fecaca";
+        readonly hiContrast: "#111827";
+        readonly loContrast: "#1f2937";
     };
     readonly green: {
         readonly fill: "#16a34a";
         readonly stroke: "#15803d";
-        readonly hiContrast: "#f0fdf4";
-        readonly loContrast: "#bbf7d0";
+        readonly hiContrast: "#111827";
+        readonly loContrast: "#1f2937";
     };
     readonly amber: {
         readonly fill: "#d97706";
         readonly stroke: "#b45309";
-        readonly hiContrast: "#fffbeb";
-        readonly loContrast: "#fde68a";
+        readonly hiContrast: "#111827";
+        readonly loContrast: "#1f2937";
     };
     readonly indigo: {
         readonly fill: "#6366f1";

package/dist/colors.js

@@ -32,7 +32,7 @@ export const RelationColors = {
     // lineColor: colors.neutral[400],
     // labelColor: colors.neutral[300],
     lineColor: '#a3a3a3',
-    labelColor: '#d4d4d4',
+    labelColor: '#d4d4d4'
 };
 export const Colors = {
     primary: blue,
@@ -58,8 +58,10 @@ export const Colors = {
         // loContrast: colors.red[200],
         fill: '#ef4444',
         stroke: '#dc2626',
-        hiContrast: '#fef2f2',
-        loContrast: '#fecaca'
+        // hiContrast: '#fef2f2',
+        // loContrast: '#fecaca',
+        hiContrast: '#111827',
+        loContrast: '#1f2937' // colors.gray[800],
     },
     green: {
         // fill: colors.green[600],
@@ -68,8 +70,10 @@ export const Colors = {
         // loContrast: colors.green[200],
         fill: '#16a34a',
         stroke: '#15803d',
-        hiContrast: '#f0fdf4',
-        loContrast: '#bbf7d0'
+        hiContrast: '#111827',
+        // hiContrast: '#f0fdf4',
+        loContrast: '#1f2937' // colors.gray[800],
+        // loContrast: '#bbf7d0'
     },
     amber: {
         // fill: colors.amber[600],
@@ -78,8 +82,10 @@ export const Colors = {
         // loContrast: colors.amber[200],
         fill: '#d97706',
         stroke: '#b45309',
-        hiContrast: '#fffbeb',
-        loContrast: '#fde68a'
+        // hiContrast: '#fffbeb',
+        // loContrast: '#fde68a',
+        hiContrast: '#111827',
+        loContrast: '#1f2937' // colors.gray[800],
     },
     indigo: {
         // fill: colors.indigo[500],

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

@@ -1,4 +1,4 @@
 import type { ModelIndex } from '../model-index';
-import { type ElementView, type ComputeResult } from '../types';
+import { type ComputeResult, type ElementView } from '../types';
 export declare function computeElementView<V extends ElementView>(view: V, index: ModelIndex): ComputeResult<V>;
 //# sourceMappingURL=compute-element-view.d.ts.map

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

@@ -1,14 +1,14 @@
-import { anyPass, filter, uniq, isNil } from 'rambdax';
-import { DefaultThemeColor, DefaultElementShape } from '../types';
+import { anyPass, both, either, filter, isNil, uniq } from 'rambdax';
+import { allPass, find, isDefined } from 'remeda';
+import { invariant, nonexhaustive } from '../errors';
+import { DefaultElementShape, DefaultThemeColor } from '../types';
 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';
+import { Relations, commonAncestor, compareByFqnHierarchically, failUnexpected, isAncestor, isSameHierarchy, parentFqn } from '../utils';
+import { compareRelations, isAnyInOut, isBetween, isIncoming, isInside, isOutgoing } from '../utils/relations';
 import { EdgeBuilder } from './EdgeBuilder';
-import { sortNodes } from './utils/sortNodes';
 import { ComputeCtx } from './compute-ctx';
-import { anyPossibleRelations } from './utils/anyPossibleRelations';
-import { invariant } from '../errors';
+import { sortNodes } from './utils/sortNodes';
 function transformToNodes(elementsIterator) {
     return Array.from(elementsIterator)
         .sort(compareByFqnHierarchically)
@@ -64,11 +64,14 @@ function applyViewRuleStyles(rules, nodes) {
                 predicates.push(isDescedants ? n => n.id.startsWith(element + '.') : n => n.id === element);
                 continue;
             }
-            failExpectedNever(target);
+            failUnexpected(target);
         }
         filter(anyPass(predicates), nodes).forEach(n => {
             n.shape = rule.style.shape ?? n.shape;
             n.color = rule.style.color ?? n.color;
+            if (isDefined.strict(rule.style.icon)) {
+                n.icon = rule.style.icon;
+            }
         });
     }
     return nodes;
@@ -79,7 +82,9 @@ const includeElementRef = (ctx, expr) => {
         : [ctx.index.find(expr.element)];
     const filters = [];
     if (expr.isDescedants) {
-        filters.push(Relations.isInside(expr.element));
+        elements.forEach(child => {
+            filters.push(both(Relations.isInside(expr.element), Relations.isAnyInOut(child.id)));
+        });
     }
     const ctxElements = uniq([...ctx.elements, ...ctx.implicits]);
     const excludeImplicits = [];
@@ -147,44 +152,42 @@ const includeWildcardRef = (ctx, _expr) => {
             ...ctx.index.siblings(root),
             ...ctx.index.ancestors(root).flatMap(a => [...ctx.index.siblings(a.id)])
         ];
-        const allInOut = ctx.index.filterRelations(isAnyInOut(root));
+        const inOut = ctx.index.filterRelations(isAnyInOut(root));
         // Neighbors that have relations with root or its children
         const implicits = [];
-        const relations = [];
         for (const implicit of allImplicits) {
-            const relationsWithImplicit = allInOut.filter(isAnyInOut(implicit.id));
-            if (relationsWithImplicit.length) {
+            if (inOut.some(isAnyInOut(implicit.id))) {
                 implicits.push(implicit);
-                relations.push(...relationsWithImplicit);
             }
         }
         return ctx.include({
             elements,
-            relations: [...ctx.index.filterRelations(isInside(root)), ...relations],
+            relations: [...ctx.index.filterRelations(isInside(root)), ...inOut],
             implicits: implicits
         });
     }
     else {
+        // Take root elements
         const elements = ctx.index.rootElements();
         if (elements.length <= 1) {
             return new ComputeCtx(ctx.index, ctx.root, new Set(elements));
         }
-        const predicates = [];
-        for (const [source, target] of anyPossibleRelations(elements)) {
-            predicates.push(Relations.isAnyBetween(source.id, target.id));
-        }
-        const relations = predicates.length ? ctx.index.filterRelations(anyPass(predicates)) : [];
-        return new ComputeCtx(ctx.index, ctx.root, new Set(elements), new Set(relations));
+        // Only relations without common ancenstors, i.e. between hierarchies
+        const relations = ctx.index.filterRelations(rel => isNil(commonAncestor(rel.source, rel.target)));
+        return ctx.include({
+            elements,
+            relations
+        });
     }
 };
 const excludeWildcardRef = (ctx, _expr) => {
     const { root } = ctx;
     if (root) {
-        const relations = [...ctx.relations].filter(anyPass([isInside(root), isIncoming(root), isOutgoing(root)]));
+        const relations = [...ctx.relations].filter(either(isInside(root), isAnyInOut(root)));
         return ctx.exclude({
-            elements: [...ctx.elements].filter(e => isAncestor(root, e.id)),
+            elements: [...ctx.elements].filter(e => e.id === root || isAncestor(root, e.id)),
             relations,
-            implicits: [...ctx.implicits].filter(anyPass(relations.map(r => hasRelation(r))))
+            implicits: [...ctx.implicits].filter(e => relations.some(isAnyInOut(e.id)))
         });
     }
     else {
@@ -232,10 +235,16 @@ const includeIncomingExpr = (ctx, expr) => {
     if (elements.length === 0) {
         return ctx;
     }
+    // '-> element.*' should include only "outside" relations.
+    // From the outside to the element descendants,
+    let allrelations = ctx.index.relations;
+    if (Expr.isElementRef(expr.incoming)) {
+        allrelations = allrelations.filter(isIncoming(expr.incoming.element));
+    }
     const implicits = [];
     const relations = [];
     for (const el of elements) {
-        const elRelations = ctx.index.filterRelations(isIncoming(el.id));
+        const elRelations = allrelations.filter(isIncoming(el.id));
         if (elRelations.length > 0) {
             relations.push(...elRelations);
             implicits.push(el);
@@ -271,10 +280,16 @@ const includeOutgoingExpr = (ctx, expr) => {
     if (elements.length === 0) {
         return ctx;
     }
+    // 'element.* -> ' should include only "outside" relations.
+    // From element descendants to outside of 'element.*'
+    let allrelations = ctx.index.relations;
+    if (Expr.isElementRef(expr.outgoing)) {
+        allrelations = allrelations.filter(isOutgoing(expr.outgoing.element));
+    }
     const implicits = [];
     const relations = [];
     for (const el of elements) {
-        const elRelations = ctx.index.filterRelations(isOutgoing(el.id));
+        const elRelations = allrelations.filter(isOutgoing(el.id));
         if (elRelations.length > 0) {
             relations.push(...elRelations);
             implicits.push(el);
@@ -310,10 +325,15 @@ const includeInOutExpr = (ctx, expr) => {
     if (targets.length === 0) {
         return ctx;
     }
+    // '-> element.* -> ' should include only "outside" relations.
+    let allrelations = ctx.index.relations;
+    if (Expr.isElementRef(expr.inout)) {
+        allrelations = allrelations.filter(isAnyInOut(expr.inout.element));
+    }
     const implicits = [];
     const relations = [];
     for (const target of targets) {
-        const foundRelations = ctx.index.filterRelations(isAnyInOut(target.id));
+        const foundRelations = allrelations.filter(isAnyInOut(target.id));
         if (foundRelations.length > 0) {
             relations.push(...foundRelations);
             implicits.push(target);
@@ -427,28 +447,64 @@ export function computeElementView(view, index) {
                 ctx = isInclude ? includeRelationExpr(ctx, expr) : excludeRelationExpr(ctx, expr);
                 continue;
             }
-            ignoreNeverInRuntime(expr);
+            nonexhaustive(expr);
         }
     }
-    const elements = new Set([...ctx.elements]);
+    // All "predicated" elements (including implicit ones)
+    const allElements = [...ctx.elements, ...ctx.implicits].sort(compareByFqnHierarchically).reverse();
+    // Filtered "allElements", only with relations
+    const elementsWithRelations = new Set();
     const edgeBuilder = new EdgeBuilder();
-    const resolvedRelations = [...ctx.relations];
-    for (const [source, target] of anyPossibleRelations([...elements, ...ctx.implicits])) {
-        if (!elements.has(source) && !elements.has(target)) {
+    const anscestorOf = (id) => (e) => e.id === id || isAncestor(e.id, id);
+    // Step 1: Add explicit relations
+    const sortedRelations = [...ctx.relations].sort(compareRelations);
+    for (const rel of sortedRelations) {
+        const source = find(allElements, anscestorOf(rel.source));
+        if (!source) {
             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 target = find(allElements, allPass([anscestorOf(rel.target), e => !isSameHierarchy(e, source)]));
+        if (!target) {
+            continue;
         }
-    }
+        elementsWithRelations.add(source);
+        elementsWithRelations.add(target);
+        edgeBuilder.add(source.id, target.id, rel);
+    }
+    const elements = new Set([...elementsWithRelations, ...ctx.elements]);
+    // Step 2: Add implicit relations
+    // if (relationsWithImplicits.length > 0) {
+    //   elmnts = [...ctx.elements, ...ctx.implicits].sort(compareByFqnHierarchically).reverse()
+    //   for (const rel of relationsWithImplicits) {
+    //     const source = find(elmnts, anscestorOf(rel.source))
+    //     if (!source) {
+    //       continue
+    //     }
+    //     const target = find(elmnts, anscestorOf(rel.target))
+    //     if (!target || isSameHierarchy(source, target)) {
+    //       continue
+    //     }
+    //     elements.add(source)
+    //     elements.add(target)
+    //     edgeBuilder.add(source.id, target.id, rel)
+    //   }
+    // }
+    // for (const [source, target] of anyPossibleRelations([...elements, ...ctx.implicits])) {
+    //   if (!elements.has(source) && !elements.has(target)) {
+    //     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);
     const edges = edgeBuilder.build().map(edge => {
         while (edge.parent) {

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

@@ -1,4 +1,6 @@
+import { isSameHierarchy } from '../../utils';
 import { Graph, alg } from '@dagrejs/graphlib';
+import { nonNullable } from '../../errors/invariant';
 export function sortNodes(_nodes, edges) {
     const g = new Graph({
         compound: true,
@@ -17,7 +19,7 @@ export function sortNodes(_nodes, edges) {
         const source = _nodes.get(edge.source);
         let target = _nodes.get(edge.target);
         while (source && target) {
-            if (!g.hasEdge(source.id, target.id)) {
+            if (!isSameHierarchy(source, target) && !g.hasEdge(source.id, target.id)) {
                 g.setEdge(source.id, target.id);
                 // console.log(`${source.id} -> ${target.id}`)
                 if (!alg.isAcyclic(g)) {
@@ -34,7 +36,7 @@ export function sortNodes(_nodes, edges) {
         }
     }
     const sorted = alg.topsort(g);
-    const nodes = sorted.map(id => _nodes.get(id));
+    const nodes = sorted.map(id => nonNullable(_nodes.get(id)));
     for (const node of nodes) {
         node.children = nodes.flatMap(n => (n.parent === node.id ? n.id : []));
     }

package/dist/errors/index.d.ts

@@ -1,4 +1,5 @@
 export * from './_base';
 export * from './invariant';
+export * from './nonexhaustive';
 export * from './model-index';
 //# sourceMappingURL=index.d.ts.map

package/dist/errors/index.js

@@ -1,4 +1,5 @@
 export * from './_base';
 export * from './invariant';
+export * from './nonexhaustive';
 export * from './model-index';
 //# sourceMappingURL=index.js.map

package/dist/errors/invariant.d.ts

@@ -1,3 +1,4 @@
 export declare const InvariantError: import("modern-errors").ErrorSubclassCore<[], {}, import("modern-errors").CustomClass>;
 export declare function invariant(condition: any, message?: string): asserts condition;
+export declare function nonNullable<T>(value: T): NonNullable<T>;
 //# sourceMappingURL=invariant.d.ts.map

package/dist/errors/invariant.js

@@ -13,4 +13,9 @@ message) {
     }
     throw new InvariantError(message ?? 'Invariant failed');
 }
+// Throws an error if the value is null or undefined
+export function nonNullable(value) {
+    invariant(value != null, 'Expected value to exist');
+    return value;
+}
 //# sourceMappingURL=invariant.js.map

package/dist/errors/nonexhaustive.d.ts

@@ -0,0 +1,3 @@
+export declare const NonExhaustiveError: import("modern-errors").ErrorSubclassCore<[], {}, import("modern-errors").CustomClass>;
+export declare function nonexhaustive(arg: never): never;
+//# sourceMappingURL=nonexhaustive.d.ts.map

package/dist/errors/nonexhaustive.js

@@ -0,0 +1,6 @@
+import { BaseError } from './_base';
+export const NonExhaustiveError = BaseError.subclass('NonExhaustiveError');
+export function nonexhaustive(arg) {
+    throw new NonExhaustiveError(`NonExhaustive value: ${JSON.stringify(arg)}`);
+}
+//# sourceMappingURL=nonexhaustive.js.map

package/dist/model-index/ModelIndex.js

@@ -65,9 +65,7 @@ export default class ModelIndex {
     };
     find = (id) => {
         const el = this._elements.get(id);
-        if (!el) {
-            throw new InvalidModelError(`Element not found ${id}`);
-        }
+        ensureModel(el, `Element not found with id ${id}`);
         return el;
     };
     children = (id) => {

package/dist/types/_common.d.ts

@@ -1,2 +1,4 @@
+import type { Opaque } from './opaque';
 export type NonEmptyArray<T> = [T, ...T[]];
+export type IconUrl = Opaque<string, 'IconUrl'>;
 //# sourceMappingURL=_common.d.ts.map

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

@@ -2,7 +2,7 @@ import type { Opaque } from './opaque';
 import type { ElementKind, ElementShape, Fqn, Tag, ThemeColor } from './element';
 import type { RelationID } from './relation';
 import type { ElementView, ViewID, ViewRuleAutoLayout } from './view';
-import type { NonEmptyArray } from './_common';
+import type { IconUrl, NonEmptyArray } from './_common';
 export type NodeId = Fqn;
 export type EdgeId = Opaque<string, 'EdgeId'>;
 export interface ComputedNode {
@@ -17,6 +17,7 @@ export interface ComputedNode {
     children: NodeId[];
     shape: ElementShape;
     color: ThemeColor;
+    icon?: IconUrl;
     navigateTo?: ViewID;
 }
 export interface ComputedEdge {

package/dist/types/element.d.ts

@@ -1,4 +1,4 @@
-import type { NonEmptyArray } from '.';
+import type { IconUrl, NonEmptyArray } from './_common';
 import type { Opaque } from './opaque';
 export type Fqn = Opaque<string, 'Fqn'>;
 export declare function AsFqn(name: string, parent?: Fqn | null): Fqn;
@@ -26,6 +26,7 @@ export interface Element {
     readonly technology: string | null;
     readonly tags: NonEmptyArray<Tag> | null;
     readonly links: NonEmptyArray<string> | null;
+    readonly icon?: IconUrl;
     readonly shape?: ElementShape;
     readonly color?: ThemeColor;
 }

package/dist/types/view.d.ts

@@ -1,7 +1,7 @@
 import type { Opaque } from './opaque';
 import type { ElementShape, Fqn, Tag, ThemeColor } from './element';
 import type { ElementExpression, Expression } from './expression';
-import type { NonEmptyArray } from './_common';
+import type { IconUrl, NonEmptyArray } from './_common';
 export type ViewID = Opaque<string, 'ViewID'>;
 export interface ViewRuleExpression {
     isInclude: boolean;
@@ -13,6 +13,7 @@ export interface ViewRuleStyle {
     style: {
         color?: ThemeColor;
         shape?: ElementShape;
+        icon?: IconUrl;
     };
 }
 export declare function isViewRuleStyle(rule: ViewRule): rule is ViewRuleStyle;

package/dist/utils/fqn.d.ts

@@ -1,8 +1,14 @@
 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 isAncestor<E extends {
+    id: Fqn;
+}>(...args: [ancestor: Fqn, another: Fqn] | [ancestor: E, another: E]): boolean;
+export declare function isSameHierarchy<E extends {
+    id: Fqn;
+}>(...args: [one: Fqn, another: Fqn] | [one: E, another: E]): boolean;
+export declare function isDescendantOf<E extends {
+    id: Fqn;
+}>(ancestors: E[]): (e: E) => 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;
@@ -16,8 +22,8 @@ export declare function parentFqn(fqn: Fqn): Fqn | null;
  *                    - Positive number if a is deeper than b.
  *                    - Negative number if b is deeper than a.
  */
-export declare const compareFqnHierarchically: (a: string, b: string) => number;
-export declare const compareByFqnHierarchically: <T extends {
+export declare function compareFqnHierarchically(a: string, b: string): number;
+export declare function compareByFqnHierarchically<T extends {
     id: Fqn;
-}>(a: T, b: T) => number;
+}>(a: T, b: T): number;
 //# sourceMappingURL=fqn.d.ts.map

package/dist/utils/fqn.js

@@ -20,10 +20,7 @@ export function isSameHierarchy(...args) {
     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)
-    ]);
+    const predicates = ancestors.flatMap(a => [(e) => e.id === a.id, (e) => isAncestor(a, e)]);
     return anyPass(predicates);
 }
 export function notDescendantOf(ancestors) {
@@ -66,7 +63,7 @@ export function parentFqn(fqn) {
  *                    - Positive number if a is deeper than b.
  *                    - Negative number if b is deeper than a.
  */
-export const compareFqnHierarchically = (a, b) => {
+export function compareFqnHierarchically(a, b) {
     const depthA = a.split('.').length;
     const depthB = b.split('.').length;
     if (depthA === depthB) {
@@ -76,8 +73,8 @@ export const compareFqnHierarchically = (a, b) => {
     else {
         return depthA - depthB;
     }
-};
-export const compareByFqnHierarchically = (a, b) => {
+}
+export function compareByFqnHierarchically(a, b) {
     return compareFqnHierarchically(a.id, b.id);
-};
+}
 //# sourceMappingURL=fqn.js.map

package/dist/utils/guards.d.ts

@@ -1,6 +1,6 @@
-import type { NonEmptyArray } from "../types";
+import type { NonEmptyArray } from '../types';
 export declare function isString(value: unknown): value is string;
-export declare function failExpectedNever(arg: never): never;
+export declare function failUnexpected(arg: never): never;
 export declare function ignoreNeverInRuntime(arg: never): void;
 export declare function isNonEmptyArray<A>(arr: ArrayLike<A>): arr is NonEmptyArray<A>;
 //# sourceMappingURL=guards.d.ts.map

package/dist/utils/guards.js

@@ -1,8 +1,9 @@
+import { NonExhaustiveError } from '../errors/nonexhaustive';
 export function isString(value) {
     return typeof value === 'string';
 }
-export function failExpectedNever(arg) {
-    throw new Error(`Unexpected value: ${JSON.stringify(arg)}`);
+export function failUnexpected(arg) {
+    throw new NonExhaustiveError(`Unexpected value: ${JSON.stringify(arg)}`);
 }
 export function ignoreNeverInRuntime(arg) {
     console.warn(`Unexpected and ignored value: ${JSON.stringify(arg)}`);

package/dist/utils/relations.d.ts

@@ -1,12 +1,12 @@
-import type { Fqn, Element } from '../types';
+import type { Fqn } from '../types';
 type Relation = {
-    source: Fqn;
-    target: Fqn;
+    source: string;
+    target: string;
 };
 type RelationPredicate = (rel: Relation) => boolean;
 export declare const compareRelations: <T extends {
-    source: Fqn;
-    target: Fqn;
+    source: string;
+    target: string;
 }>(a: T, b: T) => number;
 export declare const isInside: (parent: Fqn) => RelationPredicate;
 export declare const isBetween: (source: Fqn, target: Fqn) => RelationPredicate;
@@ -14,6 +14,11 @@ export declare const isAnyBetween: (source: Fqn, target: Fqn) => RelationPredica
 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 declare const hasRelation: <R extends {
+    source: Fqn;
+    target: Fqn;
+}>(rel: R) => <E extends {
+    id: Fqn;
+}>(element: E) => boolean;
 export {};
 //# sourceMappingURL=relations.d.ts.map

package/dist/utils/relations.js

@@ -1,5 +1,6 @@
 import { anyPass } from 'remeda';
 import { compareFqnHierarchically, isAncestor } from './fqn';
+import { either } from 'rambdax';
 export const compareRelations = (a, b) => {
     return (compareFqnHierarchically(a.source, b.source) || compareFqnHierarchically(a.target, b.target));
 };
@@ -23,21 +24,26 @@ export const isAnyBetween = (source, target) => {
 export const isIncoming = (target) => {
     const targetPrefix = target + '.';
     return (rel) => {
-        return (!(rel.source + '.').startsWith(targetPrefix) && (rel.target === target || (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 === source || (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 anyPass([isIncoming(source), isOutgoing(source)]);
+    return either(isIncoming(source), isOutgoing(source));
 };
 export const hasRelation = (rel) => {
     return (element) => {
-        return isAncestor(rel.source, element.id) || isAncestor(rel.target, element.id);
+        return (rel.source === element.id ||
+            rel.target === element.id ||
+            isAncestor(element.id, rel.source) ||
+            isAncestor(element.id, rel.target));
     };
 };
 //# sourceMappingURL=relations.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@likec4/core",
-  "version": "0.31.0",
+  "version": "0.32.0",
   "license": "MIT",
   "homepage": "https://likec4.dev",
   "author": "Denis Davydkov <denis@davydkov.com>",
@@ -44,6 +44,11 @@
       "import": "./dist/colors.js",
       "default": "./dist/colors.js"
     },
+    "./errors": {
+      "types": "./dist/errors/index.d.ts",
+      "import": "./dist/errors/index.js",
+      "default": "./dist/errors/index.js"
+    },
     "./utils": {
       "types": "./dist/utils/index.d.ts",
       "import": "./dist/utils/index.js",
@@ -77,6 +82,11 @@
         "import": "./dist/colors.js",
         "default": "./dist/colors.js"
       },
+      "./errors": {
+        "types": "./dist/errors/index.d.ts",
+        "import": "./dist/errors/index.js",
+        "default": "./dist/errors/index.js"
+      },
       "./utils": {
         "types": "./dist/utils/index.d.ts",
         "import": "./dist/utils/index.js",
@@ -96,6 +106,7 @@
     "remeda": "^1.24.0"
   },
   "devDependencies": {
-    "typescript": "^5.1.6"
+    "typescript": "^5.1.6",
+    "vitest": "^0.34.1"
   }
 }