@likec4/core 1.27.3 → 1.28.1

package/dist/shared/{core.BMep80lJ.mjs → core.DgfwjBtu.mjs}

@@ -1,6 +1,8 @@
 import { i as invariant, a as nonexhaustive } from './core.C-YXI-43.mjs';
 import { u } from './core.DbRvwARP.mjs';
 
+function n$1(e){return !!e}
+
 function o$1(a){return t=>!a(t)}
 
 function n(e){return e==null}
@@ -11,19 +13,6 @@ 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));
 
-var DeploymentElement;
-((DeploymentElement2) => {
-  DeploymentElement2.isDeploymentNode = (el) => {
-    return "kind" in el && !("element" in el);
-  };
-  DeploymentElement2.isInstance = (el) => {
-    return "element" in el && !("kind" in el);
-  };
-})(DeploymentElement || (DeploymentElement = {}));
-
-function AsFqn(name, parent) {
-  return parent ? parent + "." + name : name;
-}
 const BorderStyles = ["solid", "dashed", "dotted", "none"];
 var ElementKind;
 ((ElementKind2) => {
@@ -44,78 +33,38 @@ const DefaultShapeSize = "md";
 const DefaultPaddingSize = "md";
 const DefaultTextSize = "md";
 
-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 AsFqn(name, parent) {
+  return parent ? parent + "." + name : name;
 }
-function isRelationWhere(expr) {
-  return "where" in expr && isRelationExpression(expr.where.expr);
+function GlobalFqn(projectId, name) {
+  invariant(n$1(projectId), "Project ID must start with @");
+  return "@" + projectId + "." + name;
 }
-function isCustomRelationExpr(expr) {
-  return "customRelation" in expr;
+function isGlobalFqn(fqn) {
+  return fqn.startsWith("@");
 }
-function isRelationPredicateExpr(expr) {
-  return isRelationExpression(expr) || isRelationWhere(expr) || isCustomRelationExpr(expr);
+function splitGlobalFqn(fqn) {
+  if (!fqn.startsWith("@")) {
+    return [null, fqn];
+  }
+  const firstDot = fqn.indexOf(".");
+  if (firstDot < 2) {
+    throw new Error("Invalid global FQN");
+  }
+  const projectId = fqn.slice(1, firstDot);
+  const name = fqn.slice(firstDot + 1);
+  return [projectId, name];
 }
 
-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
-};
+var DeploymentElement;
+((DeploymentElement2) => {
+  DeploymentElement2.isDeploymentNode = (el) => {
+    return "kind" in el && !("element" in el);
+  };
+  DeploymentElement2.isInstance = (el) => {
+    return "element" in el && !("kind" in el);
+  };
+})(DeploymentElement || (DeploymentElement = {}));
 
 var FqnRef;
 ((FqnRef2) => {
@@ -126,10 +75,13 @@ var FqnRef;
     return "deployment" in ref && !("element" in ref);
   };
   FqnRef2.isDeploymentRef = (ref) => {
-    return !(0, FqnRef2.isModelRef)(ref);
+    return !(0, FqnRef2.isModelRef)(ref) && !(0, FqnRef2.isImportRef)(ref);
   };
   FqnRef2.isModelRef = (ref) => {
-    return "model" in ref;
+    return "model" in ref && !("project" in ref);
+  };
+  FqnRef2.isImportRef = (ref) => {
+    return "project" in ref && "model" in ref;
   };
   FqnRef2.toDeploymentRef = (ref) => {
     invariant((0, FqnRef2.isDeploymentRef)(ref), "Expected DeploymentRef");
@@ -140,6 +92,15 @@ var FqnRef;
       id: ref.deployment
     };
   };
+  FqnRef2.toModelFqn = (ref) => {
+    if ((0, FqnRef2.isImportRef)(ref)) {
+      return GlobalFqn(ref.project, ref.model);
+    }
+    if ((0, FqnRef2.isModelRef)(ref)) {
+      return ref.model;
+    }
+    throw new Error("Expected FqnRef.ModelRef or FqnRef.ImportRef");
+  };
 })(FqnRef || (FqnRef = {}));
 var FqnExpr;
 ((FqnExpr2) => {
@@ -147,11 +108,37 @@ var FqnExpr;
     return "wildcard" in expr && expr.wildcard === true;
   };
   FqnExpr2.isModelRef = (ref) => {
-    return "ref" in ref && FqnRef.isModelRef(ref.ref);
+    return "ref" in ref && (FqnRef.isModelRef(ref.ref) || FqnRef.isImportRef(ref.ref));
   };
   FqnExpr2.isDeploymentRef = (ref) => {
     return "ref" in ref && FqnRef.isDeploymentRef(ref.ref);
   };
+  function isElementKindExpr(expr) {
+    return "elementKind" in expr && "isEqual" in expr;
+  }
+  FqnExpr2.isElementKindExpr = isElementKindExpr;
+  function isElementTagExpr(expr) {
+    return "elementTag" in expr && "isEqual" in expr;
+  }
+  FqnExpr2.isElementTagExpr = isElementTagExpr;
+  FqnExpr2.isWhere = (expr) => {
+    return "where" in expr && (0, FqnExpr2.is)(expr.where.expr);
+  };
+  FqnExpr2.isCustom = (expr) => {
+    return "custom" in expr && ((0, FqnExpr2.is)(expr.custom.expr) || (0, FqnExpr2.isWhere)(expr.custom.expr));
+  };
+  FqnExpr2.is = (expr) => {
+    return (0, FqnExpr2.isWildcard)(expr) || (0, FqnExpr2.isModelRef)(expr) || (0, FqnExpr2.isDeploymentRef)(expr) || isElementKindExpr(expr) || isElementTagExpr(expr);
+  };
+  FqnExpr2.unwrap = (expr) => {
+    if ((0, FqnExpr2.isCustom)(expr)) {
+      expr = expr.custom.expr;
+    }
+    if ((0, FqnExpr2.isWhere)(expr)) {
+      expr = expr.where.expr;
+    }
+    return expr;
+  };
 })(FqnExpr || (FqnExpr = {}));
 var RelationExpr;
 ((RelationExpr2) => {
@@ -168,19 +155,143 @@ var RelationExpr;
     return "inout" in expr;
   };
   RelationExpr2.isWhere = (expr) => {
-    return "where" in expr;
+    return "where" in expr && ((0, RelationExpr2.isDirect)(expr.where.expr) || (0, RelationExpr2.isIncoming)(expr.where.expr) || (0, RelationExpr2.isOutgoing)(expr.where.expr) || (0, RelationExpr2.isInOut)(expr.where.expr));
+  };
+  RelationExpr2.isCustom = (expr) => {
+    return "customRelation" in expr;
+  };
+  RelationExpr2.is = (expr) => {
+    return (0, RelationExpr2.isDirect)(expr) || (0, RelationExpr2.isIncoming)(expr) || (0, RelationExpr2.isOutgoing)(expr) || (0, RelationExpr2.isInOut)(expr);
+  };
+  RelationExpr2.unwrap = (expr) => {
+    if ((0, RelationExpr2.isCustom)(expr)) {
+      expr = expr.customRelation.expr;
+    }
+    if ((0, RelationExpr2.isWhere)(expr)) {
+      expr = expr.where.expr;
+    }
+    return expr;
   };
 })(RelationExpr || (RelationExpr = {}));
 var ExpressionV2;
 ((ExpressionV22) => {
+  ExpressionV22.isWhere = (expr) => {
+    return "where" in expr;
+  };
+  ExpressionV22.isRelationWhere = (expr) => {
+    return RelationExpr.isWhere(expr);
+  };
+  ExpressionV22.isFqnExprWhere = (expr) => {
+    return FqnExpr.isWhere(expr);
+  };
   ExpressionV22.isFqnExpr = (expr) => {
-    return FqnExpr.isWildcard(expr) || FqnExpr.isModelRef(expr) || FqnExpr.isDeploymentRef(expr);
+    return FqnExpr.is(expr) || FqnExpr.isWhere(expr) || FqnExpr.isCustom(expr);
   };
   ExpressionV22.isRelation = (expr) => {
-    return RelationExpr.isDirect(expr) || RelationExpr.isIncoming(expr) || RelationExpr.isOutgoing(expr) || RelationExpr.isInOut(expr);
+    return RelationExpr.is(expr) || RelationExpr.isWhere(expr) || RelationExpr.isCustom(expr);
   };
 })(ExpressionV2 || (ExpressionV2 = {}));
 
+var ModelLayer;
+((ModelLayer2) => {
+  ((FqnRef2) => {
+    FqnRef2.isModelRef = (ref) => {
+      return "model" in ref && !("project" in ref);
+    };
+    FqnRef2.isImportRef = (ref) => {
+      return "project" in ref && "model" in ref;
+    };
+    FqnRef2.toFqn = (ref) => {
+      if ((0, FqnRef2.isImportRef)(ref)) {
+        return GlobalFqn(ref.project, ref.model);
+      }
+      if ((0, FqnRef2.isModelRef)(ref)) {
+        return ref.model;
+      }
+      throw new Error("Expected FqnRef.ModelRef or FqnRef.ImportRef");
+    };
+  })(ModelLayer2.FqnRef || (ModelLayer2.FqnRef = {}));
+  let FqnExpr;
+  ((FqnExpr2) => {
+    FqnExpr2.isWildcard = (expr) => {
+      return "wildcard" in expr && expr.wildcard === true;
+    };
+    FqnExpr2.isModelRef = (ref) => {
+      return "ref" in ref;
+    };
+    function isElementKindExpr(expr) {
+      return "elementKind" in expr && "isEqual" in expr;
+    }
+    FqnExpr2.isElementKindExpr = isElementKindExpr;
+    function isElementTagExpr(expr) {
+      return "elementTag" in expr && "isEqual" in expr;
+    }
+    FqnExpr2.isElementTagExpr = isElementTagExpr;
+    FqnExpr2.isWhere = (expr) => {
+      return "where" in expr && (0, FqnExpr2.is)(expr.where.expr);
+    };
+    FqnExpr2.isCustom = (expr) => {
+      return "custom" in expr && ((0, FqnExpr2.is)(expr.custom.expr) || (0, FqnExpr2.isWhere)(expr.custom.expr));
+    };
+    FqnExpr2.is = (expr) => {
+      return (0, FqnExpr2.isWildcard)(expr) || (0, FqnExpr2.isModelRef)(expr) || isElementKindExpr(expr) || isElementTagExpr(expr);
+    };
+  })(FqnExpr = ModelLayer2.FqnExpr || (ModelLayer2.FqnExpr = {}));
+  function isAnyFqnExpr(expr) {
+    return FqnExpr.is(expr) || FqnExpr.isWhere(expr) || FqnExpr.isCustom(expr);
+  }
+  ModelLayer2.isAnyFqnExpr = isAnyFqnExpr;
+  let RelationExpr;
+  ((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 && (0, RelationExpr2.is)(expr.where.expr);
+    };
+    RelationExpr2.isCustom = (expr) => {
+      return "customRelation" in expr;
+    };
+    RelationExpr2.is = (expr) => {
+      return (0, RelationExpr2.isDirect)(expr) || (0, RelationExpr2.isIncoming)(expr) || (0, RelationExpr2.isOutgoing)(expr) || (0, RelationExpr2.isInOut)(expr);
+    };
+  })(RelationExpr = ModelLayer2.RelationExpr || (ModelLayer2.RelationExpr = {}));
+  function isAnyRelationExpr(expr) {
+    return RelationExpr.is(expr) || RelationExpr.isWhere(expr) || RelationExpr.isCustom(expr);
+  }
+  ModelLayer2.isAnyRelationExpr = isAnyRelationExpr;
+  function isExpression(expr) {
+    return isAnyFqnExpr(expr) || isAnyRelationExpr(expr);
+  }
+  ModelLayer2.isExpression = isExpression;
+  ((Expression2) => {
+    Expression2.isWhere = (expr) => {
+      return "where" in expr;
+    };
+    Expression2.isCustomFqnExpr = (expr) => {
+      return FqnExpr.isCustom(expr);
+    };
+    Expression2.isCustomRelationExpr = (expr) => {
+      return RelationExpr.isCustom(expr);
+    };
+    Expression2.isFqnExpr = (expr) => {
+      return FqnExpr.is(expr);
+    };
+    Expression2.isRelation = (expr) => {
+      return RelationExpr.is(expr);
+    };
+  })(ModelLayer2.Expression || (ModelLayer2.Expression = {}));
+})(ModelLayer || (ModelLayer = {}));
+
 const isTagEqual = (operator) => {
   return "tag" in operator;
 };
@@ -381,4 +492,4 @@ var DiagramNode;
   DiagramNode2.isNodesGroup = isNodesGroup;
 })(DiagramNode || (DiagramNode = {}));
 
-export { isAutoLayoutDirection as $, AsFqn as A, BorderStyles as B, isRelationPredicateExpr as C, DefaultElementShape as D, ElementKind as E, isRelationWhere as F, isWildcard as G, ExpressionV2 as H, FqnExpr as I, FqnRef as J, isAndOperator as K, isKindEqual as L, isNotOperator as M, isOrOperator as N, isParticipantOperator as O, isTagEqual as P, whereOperatorAsPredicate as Q, RelationExpr as R, DefaultArrowType as S, DefaultLineStyle as T, DefaultRelationshipColor as U, ComputedNode as V, ComputedView as W, DiagramNode as X, extractStep as Y, getBBoxCenter as Z, getParallelStepsPrefix as _, isElementView as a, isDeploymentView as a0, isDynamicView as a1, isDynamicViewParallelSteps as a2, isStepEdgeId as a3, isViewRuleAutoLayout as a4, isViewRuleGlobalPredicateRef as a5, isViewRuleGlobalStyle as a6, isViewRuleGroup as a7, isViewRulePredicate as a8, isViewRuleStyle as a9, stepEdgeId as aa, o$1 as ab, y as ac, isElementPredicateExpr as b, DefaultThemeColor as c, DeploymentElement as d, isScopedElementView as e, expression as f, DefaultPaddingSize as g, DefaultShapeSize as h, isExtendsElementView as i, DefaultTextSize as j, ElementShapes as k, isCustomElement as l, isCustomRelationExpr as m, n, o, isElement as p, isElementKindExpr as q, isElementRef as r, isElementTagExpr as s, isElementWhere as t, isExpandedElementExpr as u, isIncoming as v, isInOut as w, isOutgoing as x, isRelation as y, isRelationExpression as z };
+export { y as $, AsFqn as A, BorderStyles as B, ComputedNode as C, DefaultElementShape as D, ElementKind as E, FqnExpr as F, GlobalFqn as G, DiagramNode as H, extractStep as I, getBBoxCenter as J, getParallelStepsPrefix as K, isAutoLayoutDirection as L, ModelLayer as M, isDeploymentView as N, isDynamicView as O, isDynamicViewParallelSteps as P, isStepEdgeId as Q, RelationExpr as R, isViewRuleAutoLayout as S, isViewRuleGlobalPredicateRef as T, isViewRuleGlobalStyle as U, isViewRuleGroup as V, isViewRulePredicate as W, isViewRuleStyle as X, stepEdgeId as Y, n$1 as Z, o$1 as _, isElementView as a, DefaultThemeColor as b, DeploymentElement as c, isScopedElementView as d, isGlobalFqn as e, DefaultPaddingSize as f, DefaultShapeSize as g, DefaultTextSize as h, isExtendsElementView as i, ElementShapes as j, ExpressionV2 as k, FqnRef as l, isAndOperator as m, n, o, isKindEqual as p, isNotOperator as q, isOrOperator as r, splitGlobalFqn as s, isParticipantOperator as t, isTagEqual as u, DefaultArrowType as v, whereOperatorAsPredicate as w, DefaultLineStyle as x, DefaultRelationshipColor as y, ComputedView as z };

package/dist/shared/core.SjLhMA7a.d.mts

@@ -0,0 +1,62 @@
+import { Simplify, UnionToIntersection, Tagged } from 'type-fest';
+
+type NonEmptyArray<T> = [T, ...T[]];
+type NonEmptyReadonlyArray<T> = readonly [T, ...T[]];
+type CustomColor = string;
+type Point = readonly [x: number, y: number];
+interface XYPoint {
+    x: number;
+    y: number;
+}
+type KeysOf<T> = keyof T extends infer K extends string ? K : never;
+type AllNever<Expressions> = UnionToIntersection<{
+    [Name in keyof Expressions]: {
+        -readonly [Key in keyof Expressions[Name]]?: never;
+    };
+}[keyof Expressions]>;
+/**
+ * @example
+ *   type Variant1 = {
+ *     a: string
+ *   }
+ *   type Variant2 = {
+ *     b: number
+ *   }
+ *
+ *   type Variants = ExclusiveUnion<{
+ *     Variant1: Variant1,
+ *     Variant2: Variant2
+ *   }>
+ *
+ *   Fail here
+ *   const variant1: Variants = {
+ *      a: 'one',
+ *      b: 1
+ *   }
+ */
+type ExclusiveUnion<Expressions> = Expressions extends object ? {
+    [Name in keyof Expressions]: Simplify<Omit<AllNever<Expressions>, keyof Expressions[Name]> & Expressions[Name]>;
+}[keyof Expressions] : Expressions;
+/**
+ * Copy from https://github.com/remeda/remeda/blob/main/src/internal/types/NTuple.ts
+ * An array with *exactly* N elements in it.
+ *
+ * Only literal N values are supported. For very large N the type might result
+ * in a recurse depth error. For negative N the type would result in an infinite
+ * recursion. None of these have protections because this is an internal type!
+ */
+type NTuple<T, N extends number, Result extends Array<unknown> = []> = Result['length'] extends N ? Result : NTuple<T, N, [...Result, T]>;
+type IteratorLike<T> = IteratorObject<T, BuiltinIteratorReturn>;
+type Predicate<T> = (x: T) => boolean;
+
+type ProjectId = Tagged<string, 'ProjectID'>;
+type IconUrl = Tagged<string, 'IconUrl'> | 'none';
+type Fqn<Id extends string = string> = Tagged<Id, 'Fqn'>;
+type Tag<Tags extends string = string> = Tagged<Tags, 'Tag'>;
+declare function AsFqn(name: string, parent?: Fqn | null): Fqn;
+type GlobalFqn<Id extends string = string> = Tagged<Fqn<Id>, 'GlobalFqn'>;
+declare function GlobalFqn(projectId: ProjectId, name: string): GlobalFqn;
+declare function isGlobalFqn(fqn: string): fqn is GlobalFqn;
+declare function splitGlobalFqn<Id extends string>(fqn: Fqn<Id> | GlobalFqn<Id>): [ProjectId | null, Fqn<Id>];
+
+export { AsFqn as A, type CustomColor as C, type ExclusiveUnion as E, type Fqn as F, GlobalFqn as G, type IteratorLike as I, type KeysOf as K, type NonEmptyArray as N, type Point as P, type Tag as T, type XYPoint as X, type NonEmptyReadonlyArray as a, type NTuple as b, type Predicate as c, type IconUrl as d, type ProjectId as e, isGlobalFqn as i, splitGlobalFqn as s };