@likec4/core 0.33.0 → 0.34.0

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

@@ -0,0 +1,363 @@
+"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 _types = require("../types/index.cjs");
+var _utils = require("../utils/index.cjs");
+var _computeCtx = require("./compute-ctx.cjs");
+const {
+  isAnyInOut,
+  isBetween,
+  isIncoming,
+  isInside,
+  isOutgoing,
+  isAnyBetween
+} = _utils.Relations;
+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)(isInside(expr.element), 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(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 (_types.Expr.isElementKindExpr(expr)) {
+      return e => e.kind === expr.elementKind;
+    } else {
+      return ({
+        tags
+      }) => !!tags && tags.includes(expr.elementTag);
+    }
+  } else {
+    if (_types.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(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.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)(isInside(root), 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(isAnyInOut(e.id)))
+    });
+  } else {
+    return new _computeCtx.ComputeCtx(ctx.index, ctx.root);
+  }
+};
+exports.excludeWildcardRef = excludeWildcardRef;
+const resolveElements = (ctx, expr) => {
+  if (_types.Expr.isWildcard(expr)) {
+    if (ctx.root) {
+      return [ctx.index.find(ctx.root)];
+    } else {
+      return ctx.index.rootElements();
+    }
+  }
+  if (_types.Expr.isElementKindExpr(expr)) {
+    return ctx.index.elements.filter(el => {
+      if (expr.isEqual) {
+        return el.kind === expr.elementKind;
+      }
+      return el.kind !== expr.elementKind;
+    });
+  }
+  if (_types.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 (_types.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 (_types.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
+  });
+};
+exports.includeIncomingExpr = includeIncomingExpr;
+const excludeIncomingExpr = (ctx, expr) => {
+  if (_types.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 => 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 (_types.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 (_types.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
+  });
+};
+exports.includeOutgoingExpr = includeOutgoingExpr;
+const excludeOutgoingExpr = (ctx, expr) => {
+  if (_types.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 => 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 (_types.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 (_types.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
+  });
+};
+exports.includeInOutExpr = includeInOutExpr;
+const excludeInOutExpr = (ctx, expr) => {
+  if (_types.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 => 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(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(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;

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

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