@likec4/core 0.32.0 → 0.33.1

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

@@ -0,0 +1,324 @@
+import { anyPass, both, either, isNil, uniq } from "rambdax";
+import * as Expr from "../types/expression.mjs";
+import { Relations, commonAncestor, isAncestor, isSameHierarchy } from "../utils/index.mjs";
+import { isAnyInOut, isBetween, isIncoming, isInside, isOutgoing } from "../utils/relations.mjs";
+import { ComputeCtx } from "./compute-ctx.mjs";
+export 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(both(Relations.isInside(expr.element), Relations.isAnyInOut(child.id)));
+    });
+  }
+  const ctxElements = uniq([...ctx.elements, ...ctx.implicits]);
+  const excludeImplicits = [];
+  for (const el of elements) {
+    if (ctx.root && ctx.root !== el.id && !isAncestor(el.id, ctx.root)) {
+      excludeImplicits.push(...[...ctx.implicits].filter((impl) => isAncestor(el.id, impl.id)));
+    }
+    for (const ctxEl of ctxElements) {
+      if (!isSameHierarchy(el, ctxEl)) {
+        filters.push(Relations.isAnyBetween(el.id, ctxEl.id));
+      }
+    }
+  }
+  const relations = filters.length ? ctx.index.filterRelations(anyPass(filters)) : [];
+  if (excludeImplicits.length == 0) {
+    return ctx.include({ elements, relations });
+  }
+  return ctx.include({ elements, relations }).exclude({ implicits: excludeImplicits });
+};
+export 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 });
+};
+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 }) => isNil(tags) || tags.length === 0 || !tags.includes(expr.elementTag);
+    }
+  }
+};
+export 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
+  );
+};
+export 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 });
+};
+export 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(isAnyInOut(root));
+    const implicits = [];
+    for (const implicit of allImplicits) {
+      if (inOut.some(isAnyInOut(implicit.id))) {
+        implicits.push(implicit);
+      }
+    }
+    return ctx.include({
+      elements,
+      relations: [...ctx.index.filterRelations(isInside(root)), ...inOut],
+      implicits
+    });
+  } else {
+    const elements = ctx.index.rootElements();
+    if (elements.length <= 1) {
+      return new ComputeCtx(ctx.index, ctx.root, new Set(elements));
+    }
+    const relations = ctx.index.filterRelations(
+      (rel) => isNil(commonAncestor(rel.source, rel.target))
+    );
+    return ctx.include({
+      elements,
+      relations
+    });
+  }
+};
+export const excludeWildcardRef = (ctx, _expr) => {
+  const { root } = ctx;
+  if (root) {
+    const relations = [...ctx.relations].filter(either(isInside(root), isAnyInOut(root)));
+    return ctx.exclude({
+      elements: [...ctx.elements].filter((e) => e.id === root || isAncestor(root, e.id)),
+      relations,
+      implicits: [...ctx.implicits].filter((e) => relations.some(isAnyInOut(e.id)))
+    });
+  } else {
+    return new ComputeCtx(ctx.index, ctx.root);
+  }
+};
+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 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)];
+  }
+};
+export 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(isIncoming(expr.incoming.element));
+  }
+  const implicits = [];
+  const relations = [];
+  for (const el of elements) {
+    const elRelations = allrelations.filter(isIncoming(el.id));
+    if (elRelations.length > 0) {
+      relations.push(...elRelations);
+      implicits.push(el);
+    }
+  }
+  return ctx.include({
+    relations,
+    implicits
+  });
+};
+export 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 = anyPass(elements.map((el) => isIncoming(el.id)));
+  const excluded = [...ctx.relations].filter(isIncomings);
+  if (excluded.length > 0) {
+    return ctx.exclude({
+      relations: excluded
+    });
+  }
+  return ctx;
+};
+export 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(isOutgoing(expr.outgoing.element));
+  }
+  const implicits = [];
+  const relations = [];
+  for (const el of elements) {
+    const elRelations = allrelations.filter(isOutgoing(el.id));
+    if (elRelations.length > 0) {
+      relations.push(...elRelations);
+      implicits.push(el);
+    }
+  }
+  return ctx.include({
+    relations,
+    implicits
+  });
+};
+export 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 = anyPass(elements.map((el) => isOutgoing(el.id)));
+  const excluded = [...ctx.relations].filter(isOutgoings);
+  if (excluded.length > 0) {
+    return ctx.exclude({
+      relations: excluded
+    });
+  }
+  return ctx;
+};
+export 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(isAnyInOut(expr.inout.element));
+  }
+  const implicits = [];
+  const relations = [];
+  for (const target of targets) {
+    const foundRelations = allrelations.filter(isAnyInOut(target.id));
+    if (foundRelations.length > 0) {
+      relations.push(...foundRelations);
+      implicits.push(target);
+    }
+  }
+  return ctx.include({
+    relations,
+    implicits
+  });
+};
+export 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(anyPass(targets.map((t) => isAnyInOut(t.id))));
+  if (excluded.length > 0) {
+    return ctx.exclude({
+      relations: excluded
+    });
+  }
+  return ctx;
+};
+export 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 (isSameHierarchy(source, target)) {
+        continue;
+      }
+      const foundRelations = ctx.index.filterRelations(isBetween(source.id, target.id));
+      if (foundRelations.length > 0) {
+        relations.push(...foundRelations);
+        implicits.push(source, target);
+      }
+    }
+  }
+  return ctx.include({
+    relations,
+    implicits
+  });
+};
+export 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 (isSameHierarchy(source, target)) {
+        continue;
+      }
+      filters.push(isBetween(source.id, target.id));
+    }
+  }
+  if (filters.length == 0) {
+    return ctx;
+  }
+  const excluded = [...ctx.relations].filter(anyPass(filters));
+  if (excluded.length == 0) {
+    return ctx;
+  }
+  return ctx.exclude({
+    relations: excluded
+  });
+};

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

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

package/dist/compute-view/compute.js

@@ -1,43 +1,53 @@
-import { compact, find, map, mapToObj } from 'remeda';
-import { ModelIndex } from '../model-index';
-import { computeElementView } from './compute-element-view';
-export function computeView(view, index) {
-    try {
-        return computeElementView(view, index);
-    }
-    catch (e) {
-        console.error(e);
-        return null;
-    }
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assignNavigateTo = assignNavigateTo;
+exports.computeView = computeView;
+exports.computeViews = computeViews;
+var _remeda = require("remeda");
+var _modelIndex = require("../model-index");
+var _computeElementView = require("./compute-element-view");
+function computeView(view, index) {
+  try {
+    return (0, _computeElementView.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: mapToObj(computedViews, view => [view.id, view])
-    };
+function computeViews(model) {
+  const index = _modelIndex.ModelIndex.from(model);
+  const computedViews = (0, _remeda.compact)((0, _remeda.map)(model.views, view => computeView(view, index)));
+  return {
+    elements: model.elements,
+    relations: model.relations,
+    views: (0, _remeda.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);
-        }
+function assignNavigateTo(views) {
+  const allElementViews = /* @__PURE__ */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;
-            }
-        }
+  }
+  for (const {
+    id,
+    nodes
+  } of views) {
+    for (const node of nodes) {
+      const navigateTo = (0, _remeda.find)(allElementViews.get(node.id) ?? [], v => v !== id);
+      if (navigateTo) {
+        node.navigateTo = navigateTo;
+      }
     }
-    return views;
-}
-//# sourceMappingURL=compute.js.map
+  }
+  return views;
+}

package/dist/compute-view/compute.mjs

@@ -0,0 +1,39 @@
+import { compact, find, map, mapToObj } from "remeda";
+import { ModelIndex } from "../model-index/index.mjs";
+import { computeElementView } from "./compute-element-view.mjs";
+export function computeView(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: mapToObj(computedViews, (view) => [view.id, view])
+  };
+}
+export function assignNavigateTo(views) {
+  const allElementViews = /* @__PURE__ */ new Map();
+  for (const { id, viewOf } of views) {
+    if (viewOf) {
+      const viewsOf = allElementViews.get(viewOf) ?? [];
+      viewsOf.push(id);
+      allElementViews.set(viewOf, viewsOf);
+    }
+  }
+  for (const { id, nodes } of views) {
+    for (const node of nodes) {
+      const navigateTo = find(allElementViews.get(node.id) ?? [], (v) => v !== id);
+      if (navigateTo) {
+        node.navigateTo = navigateTo;
+      }
+    }
+  }
+  return views;
+}

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

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

package/dist/compute-view/index.js

@@ -1,2 +1,24 @@
-export { computeView, computeViews, assignNavigateTo } from './compute';
-//# sourceMappingURL=index.js.map
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "assignNavigateTo", {
+  enumerable: true,
+  get: function () {
+    return _compute.assignNavigateTo;
+  }
+});
+Object.defineProperty(exports, "computeView", {
+  enumerable: true,
+  get: function () {
+    return _compute.computeView;
+  }
+});
+Object.defineProperty(exports, "computeViews", {
+  enumerable: true,
+  get: function () {
+    return _compute.computeViews;
+  }
+});
+var _compute = require("./compute");

package/dist/compute-view/index.mjs

@@ -0,0 +1 @@
+export { computeView, computeViews, assignNavigateTo } from "./compute.mjs";

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

@@ -1,3 +1,2 @@
 import type { Element } from '../../types';
 export declare function anyPossibleRelations(elements: Element[]): Generator<[source: Element, target: Element]>;
-//# sourceMappingURL=anyPossibleRelations.d.ts.map

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

@@ -1,13 +1,18 @@
-import { prop, uniqBy } from 'rambdax';
-import { compareByFqnHierarchically, isAncestor } from '../../utils/fqn';
-export function* anyPossibleRelations(elements) {
-    const uniqElements = uniqBy(prop('id'), elements).sort(compareByFqnHierarchically).reverse();
-    for (const source of uniqElements) {
-        for (const target of uniqElements) {
-            if (source !== target && !isAncestor(source, target) && !isAncestor(target, source)) {
-                yield [source, target];
-            }
-        }
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.anyPossibleRelations = anyPossibleRelations;
+var _rambdax = require("rambdax");
+var _fqn = require("../../utils/fqn");
+function* anyPossibleRelations(elements) {
+  const uniqElements = (0, _rambdax.uniqBy)((0, _rambdax.prop)("id"), elements).sort(_fqn.compareByFqnHierarchically).reverse();
+  for (const source of uniqElements) {
+    for (const target of uniqElements) {
+      if (source !== target && !(0, _fqn.isAncestor)(source, target) && !(0, _fqn.isAncestor)(target, source)) {
+        yield [source, target];
+      }
     }
-}
-//# sourceMappingURL=anyPossibleRelations.js.map
+  }
+}

package/dist/compute-view/utils/anyPossibleRelations.mjs

@@ -0,0 +1,12 @@
+import { prop, uniqBy } from "rambdax";
+import { compareByFqnHierarchically, isAncestor } from "../../utils/fqn.mjs";
+export function* anyPossibleRelations(elements) {
+  const uniqElements = uniqBy(prop("id"), elements).sort(compareByFqnHierarchically).reverse();
+  for (const source of uniqElements) {
+    for (const target of uniqElements) {
+      if (source !== target && !isAncestor(source, target) && !isAncestor(target, source)) {
+        yield [source, target];
+      }
+    }
+  }
+}

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

@@ -0,0 +1,3 @@
+import { type ComputedNode } from '../../types';
+import { type ViewRuleStyle } from '../../types/view';
+export declare function applyViewRuleStyles(rules: ViewRuleStyle[], _nodes: ComputedNode[]): ComputedNode[];

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

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.applyViewRuleStyles = applyViewRuleStyles;
+var _rambdax = require("rambdax");
+var _remeda = require("remeda");
+var Expr = _interopRequireWildcard(require("../../types/expression"));
+var _errors = require("../../errors");
+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; }
+function applyViewRuleStyles(rules, _nodes) {
+  if (rules.length === 0) {
+    return _nodes;
+  }
+  const nodes = (0, _rambdax.clone)(_nodes);
+  for (const rule of rules) {
+    const predicates = [];
+    if (!rule.style.color && !rule.style.shape) {
+      continue;
+    }
+    for (const target of rule.targets) {
+      if (Expr.isWildcard(target)) {
+        predicates.push(() => true);
+        break;
+      }
+      if (Expr.isElementKindExpr(target)) {
+        predicates.push(target.isEqual ? n => n.kind === target.elementKind : n => n.kind !== target.elementKind);
+        continue;
+      }
+      if (Expr.isElementTagExpr(target)) {
+        predicates.push(target.isEqual ? ({
+          tags
+        }) => !!tags && tags.includes(target.elementTag) : ({
+          tags
+        }) => (0, _rambdax.isNil)(tags) || !tags.includes(target.elementTag));
+        continue;
+      }
+      if (Expr.isElementRef(target)) {
+        const {
+          element,
+          isDescedants
+        } = target;
+        predicates.push(isDescedants ? n => n.id.startsWith(element + ".") : n => n.id === element);
+        continue;
+      }
+      (0, _errors.nonexhaustive)(target);
+    }
+    (0, _rambdax.filter)((0, _rambdax.anyPass)(predicates), nodes).forEach(n => {
+      n.shape = rule.style.shape ?? n.shape;
+      n.color = rule.style.color ?? n.color;
+      if (_remeda.isDefined.strict(rule.style.icon)) {
+        n.icon = rule.style.icon;
+      }
+    });
+  }
+  return nodes;
+}