likec4 0.40.0-build.3 → 0.40.0-build.7

package/dist/@likec4/core/__test__/data.d.ts

@@ -0,0 +1,20 @@
+import { ModelIndex } from '../model-index';
+import type { Element, Relation } from '../types';
+export declare const fakeElements: {
+    cloud: Element;
+    customer: Element;
+    support: Element;
+    amazon: Element;
+    'amazon.s3': Element;
+    'cloud.backend': Element;
+    'cloud.frontend': Element;
+    'cloud.backend.graphql': Element;
+    'cloud.backend.storage': Element;
+    'cloud.frontend.adminPanel': Element;
+    'cloud.frontend.dashboard': Element;
+};
+export type FakeElementIds = keyof typeof fakeElements;
+export declare const fakeRelations: Relation[];
+export type FakeRelationIds = keyof typeof fakeRelations;
+export declare const fakeModel: () => ModelIndex;
+//# sourceMappingURL=data.d.ts.map

package/dist/@likec4/core/__test__/index.d.ts

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

package/dist/@likec4/core/colors.d.ts

@@ -0,0 +1,148 @@
+export declare const RelationColors: {
+    readonly lineColor: "#b1b1b1";
+    readonly labelColor: "#b1b1b1";
+};
+export declare const Colors: {
+    readonly primary: {
+        fill: "#3b82f6";
+        stroke: "#2563eb";
+        hiContrast: "#eff6ff";
+        loContrast: "#bfdbfe";
+    };
+    readonly blue: {
+        fill: "#3b82f6";
+        stroke: "#2563eb";
+        hiContrast: "#eff6ff";
+        loContrast: "#bfdbfe";
+    };
+    readonly secondary: {
+        fill: "#0284c7";
+        stroke: "#0369a1";
+        hiContrast: "#f0f9ff";
+        loContrast: "#e0f2fe";
+    };
+    readonly sky: {
+        fill: "#0284c7";
+        stroke: "#0369a1";
+        hiContrast: "#f0f9ff";
+        loContrast: "#e0f2fe";
+    };
+    readonly muted: {
+        fill: "#64748b";
+        stroke: "#475569";
+        hiContrast: "#f8fafc";
+        loContrast: "#e2e8f0";
+    };
+    readonly slate: {
+        fill: "#64748b";
+        stroke: "#475569";
+        hiContrast: "#f8fafc";
+        loContrast: "#e2e8f0";
+    };
+    readonly gray: {
+        readonly fill: "#737373";
+        readonly stroke: "#525252";
+        readonly hiContrast: "#fafafa";
+        readonly loContrast: "#e5e5e5";
+    };
+    readonly red: {
+        readonly fill: "#b54548";
+        readonly stroke: "#8c333a";
+        readonly hiContrast: "#f8fafc";
+        readonly loContrast: "#F9C6C6";
+    };
+    readonly green: {
+        readonly fill: "#428a4f";
+        readonly stroke: "#2d5d39";
+        readonly hiContrast: "#f8fafc";
+        readonly loContrast: "#c2f0c2";
+    };
+    readonly amber: {
+        readonly fill: "#d97706";
+        readonly stroke: "#b45309";
+        readonly hiContrast: "#f8fafc";
+        readonly loContrast: "#ffe0c2";
+    };
+    readonly indigo: {
+        readonly fill: "#6366f1";
+        readonly stroke: "#4f46e5";
+        readonly hiContrast: "#eef2ff";
+        readonly loContrast: "#c7d2fe";
+    };
+};
+export declare const defaultTheme: {
+    readonly font: "Helvetica";
+    readonly shadow: "#0a0a0a";
+    readonly relation: {
+        readonly lineColor: "#b1b1b1";
+        readonly labelColor: "#b1b1b1";
+    };
+    readonly colors: {
+        readonly primary: {
+            fill: "#3b82f6";
+            stroke: "#2563eb";
+            hiContrast: "#eff6ff";
+            loContrast: "#bfdbfe";
+        };
+        readonly blue: {
+            fill: "#3b82f6";
+            stroke: "#2563eb";
+            hiContrast: "#eff6ff";
+            loContrast: "#bfdbfe";
+        };
+        readonly secondary: {
+            fill: "#0284c7";
+            stroke: "#0369a1";
+            hiContrast: "#f0f9ff";
+            loContrast: "#e0f2fe";
+        };
+        readonly sky: {
+            fill: "#0284c7";
+            stroke: "#0369a1";
+            hiContrast: "#f0f9ff";
+            loContrast: "#e0f2fe";
+        };
+        readonly muted: {
+            fill: "#64748b";
+            stroke: "#475569";
+            hiContrast: "#f8fafc";
+            loContrast: "#e2e8f0";
+        };
+        readonly slate: {
+            fill: "#64748b";
+            stroke: "#475569";
+            hiContrast: "#f8fafc";
+            loContrast: "#e2e8f0";
+        };
+        readonly gray: {
+            readonly fill: "#737373";
+            readonly stroke: "#525252";
+            readonly hiContrast: "#fafafa";
+            readonly loContrast: "#e5e5e5";
+        };
+        readonly red: {
+            readonly fill: "#b54548";
+            readonly stroke: "#8c333a";
+            readonly hiContrast: "#f8fafc";
+            readonly loContrast: "#F9C6C6";
+        };
+        readonly green: {
+            readonly fill: "#428a4f";
+            readonly stroke: "#2d5d39";
+            readonly hiContrast: "#f8fafc";
+            readonly loContrast: "#c2f0c2";
+        };
+        readonly amber: {
+            readonly fill: "#d97706";
+            readonly stroke: "#b45309";
+            readonly hiContrast: "#f8fafc";
+            readonly loContrast: "#ffe0c2";
+        };
+        readonly indigo: {
+            readonly fill: "#6366f1";
+            readonly stroke: "#4f46e5";
+            readonly hiContrast: "#eef2ff";
+            readonly loContrast: "#c7d2fe";
+        };
+    };
+};

package/dist/@likec4/core/colors.js

@@ -0,0 +1,104 @@
+const blue = {
+  // fill: colors.blue[500],
+  // stroke: colors.blue[600],
+  // hiContrast: colors.blue[50],
+  // loContrast: colors.blue[200],
+  fill: "#3b82f6",
+  stroke: "#2563eb",
+  hiContrast: "#eff6ff",
+  loContrast: "#bfdbfe"
+};
+const sky = {
+  // fill: colors.sky[600],
+  // stroke: colors.sky[700],
+  // hiContrast: colors.sky[50],
+  // loContrast: colors.sky[100],
+  fill: "#0284c7",
+  stroke: "#0369a1",
+  hiContrast: "#f0f9ff",
+  loContrast: "#e0f2fe"
+};
+const slate = {
+  // fill: colors.slate[500],
+  // stroke: colors.slate[600],
+  // hiContrast: colors.slate[50],
+  // loContrast: colors.slate[200],
+  fill: "#64748b",
+  stroke: "#475569",
+  hiContrast: "#f8fafc",
+  loContrast: "#e2e8f0"
+};
+export const RelationColors = {
+  lineColor: "#b1b1b1",
+  labelColor: "#b1b1b1"
+};
+export const Colors = {
+  primary: blue,
+  blue,
+  secondary: sky,
+  sky,
+  muted: slate,
+  slate,
+  gray: {
+    // fill: colors.neutral[500],
+    // stroke: colors.neutral[600],
+    // hiContrast: colors.neutral[50],
+    // loContrast: colors.neutral[200],
+    fill: "#737373",
+    stroke: "#525252",
+    hiContrast: "#fafafa",
+    loContrast: "#e5e5e5"
+  },
+  red: {
+    // fill: colors.red[500],
+    // stroke: colors.red[600],
+    // hiContrast: colors.red[50],
+    // loContrast: colors.red[200],
+    fill: "#b54548",
+    stroke: "#8c333a",
+    // hiContrast: '#fef2f2',
+    // loContrast: '#fecaca',
+    // hiContrast: '#191111', // colors.gray[900],
+    // loContrast: '#3b1219' // colors.gray[800],
+    hiContrast: "#f8fafc",
+    // hiContrast: '#f8fafc',
+    // loContrast: '#fdd8d8' // radix black red 12
+    loContrast: "#F9C6C6"
+  },
+  green: {
+    fill: "#428a4f",
+    stroke: "#2d5d39",
+    hiContrast: "#f8fafc",
+    loContrast: "#c2f0c2"
+  },
+  amber: {
+    // fill: colors.amber[600],
+    // stroke: colors.amber[700],
+    // hiContrast: colors.amber[50],
+    // loContrast: colors.amber[200],
+    fill: "#d97706",
+    stroke: "#b45309",
+    // hiContrast: '#fffbeb',
+    // loContrast: '#fde68a',
+    hiContrast: "#f8fafc",
+    // colors.gray[900],
+    loContrast: "#ffe0c2"
+    // colors.gray[800],
+  },
+  indigo: {
+    // fill: colors.indigo[500],
+    // stroke: colors.indigo[600],
+    // hiContrast: colors.indigo[50],
+    // loContrast: colors.indigo[200],
+    fill: "#6366f1",
+    stroke: "#4f46e5",
+    hiContrast: "#eef2ff",
+    loContrast: "#c7d2fe"
+  }
+};
+export const defaultTheme = {
+  font: "Helvetica",
+  shadow: "#0a0a0a",
+  relation: RelationColors,
+  colors: Colors
+};

package/dist/@likec4/core/compute-view/EdgeBuilder.d.ts

@@ -0,0 +1,6 @@
+import type { ComputedEdge, Fqn, Relation } from '../types';
+export declare class EdgeBuilder {
+    private _relationsObj;
+    add(source: Fqn, target: Fqn, relation: Relation): this;
+    build(): ComputedEdge[];
+}

package/dist/@likec4/core/compute-view/EdgeBuilder.js

@@ -0,0 +1,30 @@
+import { keys, pluck } from "rambdax";
+import { commonAncestor, compareRelations } from "../utils/index.js";
+export class EdgeBuilder {
+  _relationsObj = {};
+  add(source, target, relation) {
+    const bySource = this._relationsObj[source] ?? {};
+    const relations = bySource[target] ?? [];
+    relations.push(relation);
+    bySource[target] = relations;
+    this._relationsObj[source] = bySource;
+    return this;
+  }
+  build() {
+    return keys(this._relationsObj).flatMap((source) => {
+      const targets = this._relationsObj[source] ?? {};
+      return keys(targets).map((target) => {
+        const relations = (targets[target] ?? []).sort(compareRelations);
+        const label = relations.find((r) => r.title !== "")?.title ?? null;
+        return {
+          id: `${source}:${target}`,
+          parent: commonAncestor(source, target),
+          source,
+          target,
+          label,
+          relations: pluck("id", relations)
+        };
+      });
+    }).sort(compareRelations).reverse();
+  }
+}

package/dist/@likec4/core/compute-view/compute-ctx.d.ts

@@ -0,0 +1,20 @@
+import type { ModelIndex } from '../model-index';
+import type { Fqn, Element, Relation, ViewRuleExpression, ElementView } from '../types';
+export type ComputeCtxPatch = {
+    elements?: Element[];
+    relations?: Relation[];
+    implicits?: Element[];
+};
+export declare class ComputeCtx {
+    index: ModelIndex;
+    root: Fqn | null;
+    elements: ReadonlySet<Element>;
+    relations: ReadonlySet<Relation>;
+    implicits: ReadonlySet<Element>;
+    readonly allElements: ReadonlySet<Element>;
+    constructor(index: ModelIndex, root: Fqn | null, elements?: ReadonlySet<Element>, relations?: ReadonlySet<Relation>, implicits?: ReadonlySet<Element>);
+    include({ elements, relations, implicits }: ComputeCtxPatch): ComputeCtx;
+    exclude({ elements, relations, implicits }: ComputeCtxPatch): ComputeCtx;
+    processViewRules(viewRules: ViewRuleExpression[]): ComputeCtx;
+    static create(view: ElementView, index: ModelIndex): ComputeCtx;
+}

package/dist/@likec4/core/compute-view/compute-ctx.js

@@ -0,0 +1,100 @@
+import { difference } from "rambdax";
+import { Expr, isStrictElementView, isViewRuleExpression } from "../types/index.js";
+import {
+  excludeElementKindOrTag,
+  excludeElementRef,
+  excludeInOutExpr,
+  excludeIncomingExpr,
+  excludeOutgoingExpr,
+  excludeRelationExpr,
+  excludeWildcardRef,
+  includeElementKindOrTag,
+  includeElementRef,
+  includeInOutExpr,
+  includeIncomingExpr,
+  includeOutgoingExpr,
+  includeRelationExpr,
+  includeWildcardRef
+} from "./compute-predicates.js";
+import { nonexhaustive } from "../errors/index.js";
+export class ComputeCtx {
+  constructor(index, root, elements = /* @__PURE__ */ new Set(), relations = /* @__PURE__ */ new Set(), implicits = /* @__PURE__ */ new Set()) {
+    this.index = index;
+    this.root = root;
+    this.elements = elements;
+    this.relations = relations;
+    this.implicits = implicits;
+    this.allElements = /* @__PURE__ */ new Set([...this.elements, ...this.implicits]);
+  }
+  allElements;
+  include({ elements, relations, implicits }) {
+    return new ComputeCtx(
+      this.index,
+      this.root,
+      elements ? /* @__PURE__ */ new Set([...this.elements, ...elements]) : this.elements,
+      relations ? /* @__PURE__ */ new Set([...this.relations, ...relations]) : this.relations,
+      implicits ? /* @__PURE__ */ new Set([...this.implicits, ...implicits]) : this.implicits
+    );
+  }
+  exclude({ elements, relations, implicits }) {
+    let newImplicits = implicits ? new Set(difference([...this.implicits], implicits)) : this.implicits;
+    if (elements) {
+      newImplicits = new Set(difference([...newImplicits], elements));
+    }
+    return new ComputeCtx(
+      this.index,
+      this.root,
+      elements ? new Set(difference([...this.elements], elements)) : this.elements,
+      relations ? new Set(difference([...this.relations], relations)) : this.relations,
+      newImplicits
+    );
+  }
+  processViewRules(viewRules) {
+    let ctx = this;
+    for (const { isInclude, exprs } of viewRules) {
+      for (const expr of exprs) {
+        if (Expr.isElementKindExpr(expr) || Expr.isElementTagExpr(expr)) {
+          ctx = isInclude ? includeElementKindOrTag(ctx, expr) : excludeElementKindOrTag(ctx, expr);
+          continue;
+        }
+        if (Expr.isElementRef(expr)) {
+          ctx = isInclude ? includeElementRef(ctx, expr) : excludeElementRef(ctx, expr);
+          continue;
+        }
+        if (Expr.isWildcard(expr)) {
+          ctx = isInclude ? includeWildcardRef(ctx, expr) : excludeWildcardRef(ctx, expr);
+          continue;
+        }
+        if (Expr.isIncoming(expr)) {
+          ctx = isInclude ? includeIncomingExpr(ctx, expr) : excludeIncomingExpr(ctx, expr);
+          continue;
+        }
+        if (Expr.isOutgoing(expr)) {
+          ctx = isInclude ? includeOutgoingExpr(ctx, expr) : excludeOutgoingExpr(ctx, expr);
+          continue;
+        }
+        if (Expr.isInOut(expr)) {
+          ctx = isInclude ? includeInOutExpr(ctx, expr) : excludeInOutExpr(ctx, expr);
+          continue;
+        }
+        if (Expr.isRelation(expr)) {
+          ctx = isInclude ? includeRelationExpr(ctx, expr) : excludeRelationExpr(ctx, expr);
+          continue;
+        }
+        nonexhaustive(expr);
+      }
+    }
+    return ctx;
+  }
+  static create(view, index) {
+    const rootElement = isStrictElementView(view) ? view.viewOf : null;
+    let ctx = new ComputeCtx(index, rootElement);
+    const rulesInclude = view.rules.filter(isViewRuleExpression);
+    if (rootElement && rulesInclude.length == 0) {
+      ctx = ctx.include({
+        elements: [index.find(rootElement)]
+      });
+    }
+    return ctx.processViewRules(rulesInclude);
+  }
+}

package/dist/@likec4/core/compute-view/compute-ctx.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=compute-ctx.spec.d.ts.map

package/dist/@likec4/core/compute-view/compute-element-view.d.ts

@@ -0,0 +1,3 @@
+import type { ModelIndex } from '../model-index';
+import { type ComputedView, type ElementView } from '../types';
+export declare function computeElementView(view: ElementView, index: ModelIndex): ComputedView;

package/dist/@likec4/core/compute-view/compute-element-view.js

@@ -0,0 +1,98 @@
+import { allPass, find } from "remeda";
+import { nonNullable } from "../errors/index.js";
+import {
+  DefaultElementShape,
+  DefaultThemeColor,
+  isViewRuleAutoLayout,
+  isViewRuleStyle
+} from "../types/index.js";
+import { compareByFqnHierarchically, isAncestor, isSameHierarchy, parentFqn } from "../utils/index.js";
+import { EdgeBuilder } from "./EdgeBuilder.js";
+import { ComputeCtx } from "./compute-ctx.js";
+import { applyViewRuleStyles } from "./utils/applyViewRuleStyles.js";
+import { sortNodes } from "./utils/sortNodes.js";
+function reduceToMap(elementsIterator) {
+  return Array.from(elementsIterator).sort(compareByFqnHierarchically).reduce((map, { id, color, shape, ...el }) => {
+    let parent = parentFqn(id);
+    let level = 0;
+    while (parent) {
+      if (map.has(parent)) {
+        break;
+      }
+      parent = parentFqn(parent);
+    }
+    if (parent) {
+      const parentNd = nonNullable(map.get(parent));
+      parentNd.children.push(id);
+      level = parentNd.level + 1;
+    }
+    const node = {
+      ...el,
+      id,
+      parent,
+      level,
+      color: color ?? DefaultThemeColor,
+      shape: shape ?? DefaultElementShape,
+      children: [],
+      inEdges: [],
+      outEdges: []
+    };
+    map.set(id, node);
+    return map;
+  }, /* @__PURE__ */ new Map());
+}
+const keepOriginalSortFromView = (_nodes, ctx) => {
+  const nodes = [...ctx.allElements].flatMap((e) => _nodes.get(e.id) || []);
+  for (const node of nodes) {
+    node.children = nodes.flatMap((n) => n.parent === node.id ? n.id : []);
+  }
+  return nodes;
+};
+export function computeElementView(view, index) {
+  const ctx = ComputeCtx.create(view, index);
+  const leafsFirst = [...ctx.allElements].sort((a, b) => -1 * compareByFqnHierarchically(a, b));
+  const elementsWithRelations = /* @__PURE__ */ new Set();
+  const edgeBuilder = new EdgeBuilder();
+  const anscestorOf = (id) => (e) => e.id === id || isAncestor(e.id, id);
+  const sortedRelations = [...ctx.relations];
+  for (const rel of sortedRelations) {
+    const source = find(leafsFirst, anscestorOf(rel.source));
+    if (!source) {
+      continue;
+    }
+    const target = find(
+      leafsFirst,
+      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 nodesMap = reduceToMap(/* @__PURE__ */ new Set([...ctx.elements, ...elementsWithRelations]));
+  const edges = edgeBuilder.build().map((edge) => {
+    while (edge.parent) {
+      if (nodesMap.has(edge.parent)) {
+        break;
+      }
+      edge.parent = parentFqn(edge.parent);
+    }
+    nonNullable(nodesMap.get(edge.source)).outEdges.push(edge.id);
+    nonNullable(nodesMap.get(edge.target)).inEdges.push(edge.id);
+    return edge;
+  });
+  const nodes = applyViewRuleStyles(
+    view.rules.filter(isViewRuleStyle),
+    sortNodes(keepOriginalSortFromView(nodesMap, ctx), edges)
+    // map(e => nodesMap.get(e.id)!, Array.from(elements))
+  );
+  const autoLayoutRule = view.rules.find(isViewRuleAutoLayout);
+  return {
+    ...view,
+    autoLayout: autoLayoutRule?.autoLayout ?? "TB",
+    nodes,
+    edges
+  };
+}

package/dist/@likec4/core/compute-view/compute-element-view.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=compute-element-view.spec.d.ts.map

package/dist/@likec4/core/compute-view/compute-predicates.d.ts

@@ -0,0 +1,16 @@
+import { Expr } from '../types';
+import { ComputeCtx } from './compute-ctx';
+export declare const includeElementRef: (ctx: ComputeCtx, expr: Expr.ElementRefExpr) => ComputeCtx;
+export declare const excludeElementRef: (ctx: ComputeCtx, expr: Expr.ElementRefExpr) => ComputeCtx;
+export declare const includeElementKindOrTag: (ctx: ComputeCtx, expr: Expr.ElementKindExpr | Expr.ElementTagExpr) => ComputeCtx;
+export declare const excludeElementKindOrTag: (ctx: ComputeCtx, expr: Expr.ElementKindExpr | Expr.ElementTagExpr) => ComputeCtx;
+export declare const includeWildcardRef: (ctx: ComputeCtx, _expr: Expr.WildcardExpr) => ComputeCtx;
+export declare const excludeWildcardRef: (ctx: ComputeCtx, _expr: Expr.WildcardExpr) => ComputeCtx;
+export declare const includeIncomingExpr: (ctx: ComputeCtx, expr: Expr.IncomingExpr) => ComputeCtx;
+export declare const excludeIncomingExpr: (ctx: ComputeCtx, expr: Expr.IncomingExpr) => ComputeCtx;
+export declare const includeOutgoingExpr: (ctx: ComputeCtx, expr: Expr.OutgoingExpr) => ComputeCtx;
+export declare const excludeOutgoingExpr: (ctx: ComputeCtx, expr: Expr.OutgoingExpr) => ComputeCtx;
+export declare const includeInOutExpr: (ctx: ComputeCtx, expr: Expr.InOutExpr) => ComputeCtx;
+export declare const excludeInOutExpr: (ctx: ComputeCtx, expr: Expr.InOutExpr) => ComputeCtx;
+export declare const includeRelationExpr: (ctx: ComputeCtx, expr: Expr.RelationExpr) => ComputeCtx;
+export declare const excludeRelationExpr: (ctx: ComputeCtx, expr: Expr.RelationExpr) => ComputeCtx;