@likec4/core 1.30.0 → 1.32.0

package/dist/shared/core.Bk7wEZFG.mjs

@@ -0,0 +1,276 @@
+import { F as FqnRef, c as n, d as isStepEdgeId } from './core.CUYDgv2-.mjs';
+
+function o(r){return Array.isArray(r)}
+
+var FqnExpr;
+((FqnExpr2) => {
+  function isWildcard(expr) {
+    return "wildcard" in expr && expr.wildcard === true;
+  }
+  FqnExpr2.isWildcard = isWildcard;
+  function isModelRef(ref) {
+    return "ref" in ref && FqnRef.isModelRef(ref.ref);
+  }
+  FqnExpr2.isModelRef = isModelRef;
+  function isDeploymentRef(expr) {
+    return "ref" in expr && FqnRef.isDeploymentRef(expr.ref);
+  }
+  FqnExpr2.isDeploymentRef = isDeploymentRef;
+  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;
+  function isWhere(expr) {
+    return "where" in expr && is(expr.where.expr);
+  }
+  FqnExpr2.isWhere = isWhere;
+  function isCustom(expr) {
+    return "custom" in expr && (is(expr.custom.expr) || isWhere(expr.custom.expr));
+  }
+  FqnExpr2.isCustom = isCustom;
+  function is(expr) {
+    return isWildcard(expr) || isModelRef(expr) || isDeploymentRef(expr) || isElementKindExpr(expr) || isElementTagExpr(expr);
+  }
+  FqnExpr2.is = is;
+  function unwrap(expr) {
+    if (isCustom(expr)) {
+      expr = expr.custom.expr;
+    }
+    if (isWhere(expr)) {
+      expr = expr.where.expr;
+    }
+    return expr;
+  }
+  FqnExpr2.unwrap = unwrap;
+})(FqnExpr || (FqnExpr = {}));
+var RelationExpr;
+((RelationExpr2) => {
+  function isDirect(expr) {
+    return "source" in expr && "target" in expr;
+  }
+  RelationExpr2.isDirect = isDirect;
+  function isIncoming(expr) {
+    return "incoming" in expr;
+  }
+  RelationExpr2.isIncoming = isIncoming;
+  function isOutgoing(expr) {
+    return "outgoing" in expr;
+  }
+  RelationExpr2.isOutgoing = isOutgoing;
+  function isInOut(expr) {
+    return "inout" in expr;
+  }
+  RelationExpr2.isInOut = isInOut;
+  function isWhere(expr) {
+    return "where" in expr && (isDirect(expr.where.expr) || isIncoming(expr.where.expr) || isOutgoing(expr.where.expr) || isInOut(expr.where.expr));
+  }
+  RelationExpr2.isWhere = isWhere;
+  function isCustom(expr) {
+    return "customRelation" in expr;
+  }
+  RelationExpr2.isCustom = isCustom;
+  function is(expr) {
+    return isDirect(expr) || isIncoming(expr) || isOutgoing(expr) || isInOut(expr);
+  }
+  RelationExpr2.is = is;
+  function unwrap(expr) {
+    if (isCustom(expr)) {
+      expr = expr.customRelation.expr;
+    }
+    if (isWhere(expr)) {
+      expr = expr.where.expr;
+    }
+    return expr;
+  }
+  RelationExpr2.unwrap = unwrap;
+})(RelationExpr || (RelationExpr = {}));
+var Expression;
+((Expression2) => {
+  function isWhere(expr) {
+    return "where" in expr;
+  }
+  Expression2.isWhere = isWhere;
+  function isRelationWhere(expr) {
+    return RelationExpr.isWhere(expr);
+  }
+  Expression2.isRelationWhere = isRelationWhere;
+  function isFqnExprWhere(expr) {
+    return FqnExpr.isWhere(expr);
+  }
+  Expression2.isFqnExprWhere = isFqnExprWhere;
+  function isFqnExpr(expr) {
+    return FqnExpr.is(expr) || FqnExpr.isWhere(expr) || FqnExpr.isCustom(expr);
+  }
+  Expression2.isFqnExpr = isFqnExpr;
+  function isRelation(expr) {
+    return RelationExpr.is(expr) || RelationExpr.isWhere(expr) || RelationExpr.isCustom(expr);
+  }
+  Expression2.isRelation = isRelation;
+})(Expression || (Expression = {}));
+
+var ModelFqnExpr;
+((ModelFqnExpr2) => {
+  function isWildcard(expr) {
+    return "wildcard" in expr && expr.wildcard === true;
+  }
+  ModelFqnExpr2.isWildcard = isWildcard;
+  function isModelRef(ref) {
+    return "ref" in ref && FqnRef.isModelRef(ref.ref);
+  }
+  ModelFqnExpr2.isModelRef = isModelRef;
+  function isElementKindExpr(expr) {
+    return "elementKind" in expr && "isEqual" in expr;
+  }
+  ModelFqnExpr2.isElementKindExpr = isElementKindExpr;
+  function isElementTagExpr(expr) {
+    return "elementTag" in expr && "isEqual" in expr;
+  }
+  ModelFqnExpr2.isElementTagExpr = isElementTagExpr;
+  function isWhere(expr) {
+    return "where" in expr && is(expr.where.expr);
+  }
+  ModelFqnExpr2.isWhere = isWhere;
+  function isCustom(expr) {
+    return "custom" in expr && (is(expr.custom.expr) || isWhere(expr.custom.expr));
+  }
+  ModelFqnExpr2.isCustom = isCustom;
+  function is(expr) {
+    return isWildcard(expr) || isModelRef(expr) || isElementKindExpr(expr) || isElementTagExpr(expr);
+  }
+  ModelFqnExpr2.is = is;
+  function unwrap(expr) {
+    if (isCustom(expr)) {
+      expr = expr.custom.expr;
+    }
+    if (isWhere(expr)) {
+      expr = expr.where.expr;
+    }
+    return expr;
+  }
+  ModelFqnExpr2.unwrap = unwrap;
+})(ModelFqnExpr || (ModelFqnExpr = {}));
+var ModelRelationExpr;
+((ModelRelationExpr2) => {
+  function isDirect(expr) {
+    return "source" in expr && "target" in expr;
+  }
+  ModelRelationExpr2.isDirect = isDirect;
+  function isIncoming(expr) {
+    return "incoming" in expr;
+  }
+  ModelRelationExpr2.isIncoming = isIncoming;
+  function isOutgoing(expr) {
+    return "outgoing" in expr;
+  }
+  ModelRelationExpr2.isOutgoing = isOutgoing;
+  function isInOut(expr) {
+    return "inout" in expr;
+  }
+  ModelRelationExpr2.isInOut = isInOut;
+  function isWhere(expr) {
+    return "where" in expr && (isDirect(expr.where.expr) || isIncoming(expr.where.expr) || isOutgoing(expr.where.expr) || isInOut(expr.where.expr));
+  }
+  ModelRelationExpr2.isWhere = isWhere;
+  function isCustom(expr) {
+    return "customRelation" in expr;
+  }
+  ModelRelationExpr2.isCustom = isCustom;
+  function is(expr) {
+    return isDirect(expr) || isIncoming(expr) || isOutgoing(expr) || isInOut(expr);
+  }
+  ModelRelationExpr2.is = is;
+  function unwrap(expr) {
+    if (isCustom(expr)) {
+      expr = expr.customRelation.expr;
+    }
+    if (isWhere(expr)) {
+      expr = expr.where.expr;
+    }
+    return expr;
+  }
+  ModelRelationExpr2.unwrap = unwrap;
+})(ModelRelationExpr || (ModelRelationExpr = {}));
+var ModelExpression;
+((ModelExpression2) => {
+  function isWhere(expr) {
+    return "where" in expr;
+  }
+  ModelExpression2.isWhere = isWhere;
+  function isRelationWhere(expr) {
+    return ModelRelationExpr.isWhere(expr);
+  }
+  ModelExpression2.isRelationWhere = isRelationWhere;
+  function isFqnExprWhere(expr) {
+    return ModelFqnExpr.isWhere(expr);
+  }
+  ModelExpression2.isFqnExprWhere = isFqnExprWhere;
+  function isFqnExpr(expr) {
+    return ModelFqnExpr.is(expr) || ModelFqnExpr.isWhere(expr) || ModelFqnExpr.isCustom(expr);
+  }
+  ModelExpression2.isFqnExpr = isFqnExpr;
+  function isRelationExpr(expr) {
+    return ModelRelationExpr.is(expr) || ModelRelationExpr.isWhere(expr) || ModelRelationExpr.isCustom(expr);
+  }
+  ModelExpression2.isRelationExpr = isRelationExpr;
+})(ModelExpression || (ModelExpression = {}));
+
+function isViewRulePredicate(rule) {
+  return "include" in rule || "exclude" in rule;
+}
+function isViewRuleStyle(rule) {
+  return "targets" in rule && "style" in rule;
+}
+function isComputedView(view) {
+  return view._stage === "computed";
+}
+function isDiagramView(view) {
+  return view._stage === "layouted";
+}
+function isElementView(view) {
+  return view._type === "element";
+}
+function isScopedElementView(view) {
+  return isElementView(view) && n(view.viewOf);
+}
+function isExtendsElementView(view) {
+  return isElementView(view) && n(view.extends);
+}
+function isDeploymentView(view) {
+  return view._type === "deployment";
+}
+function isDynamicView(view) {
+  return view._type === "dynamic";
+}
+
+function isViewRuleGlobalStyle(rule) {
+  return "styleId" in rule;
+}
+function isViewRuleGlobalPredicateRef(rule) {
+  return "predicateId" in rule;
+}
+function isAutoLayoutDirection(autoLayout) {
+  return autoLayout === "TB" || autoLayout === "BT" || autoLayout === "LR" || autoLayout === "RL";
+}
+function isViewRuleAutoLayout(rule) {
+  return "direction" in rule;
+}
+
+function getParallelStepsPrefix(id) {
+  if (isStepEdgeId(id) && id.includes(".")) {
+    return id.slice(0, id.indexOf(".") + 1);
+  }
+  return null;
+}
+function isDynamicViewParallelSteps(step) {
+  return "__parallel" in step && o(step.__parallel);
+}
+
+function isViewRuleGroup(rule) {
+  return "title" in rule && "groupRules" in rule && Array.isArray(rule.groupRules);
+}
+
+export { Expression as E, FqnExpr as F, ModelFqnExpr as M, RelationExpr as R, isElementView as a, isViewRuleStyle as b, isViewRulePredicate as c, isViewRuleAutoLayout as d, isViewRuleGroup as e, isViewRuleGlobalPredicateRef as f, isViewRuleGlobalStyle as g, isDynamicViewParallelSteps as h, isExtendsElementView as i, ModelRelationExpr as j, ModelExpression as k, isDynamicView as l, isDeploymentView as m, isComputedView as n, o, isDiagramView as p, isScopedElementView as q, isAutoLayoutDirection as r, getParallelStepsPrefix as s };

package/dist/shared/core.BrCnZFTn.mjs

@@ -0,0 +1,32 @@
+import { t } from './core.rmvsy0n3.mjs';
+import { i as invariant } from './core.Cy9smucx.mjs';
+
+function imap(arg1, arg2) {
+  const mapper = arg2 ?? arg1;
+  invariant(t(mapper));
+  function* _map(iter) {
+    for (const value of iter) {
+      yield mapper(value);
+    }
+    return;
+  }
+  if (!arg2) {
+    return _map;
+  }
+  return _map(arg1);
+}
+
+function toArray(iterable) {
+  if (iterable) {
+    return Array.from(iterable);
+  }
+  return (it) => Array.from(it);
+}
+function toSet(iterable) {
+  if (iterable) {
+    return new Set(iterable);
+  }
+  return (it) => new Set(it);
+}
+
+export { toArray as a, imap as i, toSet as t };

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

@@ -0,0 +1,146 @@
+import { IsAny, UnionToIntersection, Simplify, Tagged } from 'type-fest';
+
+type NonEmptyArray<T> = [T, ...T[]];
+type NonEmptyReadonlyArray<T> = readonly [T, ...T[]];
+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
+ * ```ts
+ *   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, All = AllNever<Expressions>> = Expressions extends object ? {
+    [Name in keyof Expressions]: Simplify<Omit<All, keyof Expressions[Name]> & Expressions[Name]>;
+}[keyof Expressions] : never;
+/**
+ * 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;
+interface Link {
+    title?: string;
+    url: string;
+    relative?: string;
+}
+/**
+ * Coalesce `V` to a string if it is `any`
+ */
+type Coalesce<V extends string, OrIfAny = string> = IsAny<V> extends true ? OrIfAny : V;
+
+type ProjectId<T = string> = Tagged<T, 'ProjectID'>;
+type BuiltInIcon = 'none' | `${'aws' | 'azure' | 'gcp' | 'tech'}:${string}`;
+type Icon = Tagged<string, 'Icon'> | BuiltInIcon;
+type IconUrl = Icon;
+/**
+ * Full-qualified-name for model elements
+ *
+ * @param This - Fqn of the element (specific element)
+ * @param All - The type of all known FQNs
+ *
+ * @example
+ * ```ts
+ * type ElementAFqn = Fqn<'a', 'a' | ' | 'b'>
+ *
+ * ```
+ */
+type Fqn<Id = string> = Tagged<Id, 'Fqn'>;
+declare function Fqn(name: string, parent?: Fqn | null): Fqn;
+type ElementKind<Kinds = string> = Tagged<Kinds, 'ElementKind'>;
+declare const GroupElementKind: ElementKind<"@group">;
+type GroupElementKind = typeof GroupElementKind;
+declare function isGroupElementKind<V extends {
+    kind?: any;
+}>(v: V): v is V & {
+    kind: GroupElementKind;
+};
+/**
+ * Full-qualified-name for deployment elements
+ */
+type DeploymentFqn<T = string> = Tagged<T, 'DeploymentFqn'>;
+declare function DeploymentFqn(name: string, parent?: DeploymentFqn | null): DeploymentFqn;
+type DeploymentKind<Kinds = string> = Tagged<Kinds, 'DeploymentKind'>;
+type ViewId<Id = string> = Tagged<Id, 'ViewId'>;
+declare function ViewId(id: string): ViewId;
+type AnyFqn<T = string> = DeploymentFqn<T> | Fqn<T>;
+/**
+ * @deprecated Use {@link RelationshipKind} instead
+ */
+type RelationKind<Kinds = string> = RelationshipKind<Kinds>;
+type RelationshipKind<Kinds = string> = Tagged<Kinds, 'RelationshipKind'>;
+type RelationId<Id = string> = Tagged<Id, 'RelationId'>;
+declare function RelationId(id: string): RelationId;
+type Tag<T = string> = Tagged<T, 'Tag'>;
+type GlobalFqn<Id = string> = Tagged<Fqn<Id>, 'GlobalFqn'>;
+declare function GlobalFqn<A>(projectId: A | ProjectId<A>, name: string): GlobalFqn<A>;
+declare function isGlobalFqn<A extends string>(fqn: A): fqn is GlobalFqn<A>;
+declare function splitGlobalFqn<I extends string>(fqn: Fqn<I> | GlobalFqn<I>): [ProjectId | null, Fqn<I>];
+type NodeId = Tagged<string, 'NodeId' | 'Fqn' | 'DeploymentFqn'>;
+declare function NodeId(id: string): NodeId;
+type EdgeId = Tagged<string, 'EdgeId'>;
+declare function EdgeId(id: string): EdgeId;
+type StepEdgeIdLiteral = `step-${number}` | `step-${number}.${number}`;
+type StepEdgeId = Tagged<StepEdgeIdLiteral, 'EdgeId'>;
+declare function stepEdgeId(step: number, parallelStep?: number): StepEdgeId;
+declare const StepEdgeKind = "@step";
+declare function isStepEdgeId(id: string): id is StepEdgeId;
+declare function extractStep(id: EdgeId): number;
+
+type scalar_AnyFqn<T = string> = AnyFqn<T>;
+type scalar_BuiltInIcon = BuiltInIcon;
+declare const scalar_DeploymentFqn: typeof DeploymentFqn;
+type scalar_DeploymentKind<Kinds = string> = DeploymentKind<Kinds>;
+declare const scalar_EdgeId: typeof EdgeId;
+type scalar_ElementKind<Kinds = string> = ElementKind<Kinds>;
+declare const scalar_Fqn: typeof Fqn;
+declare const scalar_GlobalFqn: typeof GlobalFqn;
+type scalar_GroupElementKind = GroupElementKind;
+type scalar_Icon = Icon;
+type scalar_IconUrl = IconUrl;
+declare const scalar_NodeId: typeof NodeId;
+type scalar_ProjectId<T = string> = ProjectId<T>;
+declare const scalar_RelationId: typeof RelationId;
+type scalar_RelationKind<Kinds = string> = RelationKind<Kinds>;
+type scalar_RelationshipKind<Kinds = string> = RelationshipKind<Kinds>;
+type scalar_StepEdgeId = StepEdgeId;
+type scalar_StepEdgeIdLiteral = StepEdgeIdLiteral;
+declare const scalar_StepEdgeKind: typeof StepEdgeKind;
+type scalar_Tag<T = string> = Tag<T>;
+declare const scalar_ViewId: typeof ViewId;
+declare const scalar_extractStep: typeof extractStep;
+declare const scalar_isGlobalFqn: typeof isGlobalFqn;
+declare const scalar_isGroupElementKind: typeof isGroupElementKind;
+declare const scalar_isStepEdgeId: typeof isStepEdgeId;
+declare const scalar_splitGlobalFqn: typeof splitGlobalFqn;
+declare const scalar_stepEdgeId: typeof stepEdgeId;
+declare namespace scalar {
+  export { type scalar_AnyFqn as AnyFqn, type scalar_BuiltInIcon as BuiltInIcon, scalar_DeploymentFqn as DeploymentFqn, type scalar_DeploymentKind as DeploymentKind, scalar_EdgeId as EdgeId, type scalar_ElementKind as ElementKind, scalar_Fqn as Fqn, scalar_GlobalFqn as GlobalFqn, type scalar_GroupElementKind as GroupElementKind, type scalar_Icon as Icon, type scalar_IconUrl as IconUrl, scalar_NodeId as NodeId, type scalar_ProjectId as ProjectId, scalar_RelationId as RelationId, type scalar_RelationKind as RelationKind, type scalar_RelationshipKind as RelationshipKind, type scalar_StepEdgeId as StepEdgeId, type scalar_StepEdgeIdLiteral as StepEdgeIdLiteral, scalar_StepEdgeKind as StepEdgeKind, type scalar_Tag as Tag, scalar_ViewId as ViewId, scalar_extractStep as extractStep, scalar_isGlobalFqn as isGlobalFqn, scalar_isGroupElementKind as isGroupElementKind, scalar_isStepEdgeId as isStepEdgeId, scalar_splitGlobalFqn as splitGlobalFqn, scalar_stepEdgeId as stepEdgeId };
+}
+
+export { type AnyFqn as A, type BuiltInIcon as B, type Coalesce as C, DeploymentFqn as D, EdgeId as E, Fqn as F, GroupElementKind as G, type IteratorLike as I, type KeysOf as K, type Link as L, NodeId as N, type ProjectId as P, RelationId as R, type StepEdgeIdLiteral as S, type Tag as T, ViewId as V, type ElementKind as a, type DeploymentKind as b, type RelationshipKind as c, type NonEmptyArray as d, type NonEmptyReadonlyArray as e, type ExclusiveUnion as f, type NTuple as g, type Predicate as h, type Icon as i, type IconUrl as j, isGroupElementKind as k, type RelationKind as l, GlobalFqn as m, isGlobalFqn as n, splitGlobalFqn as o, type StepEdgeId as p, stepEdgeId as q, StepEdgeKind as r, scalar as s, isStepEdgeId as t, extractStep as u };