@likec4/core 1.19.1 → 1.20.0

package/dist/shared/core.B2QYWlYe.cjs

@@ -0,0 +1,435 @@
+'use strict';
+
+const chunkRAAYCPUM = require('./core.DsoCu540.cjs');
+
+function o$1(a){return t=>!a(t)}
+
+function n(e){return e==null}
+
+function o(r){return Array.isArray(r)}
+
+function t(...a){return chunkRAAYCPUM.u(e,a)}var e=(a,o)=>o.every(l=>l(a));
+
+function y(...a){return chunkRAAYCPUM.u(r,a)}var r=(a,o)=>o.some(e=>e(a));
+
+exports.DeploymentElement = void 0;
+((DeploymentElement2) => {
+  DeploymentElement2.isDeploymentNode = (el) => {
+    return "kind" in el && !("element" in el);
+  };
+  DeploymentElement2.isInstance = (el) => {
+    return "element" in el && !("kind" in el);
+  };
+})(exports.DeploymentElement || (exports.DeploymentElement = {}));
+
+function AsFqn(name, parent) {
+  return parent ? parent + "." + name : name;
+}
+const BorderStyles = ["solid", "dashed", "dotted", "none"];
+exports.ElementKind = void 0;
+((ElementKind2) => {
+  ElementKind2.Group = "@group";
+})(exports.ElementKind || (exports.ElementKind = {}));
+const ElementShapes = [
+  "rectangle",
+  "person",
+  "browser",
+  "mobile",
+  "cylinder",
+  "storage",
+  "queue"
+];
+const DefaultThemeColor = "primary";
+const DefaultElementShape = "rectangle";
+
+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
+};
+
+exports.FqnRef = void 0;
+((FqnRef2) => {
+  FqnRef2.isInsideInstanceRef = (ref) => {
+    return "deployment" in ref && "element" in ref;
+  };
+  FqnRef2.isDeploymentElementRef = (ref) => {
+    return "deployment" in ref && !("element" in ref);
+  };
+  FqnRef2.isDeploymentRef = (ref) => {
+    return !(0, FqnRef2.isModelRef)(ref);
+  };
+  FqnRef2.isModelRef = (ref) => {
+    return "model" in ref;
+  };
+  FqnRef2.toDeploymentRef = (ref) => {
+    chunkRAAYCPUM.invariant((0, FqnRef2.isDeploymentRef)(ref), "Expected DeploymentRef");
+    return (0, FqnRef2.isInsideInstanceRef)(ref) ? {
+      id: ref.deployment,
+      element: ref.element
+    } : {
+      id: ref.deployment
+    };
+  };
+})(exports.FqnRef || (exports.FqnRef = {}));
+exports.FqnExpr = void 0;
+((FqnExpr2) => {
+  FqnExpr2.isWildcard = (expr) => {
+    return "wildcard" in expr && expr.wildcard === true;
+  };
+  FqnExpr2.isModelRef = (ref) => {
+    return "ref" in ref && exports.FqnRef.isModelRef(ref.ref);
+  };
+  FqnExpr2.isDeploymentRef = (ref) => {
+    return "ref" in ref && exports.FqnRef.isDeploymentRef(ref.ref);
+  };
+})(exports.FqnExpr || (exports.FqnExpr = {}));
+exports.RelationExpr = void 0;
+((RelationExpr2) => {
+  RelationExpr2.isDirect = (expr) => {
+    return "source" in expr && "target" in expr;
+  };
+  RelationExpr2.isIncoming = (expr) => {
+    return "incoming" in expr;
+  };
+  RelationExpr2.isOutgoing = (expr) => {
+    return "outgoing" in expr;
+  };
+  RelationExpr2.isInOut = (expr) => {
+    return "inout" in expr;
+  };
+  RelationExpr2.isWhere = (expr) => {
+    return "where" in expr;
+  };
+})(exports.RelationExpr || (exports.RelationExpr = {}));
+exports.ExpressionV2 = void 0;
+((ExpressionV22) => {
+  ExpressionV22.isFqnExpr = (expr) => {
+    return exports.FqnExpr.isWildcard(expr) || exports.FqnExpr.isModelRef(expr) || exports.FqnExpr.isDeploymentRef(expr);
+  };
+  ExpressionV22.isRelation = (expr) => {
+    return exports.RelationExpr.isDirect(expr) || exports.RelationExpr.isIncoming(expr) || exports.RelationExpr.isOutgoing(expr) || exports.RelationExpr.isInOut(expr);
+  };
+})(exports.ExpressionV2 || (exports.ExpressionV2 = {}));
+
+const isTagEqual = (operator) => {
+  return "tag" in operator;
+};
+const isKindEqual = (operator) => {
+  return "kind" in operator;
+};
+const isParticipantOperator = (operator) => {
+  return "participant" 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 isParticipantOperator(operator): {
+      const participant = operator.participant;
+      const participantPredicate = whereOperatorAsPredicate(operator.operator);
+      return participantIs(participant, participantPredicate);
+    }
+    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$1(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:
+      chunkRAAYCPUM.nonexhaustive(operator);
+  }
+}
+function participantIs(participant, predicate) {
+  return (value) => {
+    if (!value.source || !value.target) {
+      return false;
+    }
+    switch (participant) {
+      case "source": {
+        return predicate(value.source);
+      }
+      case "target": {
+        return predicate(value.target);
+      }
+    }
+  };
+}
+
+const DefaultLineStyle = "dashed";
+const DefaultArrowType = "normal";
+const DefaultRelationshipColor = "gray";
+
+function isViewRulePredicate(rule) {
+  return "include" in rule && Array.isArray(rule.include) || "exclude" in rule && Array.isArray(rule.exclude);
+}
+function isViewRuleGlobalPredicateRef(rule) {
+  return "predicateId" in rule;
+}
+function isViewRuleStyle(rule) {
+  return "style" in rule && "targets" in rule && Array.isArray(rule.targets);
+}
+function isViewRuleGlobalStyle(rule) {
+  return "styleId" in rule;
+}
+function isAutoLayoutDirection(autoLayout) {
+  return autoLayout === "TB" || autoLayout === "BT" || autoLayout === "LR" || autoLayout === "RL";
+}
+function isViewRuleAutoLayout(rule) {
+  return "direction" in rule;
+}
+function isViewRuleGroup(rule) {
+  return "title" in rule && "groupRules" in rule && Array.isArray(rule.groupRules);
+}
+function isDynamicViewParallelSteps(step) {
+  return "__parallel" in step && o(step.__parallel);
+}
+function isDeploymentView(view) {
+  return view.__ === "deployment";
+}
+function isDynamicView(view) {
+  return view.__ === "dynamic";
+}
+function isElementView(view) {
+  return n(view.__) || view.__ === "element";
+}
+function isExtendsElementView(view) {
+  return isElementView(view) && "extends" in view;
+}
+function isScopedElementView(view) {
+  return isElementView(view) && "viewOf" in view;
+}
+function stepEdgeId(step, parallelStep) {
+  const id = `step-${String(step).padStart(2, "0")}`;
+  return parallelStep ? `${id}.${parallelStep}` : id;
+}
+function isStepEdgeId(id) {
+  return id.startsWith("step-");
+}
+function extractStep(id) {
+  if (!isStepEdgeId(id)) {
+    throw new Error(`Invalid step edge id: ${id}`);
+  }
+  return parseFloat(id.slice("step-".length));
+}
+function getParallelStepsPrefix(id) {
+  if (isStepEdgeId(id) && id.includes(".")) {
+    return id.slice(0, id.indexOf(".") + 1);
+  }
+  return null;
+}
+exports.ComputedNode = void 0;
+((ComputedNode2) => {
+  function modelRef(node) {
+    return node.modelRef === 1 ? node.id : node.modelRef ?? null;
+  }
+  ComputedNode2.modelRef = modelRef;
+  function deploymentRef(node) {
+    return node.deploymentRef === 1 ? node.id : node.deploymentRef ?? null;
+  }
+  ComputedNode2.deploymentRef = deploymentRef;
+  function isNodesGroup(node) {
+    return node.kind === exports.ElementKind.Group;
+  }
+  ComputedNode2.isNodesGroup = isNodesGroup;
+})(exports.ComputedNode || (exports.ComputedNode = {}));
+exports.ComputedView = void 0;
+((ComputedView2) => {
+  function isDeployment(view) {
+    return view.__ === "deployment";
+  }
+  ComputedView2.isDeployment = isDeployment;
+  function isDynamic(view) {
+    return view.__ === "dynamic";
+  }
+  ComputedView2.isDynamic = isDynamic;
+  function isElement(view) {
+    return n(view.__) || view.__ === "element";
+  }
+  ComputedView2.isElement = isElement;
+})(exports.ComputedView || (exports.ComputedView = {}));
+function getBBoxCenter({
+  x,
+  y,
+  width,
+  height
+}) {
+  return {
+    x: x + width / 2,
+    y: y + height / 2
+  };
+}
+exports.DiagramNode = void 0;
+((DiagramNode2) => {
+  function modelRef(node) {
+    return node.modelRef === 1 ? node.id : node.modelRef ?? null;
+  }
+  DiagramNode2.modelRef = modelRef;
+  function deploymentRef(node) {
+    return node.deploymentRef === 1 ? node.id : node.deploymentRef ?? null;
+  }
+  DiagramNode2.deploymentRef = deploymentRef;
+  function isNodesGroup(node) {
+    return node.kind === exports.ElementKind.Group;
+  }
+  DiagramNode2.isNodesGroup = isNodesGroup;
+})(exports.DiagramNode || (exports.DiagramNode = {}));
+
+exports.AsFqn = AsFqn;
+exports.BorderStyles = BorderStyles;
+exports.DefaultArrowType = DefaultArrowType;
+exports.DefaultElementShape = DefaultElementShape;
+exports.DefaultLineStyle = DefaultLineStyle;
+exports.DefaultRelationshipColor = DefaultRelationshipColor;
+exports.DefaultThemeColor = DefaultThemeColor;
+exports.ElementShapes = ElementShapes;
+exports.expression = expression;
+exports.extractStep = extractStep;
+exports.getBBoxCenter = getBBoxCenter;
+exports.getParallelStepsPrefix = getParallelStepsPrefix;
+exports.isAndOperator = isAndOperator;
+exports.isAutoLayoutDirection = isAutoLayoutDirection;
+exports.isCustomElement = isCustomElement;
+exports.isCustomRelationExpr = isCustomRelationExpr;
+exports.isDeploymentView = isDeploymentView;
+exports.isDynamicView = isDynamicView;
+exports.isDynamicViewParallelSteps = isDynamicViewParallelSteps;
+exports.isElement = isElement;
+exports.isElementKindExpr = isElementKindExpr;
+exports.isElementPredicateExpr = isElementPredicateExpr;
+exports.isElementRef = isElementRef;
+exports.isElementTagExpr = isElementTagExpr;
+exports.isElementView = isElementView;
+exports.isElementWhere = isElementWhere;
+exports.isExpandedElementExpr = isExpandedElementExpr;
+exports.isExtendsElementView = isExtendsElementView;
+exports.isInOut = isInOut;
+exports.isIncoming = isIncoming;
+exports.isKindEqual = isKindEqual;
+exports.isNotOperator = isNotOperator;
+exports.isOrOperator = isOrOperator;
+exports.isOutgoing = isOutgoing;
+exports.isRelation = isRelation;
+exports.isRelationExpression = isRelationExpression;
+exports.isRelationPredicateExpr = isRelationPredicateExpr;
+exports.isRelationWhere = isRelationWhere;
+exports.isScopedElementView = isScopedElementView;
+exports.isStepEdgeId = isStepEdgeId;
+exports.isTagEqual = isTagEqual;
+exports.isViewRuleAutoLayout = isViewRuleAutoLayout;
+exports.isViewRuleGlobalPredicateRef = isViewRuleGlobalPredicateRef;
+exports.isViewRuleGlobalStyle = isViewRuleGlobalStyle;
+exports.isViewRuleGroup = isViewRuleGroup;
+exports.isViewRulePredicate = isViewRulePredicate;
+exports.isViewRuleStyle = isViewRuleStyle;
+exports.isWildcard = isWildcard;
+exports.n = n;
+exports.o = o;
+exports.o$1 = o$1;
+exports.stepEdgeId = stepEdgeId;
+exports.whereOperatorAsPredicate = whereOperatorAsPredicate;
+exports.y = y;