@likec4/core 0.2.1 → 0.4.0

package/dist/compute-view/EdgeBuilder.js

@@ -1,5 +1,6 @@
-import { equals, keys, pluck, reject } from 'rambdax';
-import { commonAncestor, compareFqnHierarchically } from '../utils';
+import { equals, head, keys, pluck, reject } from 'rambdax';
+import { commonAncestor, compareFqnHierarchically } from '../utils/fqn';
+import { compareRelations } from '../utils/relations';
 export class EdgeBuilder {
     _relationsObj = {};
     add(source, target, relation) {
@@ -11,12 +12,11 @@ export class EdgeBuilder {
         return this;
     }
     build() {
-        return keys(this._relationsObj).sort(compareFqnHierarchically).reverse().flatMap(source => {
+        return keys(this._relationsObj).flatMap(source => {
             const targets = this._relationsObj[source] ?? {};
-            return keys(targets).sort(compareFqnHierarchically).reverse().map(target => {
-                const relations = targets[target] ?? [];
-                const titles = reject(equals(''), pluck('title', relations));
-                const label = titles.length === 1 ? titles[0] : null;
+            return keys(targets).map(target => {
+                const relations = (targets[target] ?? []).sort(compareRelations);
+                const label = head(reject(equals(''), pluck('title', relations))) ?? null;
                 return {
                     id: `${source}:${target}`,
                     parent: commonAncestor(source, target),
@@ -26,6 +26,6 @@ export class EdgeBuilder {
                     relations: pluck('id', relations)
                 };
             });
-        });
+        }).sort(compareRelations).reverse();
     }
 }

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

@@ -1,7 +1,7 @@
 import { anyPass, filter } from 'rambdax';
 import { DefaultElementShape, DefaultThemeColor } from '../types';
 import * as Expression from '../types/expression';
-import { isViewRuleExpression, isViewRuleStyle } from '../types/view';
+import { isViewRuleAutoLayout, isViewRuleExpression, isViewRuleStyle } from '../types/view';
 import { Relations, compareByFqnHierarchically, failExpectedNever, isSameHierarchy, parentFqn } from '../utils';
 import { EdgeBuilder } from './EdgeBuilder';
 import { anyPossibleRelations } from './utils/anyPossibleRelations';
@@ -155,8 +155,10 @@ export function computeElementView(view, index) {
         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.js

@@ -1,7 +1,7 @@
 import { anyPass, map, pluck, uniq } from 'rambdax';
 import * as Expr from '../../types/expression';
 import { failExpectedNever, isAncestor } from '../../utils';
-import { isBetween, isIncoming, isOutgoing } from '../../utils/relations';
+import { isBetween, isIncoming, isInside, isOutgoing } from '../../utils/relations';
 import { anyPossibleRelations } from './anyPossibleRelations';
 const dropNested = (elements) => {
     return elements.reduce((acc, current) => {
@@ -65,7 +65,7 @@ const evaluateElementExpression = (index, expr, rootElement = null) => {
                 ])
             ];
             relations = index.filterRelations(anyPass([
-                isBetween(rootElement),
+                isInside(rootElement),
                 isIncoming(rootElement),
                 isOutgoing(rootElement),
             ]));
@@ -85,7 +85,7 @@ const evaluateElementExpression = (index, expr, rootElement = null) => {
     if (Expr.isElementRef(expr)) {
         elements = expr.isDescedants ? index.children(expr.element) : [index.find(expr.element)];
         if (expr.isDescedants) {
-            relations = index.filterRelations(isBetween(expr.element));
+            relations = index.filterRelations(isInside(expr.element));
             //   relations = index.filterRelations(anyPass([
             //     isBetween(expr.element),
             //     isIncoming(expr.element),

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

@@ -1,7 +1,7 @@
 import type { Opaque } from './opaque';
 import type { ElementShape, Fqn, ThemeColor } from './element';
 import type { RelationID } from './relation';
-import type { ElementView, ViewID } from './view';
+import type { ElementView, ViewID, ViewRuleAutoLayout } from './view';
 export type NodeId = Fqn;
 export type EdgeId = Opaque<string, 'EdgeId'>;
 export interface ComputedNode {
@@ -24,6 +24,7 @@ export interface ComputedEdge {
     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/view.d.ts

@@ -15,7 +15,11 @@ export interface ViewRuleStyle {
     };
 }
 export declare function isViewRuleStyle(rule: ViewRule): rule is ViewRuleStyle;
-export type ViewRule = ViewRuleExpression | ViewRuleStyle;
+export interface ViewRuleAutoLayout {
+    autoLayout: 'TB' | 'BT' | 'LR' | 'RL';
+}
+export declare function isViewRuleAutoLayout(rule: ViewRule): rule is ViewRuleAutoLayout;
+export type ViewRule = ViewRuleExpression | ViewRuleStyle | ViewRuleAutoLayout;
 export interface ElementView {
     readonly id: ViewID;
     readonly viewOf?: Fqn;

package/dist/types/view.js

@@ -4,3 +4,6 @@ export function isViewRuleExpression(rule) {
 export function isViewRuleStyle(rule) {
     return 'style' in rule && 'targets' in rule;
 }
+export function isViewRuleAutoLayout(rule) {
+    return 'autoLayout' in rule;
+}

package/dist/utils/relations.d.ts

@@ -3,7 +3,12 @@ type Relation = {
     source: Fqn;
     target: Fqn;
 };
-export declare const isBetween: (source: Fqn, target?: Fqn) => (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;

package/dist/utils/relations.js

@@ -1,5 +1,15 @@
 import { either } from 'rambdax';
-export const isBetween = (source, target = source) => {
+import { compareFqnHierarchically } from './fqn';
+export const compareRelations = (a, b) => {
+    return compareFqnHierarchically(a.source, b.source) || compareFqnHierarchically(a.target, b.target);
+};
+export const isInside = (parent) => {
+    const prefix = parent + '.';
+    return (rel) => {
+        return rel.source.startsWith(prefix) && rel.target.startsWith(prefix);
+    };
+};
+export const isBetween = (source, target) => {
     const sourcePrefix = source + '.';
     const targetPrefix = target + '.';
     return (rel) => {

package/package.json

@@ -1,7 +1,6 @@
 {
   "name": "@likec4/core",
-  "version": "0.2.1",
-  "type": "module",
+  "version": "0.4.0",
   "bugs": "https://github.com/likec4/likec4/issues",
   "homepage": "https://like-c4.dev",
   "author": "Denis Davydkov <denis@davydkov.com>",
@@ -24,6 +23,7 @@
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "type": "module",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -83,6 +83,6 @@
   "devDependencies": {
     "typescript": "^5.0.3",
     "vite": "^4.2.1",
-    "vitest": "^0.29.8"
+    "vitest": "^0.30.1"
   }
 }