@likec4/core 1.17.1 → 1.18.0

package/dist/shared/core.BBgiAAv1.mjs

@@ -0,0 +1,144 @@
+import { u, n as nonexhaustive, a as n } from './core.k12s_keD.mjs';
+
+function o(a){return t=>!a(t)}
+
+function t(...a){return u(e,a)}var e=(a,o)=>o.every(l=>l(a));
+
+function y(...a){return u(r,a)}var r=(a,o)=>o.some(e=>e(a));
+
+function isElementRef(expr) {
+  return "element" in expr;
+}
+function isExpandedElementExpr(expr) {
+  return "expanded" in expr;
+}
+function isCustomElement(expr) {
+  return "custom" in expr && (isElement(expr.custom.expr) || isElementWhere(expr.custom.expr));
+}
+function isWildcard(expr) {
+  return "wildcard" in expr;
+}
+function isElementKindExpr(expr) {
+  return "elementKind" in expr && "isEqual" in expr;
+}
+function isElementTagExpr(expr) {
+  return "elementTag" in expr && "isEqual" in expr;
+}
+function isElement(expr) {
+  return isElementRef(expr) || isWildcard(expr) || isElementKindExpr(expr) || isElementTagExpr(expr) || isExpandedElementExpr(expr);
+}
+function isElementWhere(expr) {
+  return "where" in expr && isElement(expr.where.expr);
+}
+function isElementPredicateExpr(expr) {
+  return isElement(expr) || isElementWhere(expr) || isCustomElement(expr);
+}
+function isRelation(expr) {
+  return "source" in expr && "target" in expr;
+}
+function isInOut(expr) {
+  return "inout" in expr;
+}
+function isIncoming(expr) {
+  return "incoming" in expr;
+}
+function isOutgoing(expr) {
+  return "outgoing" in expr;
+}
+function isRelationExpression(expr) {
+  return isRelation(expr) || isInOut(expr) || isIncoming(expr) || isOutgoing(expr);
+}
+function isRelationWhere(expr) {
+  return "where" in expr && isRelationExpression(expr.where.expr);
+}
+function isCustomRelationExpr(expr) {
+  return "customRelation" in expr;
+}
+function isRelationPredicateExpr(expr) {
+  return isRelationExpression(expr) || isRelationWhere(expr) || isCustomRelationExpr(expr);
+}
+
+const expression = {
+  __proto__: null,
+  isCustomElement: isCustomElement,
+  isCustomRelationExpr: isCustomRelationExpr,
+  isElement: isElement,
+  isElementKindExpr: isElementKindExpr,
+  isElementPredicateExpr: isElementPredicateExpr,
+  isElementRef: isElementRef,
+  isElementTagExpr: isElementTagExpr,
+  isElementWhere: isElementWhere,
+  isExpandedElementExpr: isExpandedElementExpr,
+  isInOut: isInOut,
+  isIncoming: isIncoming,
+  isOutgoing: isOutgoing,
+  isRelation: isRelation,
+  isRelationExpression: isRelationExpression,
+  isRelationPredicateExpr: isRelationPredicateExpr,
+  isRelationWhere: isRelationWhere,
+  isWildcard: isWildcard
+};
+
+const isTagEqual = (operator) => {
+  return "tag" in operator;
+};
+const isKindEqual = (operator) => {
+  return "kind" in operator;
+};
+const isNotOperator = (operator) => {
+  return "not" in operator;
+};
+const isAndOperator = (operator) => {
+  return "and" in operator;
+};
+const isOrOperator = (operator) => {
+  return "or" in operator;
+};
+function whereOperatorAsPredicate(operator) {
+  switch (true) {
+    case isTagEqual(operator): {
+      if ("eq" in operator.tag) {
+        const tag2 = operator.tag.eq;
+        return (value) => {
+          return Array.isArray(value.tags) && value.tags.includes(tag2);
+        };
+      }
+      const tag = operator.tag.neq;
+      return (value) => {
+        return !Array.isArray(value.tags) || !value.tags.includes(tag);
+      };
+    }
+    case isKindEqual(operator): {
+      if ("eq" in operator.kind) {
+        const kind2 = operator.kind.eq;
+        return (value) => {
+          return value.kind === kind2;
+        };
+      }
+      const kind = operator.kind.neq;
+      return (value) => {
+        return n(value.kind) || value.kind !== kind;
+      };
+    }
+    case isNotOperator(operator): {
+      const predicate = whereOperatorAsPredicate(operator.not);
+      return o(predicate);
+    }
+    case isAndOperator(operator): {
+      const predicates = operator.and.map(whereOperatorAsPredicate);
+      return t(predicates);
+    }
+    case isOrOperator(operator): {
+      const predicates = operator.or.map(whereOperatorAsPredicate);
+      return y(predicates);
+    }
+    default:
+      nonexhaustive(operator);
+  }
+}
+
+const DefaultLineStyle = "dashed";
+const DefaultArrowType = "normal";
+const DefaultRelationshipColor = "gray";
+
+export { y as A, o as B, t as C, DefaultLineStyle as D, isElementRef as a, isExpandedElementExpr as b, isCustomElement as c, isWildcard as d, expression as e, isElementKindExpr as f, isElementTagExpr as g, isElement as h, isElementPredicateExpr as i, isElementWhere as j, isRelation as k, isInOut as l, isIncoming as m, isOutgoing as n, isRelationExpression as o, isRelationWhere as p, isCustomRelationExpr as q, isRelationPredicateExpr as r, isTagEqual as s, isKindEqual as t, isNotOperator as u, isAndOperator as v, isOrOperator as w, whereOperatorAsPredicate as x, DefaultArrowType as y, DefaultRelationshipColor as z };