@likec4/core 0.32.0 → 0.33.0

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

@@ -0,0 +1,145 @@
+import { allPass, find } from "remeda";
+import { nonNullable, nonexhaustive } from "../errors/index.mjs";
+import {
+  DefaultElementShape,
+  DefaultThemeColor
+} from "../types/index.mjs";
+import * as Expr from "../types/expression.mjs";
+import { isViewRuleAutoLayout, isViewRuleExpression, isViewRuleStyle } from "../types/view.mjs";
+import { compareByFqnHierarchically, isAncestor, isSameHierarchy, parentFqn } from "../utils/index.mjs";
+import { EdgeBuilder } from "./EdgeBuilder.mjs";
+import { ComputeCtx } from "./compute-ctx.mjs";
+import {
+  excludeElementKindOrTag,
+  excludeElementRef,
+  excludeInOutExpr,
+  excludeIncomingExpr,
+  excludeOutgoingExpr,
+  excludeRelationExpr,
+  excludeWildcardRef,
+  includeElementKindOrTag,
+  includeElementRef,
+  includeInOutExpr,
+  includeIncomingExpr,
+  includeOutgoingExpr,
+  includeRelationExpr,
+  includeWildcardRef
+} from "./compute-predicates.mjs";
+import { applyViewRuleStyles } from "./utils/applyViewRuleStyles.mjs";
+import { sortNodes } from "./utils/sortNodes.mjs";
+function reduceToMap(elementsIterator) {
+  return Array.from(elementsIterator).sort(compareByFqnHierarchically).reduce((map, { id, color, shape, ...el }) => {
+    let parent = parentFqn(id);
+    while (parent) {
+      if (map.has(parent)) {
+        break;
+      }
+      parent = parentFqn(parent);
+    }
+    if (parent) {
+      const parentNd = nonNullable(map.get(parent));
+      parentNd.children.push(id);
+    }
+    const node = {
+      ...el,
+      id,
+      parent,
+      color: color ?? DefaultThemeColor,
+      shape: shape ?? DefaultElementShape,
+      children: [],
+      inEdges: [],
+      outEdges: []
+    };
+    map.set(id, node);
+    return map;
+  }, /* @__PURE__ */ new Map());
+}
+export function computeElementView(view, index) {
+  const rootElement = 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)]
+    });
+  }
+  for (const { isInclude, exprs } of rulesInclude) {
+    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);
+    }
+  }
+  const allElements = [...ctx.elements, ...ctx.implicits].sort(compareByFqnHierarchically).reverse();
+  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(allElements, anscestorOf(rel.source));
+    if (!source) {
+      continue;
+    }
+    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 = /* @__PURE__ */ new Set([...ctx.elements, ...elementsWithRelations]);
+  const nodesMap = reduceToMap(elements);
+  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(nodesMap, 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/compute-view/compute-predicates.d.ts

@@ -0,0 +1,16 @@
+import * as Expr from '../types/expression';
+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;

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

@@ -0,0 +1,358 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.includeWildcardRef = exports.includeRelationExpr = exports.includeOutgoingExpr = exports.includeIncomingExpr = exports.includeInOutExpr = exports.includeElementRef = exports.includeElementKindOrTag = exports.excludeWildcardRef = exports.excludeRelationExpr = exports.excludeOutgoingExpr = exports.excludeIncomingExpr = exports.excludeInOutExpr = exports.excludeElementRef = exports.excludeElementKindOrTag = void 0;
+var _rambdax = require("rambdax");
+var Expr = _interopRequireWildcard(require("../types/expression"));
+var _utils = require("../utils");
+var _relations = require("../utils/relations");
+var _computeCtx = require("./compute-ctx");
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+const includeElementRef = (ctx, expr) => {
+  const elements = expr.isDescedants ? ctx.index.children(expr.element) : [ctx.index.find(expr.element)];
+  const filters = [];
+  if (expr.isDescedants) {
+    elements.forEach(child => {
+      filters.push((0, _rambdax.both)(_utils.Relations.isInside(expr.element), _utils.Relations.isAnyInOut(child.id)));
+    });
+  }
+  const ctxElements = (0, _rambdax.uniq)([...ctx.elements, ...ctx.implicits]);
+  const excludeImplicits = [];
+  for (const el of elements) {
+    if (ctx.root && ctx.root !== el.id && !(0, _utils.isAncestor)(el.id, ctx.root)) {
+      excludeImplicits.push(...[...ctx.implicits].filter(impl => (0, _utils.isAncestor)(el.id, impl.id)));
+    }
+    for (const ctxEl of ctxElements) {
+      if (!(0, _utils.isSameHierarchy)(el, ctxEl)) {
+        filters.push(_utils.Relations.isAnyBetween(el.id, ctxEl.id));
+      }
+    }
+  }
+  const relations = filters.length ? ctx.index.filterRelations((0, _rambdax.anyPass)(filters)) : [];
+  if (excludeImplicits.length == 0) {
+    return ctx.include({
+      elements,
+      relations
+    });
+  }
+  return ctx.include({
+    elements,
+    relations
+  }).exclude({
+    implicits: excludeImplicits
+  });
+};
+exports.includeElementRef = includeElementRef;
+const excludeElementRef = (ctx, expr) => {
+  const elements = expr.isDescedants ? ctx.index.children(expr.element) : [ctx.index.find(expr.element)];
+  const elementsIds = elements.map(e => e.id);
+  const relations = [...ctx.relations].filter(r => elementsIds.includes(r.source) || elementsIds.includes(r.target));
+  return ctx.exclude({
+    elements,
+    relations
+  });
+};
+exports.excludeElementRef = excludeElementRef;
+const asElementPredicate = expr => {
+  if (expr.isEqual) {
+    if (Expr.isElementKindExpr(expr)) {
+      return e => e.kind === expr.elementKind;
+    } else {
+      return ({
+        tags
+      }) => !!tags && tags.includes(expr.elementTag);
+    }
+  } else {
+    if (Expr.isElementKindExpr(expr)) {
+      return e => e.kind !== expr.elementKind;
+    } else {
+      return ({
+        tags
+      }) => (0, _rambdax.isNil)(tags) || tags.length === 0 || !tags.includes(expr.elementTag);
+    }
+  }
+};
+const includeElementKindOrTag = (ctx, expr) => {
+  const elements = ctx.index.elements.filter(asElementPredicate(expr));
+  return elements.reduce((accCtx, el) => includeElementRef(accCtx, {
+    element: el.id,
+    isDescedants: false
+  }), ctx);
+};
+exports.includeElementKindOrTag = includeElementKindOrTag;
+const excludeElementKindOrTag = (ctx, expr) => {
+  const predicate = asElementPredicate(expr);
+  const elements = [...ctx.elements].filter(predicate);
+  const implicits = [...ctx.implicits].filter(predicate);
+  return ctx.exclude({
+    elements,
+    implicits
+  });
+};
+exports.excludeElementKindOrTag = excludeElementKindOrTag;
+const includeWildcardRef = (ctx, _expr) => {
+  const {
+    root
+  } = ctx;
+  if (root) {
+    const elements = [ctx.index.find(root), ...ctx.index.children(root)];
+    const allImplicits = [...ctx.index.siblings(root), ...ctx.index.ancestors(root).flatMap(a => [...ctx.index.siblings(a.id)])];
+    const inOut = ctx.index.filterRelations((0, _relations.isAnyInOut)(root));
+    const implicits = [];
+    for (const implicit of allImplicits) {
+      if (inOut.some((0, _relations.isAnyInOut)(implicit.id))) {
+        implicits.push(implicit);
+      }
+    }
+    return ctx.include({
+      elements,
+      relations: [...ctx.index.filterRelations((0, _relations.isInside)(root)), ...inOut],
+      implicits
+    });
+  } else {
+    const elements = ctx.index.rootElements();
+    if (elements.length <= 1) {
+      return new _computeCtx.ComputeCtx(ctx.index, ctx.root, new Set(elements));
+    }
+    const relations = ctx.index.filterRelations(rel => (0, _rambdax.isNil)((0, _utils.commonAncestor)(rel.source, rel.target)));
+    return ctx.include({
+      elements,
+      relations
+    });
+  }
+};
+exports.includeWildcardRef = includeWildcardRef;
+const excludeWildcardRef = (ctx, _expr) => {
+  const {
+    root
+  } = ctx;
+  if (root) {
+    const relations = [...ctx.relations].filter((0, _rambdax.either)((0, _relations.isInside)(root), (0, _relations.isAnyInOut)(root)));
+    return ctx.exclude({
+      elements: [...ctx.elements].filter(e => e.id === root || (0, _utils.isAncestor)(root, e.id)),
+      relations,
+      implicits: [...ctx.implicits].filter(e => relations.some((0, _relations.isAnyInOut)(e.id)))
+    });
+  } else {
+    return new _computeCtx.ComputeCtx(ctx.index, ctx.root);
+  }
+};
+exports.excludeWildcardRef = excludeWildcardRef;
+const resolveElements = (ctx, expr) => {
+  if (Expr.isWildcard(expr)) {
+    if (ctx.root) {
+      return [ctx.index.find(ctx.root)];
+    } else {
+      return ctx.index.rootElements();
+    }
+  }
+  if (Expr.isElementKindExpr(expr)) {
+    return ctx.index.elements.filter(el => {
+      if (expr.isEqual) {
+        return el.kind === expr.elementKind;
+      }
+      return el.kind !== expr.elementKind;
+    });
+  }
+  if (Expr.isElementTagExpr(expr)) {
+    return ctx.index.elements.filter(el => {
+      const tags = el.tags;
+      if (expr.isEqual) {
+        return !!tags && tags.includes(expr.elementTag);
+      }
+      return (0, _rambdax.isNil)(tags) || tags.length === 0 || !tags.includes(expr.elementTag);
+    });
+  }
+  if (expr.isDescedants) {
+    return ctx.index.children(expr.element);
+  } else {
+    return [ctx.index.find(expr.element)];
+  }
+};
+const includeIncomingExpr = (ctx, expr) => {
+  if (Expr.isWildcard(expr.incoming) && !ctx.root) {
+    return ctx;
+  }
+  const elements = resolveElements(ctx, expr.incoming);
+  if (elements.length === 0) {
+    return ctx;
+  }
+  let allrelations = ctx.index.relations;
+  if (Expr.isElementRef(expr.incoming)) {
+    allrelations = allrelations.filter((0, _relations.isIncoming)(expr.incoming.element));
+  }
+  const implicits = [];
+  const relations = [];
+  for (const el of elements) {
+    const elRelations = allrelations.filter((0, _relations.isIncoming)(el.id));
+    if (elRelations.length > 0) {
+      relations.push(...elRelations);
+      implicits.push(el);
+    }
+  }
+  return ctx.include({
+    relations,
+    implicits
+  });
+};
+exports.includeIncomingExpr = includeIncomingExpr;
+const excludeIncomingExpr = (ctx, expr) => {
+  if (Expr.isWildcard(expr.incoming) && !ctx.root) {
+    return ctx;
+  }
+  const elements = resolveElements(ctx, expr.incoming);
+  if (elements.length === 0) {
+    return ctx;
+  }
+  const isIncomings = (0, _rambdax.anyPass)(elements.map(el => (0, _relations.isIncoming)(el.id)));
+  const excluded = [...ctx.relations].filter(isIncomings);
+  if (excluded.length > 0) {
+    return ctx.exclude({
+      relations: excluded
+    });
+  }
+  return ctx;
+};
+exports.excludeIncomingExpr = excludeIncomingExpr;
+const includeOutgoingExpr = (ctx, expr) => {
+  if (Expr.isWildcard(expr.outgoing) && !ctx.root) {
+    return ctx;
+  }
+  const elements = resolveElements(ctx, expr.outgoing);
+  if (elements.length === 0) {
+    return ctx;
+  }
+  let allrelations = ctx.index.relations;
+  if (Expr.isElementRef(expr.outgoing)) {
+    allrelations = allrelations.filter((0, _relations.isOutgoing)(expr.outgoing.element));
+  }
+  const implicits = [];
+  const relations = [];
+  for (const el of elements) {
+    const elRelations = allrelations.filter((0, _relations.isOutgoing)(el.id));
+    if (elRelations.length > 0) {
+      relations.push(...elRelations);
+      implicits.push(el);
+    }
+  }
+  return ctx.include({
+    relations,
+    implicits
+  });
+};
+exports.includeOutgoingExpr = includeOutgoingExpr;
+const excludeOutgoingExpr = (ctx, expr) => {
+  if (Expr.isWildcard(expr.outgoing) && !ctx.root) {
+    return ctx;
+  }
+  const elements = resolveElements(ctx, expr.outgoing);
+  if (elements.length === 0) {
+    return ctx;
+  }
+  const isOutgoings = (0, _rambdax.anyPass)(elements.map(el => (0, _relations.isOutgoing)(el.id)));
+  const excluded = [...ctx.relations].filter(isOutgoings);
+  if (excluded.length > 0) {
+    return ctx.exclude({
+      relations: excluded
+    });
+  }
+  return ctx;
+};
+exports.excludeOutgoingExpr = excludeOutgoingExpr;
+const includeInOutExpr = (ctx, expr) => {
+  if (Expr.isWildcard(expr.inout) && !ctx.root) {
+    return ctx;
+  }
+  const targets = resolveElements(ctx, expr.inout);
+  if (targets.length === 0) {
+    return ctx;
+  }
+  let allrelations = ctx.index.relations;
+  if (Expr.isElementRef(expr.inout)) {
+    allrelations = allrelations.filter((0, _relations.isAnyInOut)(expr.inout.element));
+  }
+  const implicits = [];
+  const relations = [];
+  for (const target of targets) {
+    const foundRelations = allrelations.filter((0, _relations.isAnyInOut)(target.id));
+    if (foundRelations.length > 0) {
+      relations.push(...foundRelations);
+      implicits.push(target);
+    }
+  }
+  return ctx.include({
+    relations,
+    implicits
+  });
+};
+exports.includeInOutExpr = includeInOutExpr;
+const excludeInOutExpr = (ctx, expr) => {
+  if (Expr.isWildcard(expr.inout) && !ctx.root) {
+    return ctx;
+  }
+  const targets = resolveElements(ctx, expr.inout);
+  if (targets.length === 0) {
+    return ctx;
+  }
+  const excluded = [...ctx.relations].filter((0, _rambdax.anyPass)(targets.map(t => (0, _relations.isAnyInOut)(t.id))));
+  if (excluded.length > 0) {
+    return ctx.exclude({
+      relations: excluded
+    });
+  }
+  return ctx;
+};
+exports.excludeInOutExpr = excludeInOutExpr;
+const includeRelationExpr = (ctx, expr) => {
+  const sources = resolveElements(ctx, expr.source);
+  const targets = resolveElements(ctx, expr.target);
+  if (sources.length === 0 || targets.length === 0) {
+    return ctx;
+  }
+  const implicits = [];
+  const relations = [];
+  for (const source of sources) {
+    for (const target of targets) {
+      if ((0, _utils.isSameHierarchy)(source, target)) {
+        continue;
+      }
+      const foundRelations = ctx.index.filterRelations((0, _relations.isBetween)(source.id, target.id));
+      if (foundRelations.length > 0) {
+        relations.push(...foundRelations);
+        implicits.push(source, target);
+      }
+    }
+  }
+  return ctx.include({
+    relations,
+    implicits
+  });
+};
+exports.includeRelationExpr = includeRelationExpr;
+const excludeRelationExpr = (ctx, expr) => {
+  const sources = resolveElements(ctx, expr.source);
+  const targets = resolveElements(ctx, expr.target);
+  const filters = [];
+  for (const source of sources) {
+    for (const target of targets) {
+      if ((0, _utils.isSameHierarchy)(source, target)) {
+        continue;
+      }
+      filters.push((0, _relations.isBetween)(source.id, target.id));
+    }
+  }
+  if (filters.length == 0) {
+    return ctx;
+  }
+  const excluded = [...ctx.relations].filter((0, _rambdax.anyPass)(filters));
+  if (excluded.length == 0) {
+    return ctx;
+  }
+  return ctx.exclude({
+    relations: excluded
+  });
+};
+exports.excludeRelationExpr = excludeRelationExpr;