@likec4/core 1.31.0 → 1.32.1

package/dist/types/aux.d.mts

@@ -0,0 +1,3 @@
+import 'type-fest';
+import '../shared/core.BuO4ncfY.mjs';
+export { y as AllKinds, A as Any, A as AnyAux, C as AnySpec, b as Aux, q as DeploymentFqn, u as DeploymentId, D as DeploymentKind, h as EdgeId, g as ElementId, l as ElementKind, F as Fqn, p as LooseDeploymentId, a3 as LooseDeploymentKind, o as LooseElementId, a2 as LooseElementKind, a4 as LooseRelationKind, L as LooseTag, a1 as LooseTags, x as LooseViewId, j as Metadata, k as MetadataKey, N as Never, I as NodeId, a0 as OrString, G as PickByStage, P as ProjectId, m as RelationId, R as RelationKind, J as Spec, S as SpecAux, s as Stage, q as StrictDeploymentFqn, X as StrictDeploymentKind, Q as StrictElementKind, F as StrictFqn, K as StrictProjectId, Y as StrictRelationKind, O as StrictTag, n as StrictViewId, v as Tag, T as Tags, U as Unknown, c as UnknownComputed, d as UnknownLayouted, e as UnknownParsed, V as ViewId, $ as WithLinks, B as WithMetadata, z as WithOptionalLinks, W as WithOptionalTags, Z as WithTags, H as setStage, t as toComputed, r as toLayouted, w as toParsed } from '../shared/core.BaYE_r29.mjs';

package/dist/types/aux.mjs

@@ -0,0 +1 @@
+

package/dist/types/index.d.mts

@@ -1,48 +1,10 @@
-import { X as XYPoint, N as NonEmptyArray, P as Point, F as Fqn } from '../shared/core.SjLhMA7a.mjs';
-export { A as AsFqn, C as CustomColor, E as ExclusiveUnion, G as GlobalFqn, d as IconUrl, I as IteratorLike, K as KeysOf, b as NTuple, a as NonEmptyReadonlyArray, c as Predicate, e as ProjectId, T as Tag, i as isGlobalFqn, s as splitGlobalFqn } from '../shared/core.SjLhMA7a.mjs';
-import { bk as ViewId, aW as BBox, p as BorderStyle, t as ElementShape, ay as ThemeColor, bl as ViewManualLayout, aT as AutoLayoutDirection } from '../shared/core.DJvmfnEi.mjs';
-export { ag as AbstractRelation, a1 as AllNever, a2 as AndOperator, O as AnyParsedLikeC4ModelData, aU as BasicElementView, aV as BasicView, B as BorderStyles, ap as Color, aq as ColorLiteral, aX as ComputedDeploymentView, aY as ComputedDynamicView, aZ as ComputedEdge, a_ as ComputedElementView, C as ComputedLikeC4ModelData, az as ComputedNode, a as ComputedView, a$ as CustomColorDefinitions, ad as DefaultArrowType, j as DefaultElementShape, ae as DefaultLineStyle, k as DefaultPaddingSize, af as DefaultRelationshipColor, l as DefaultShapeSize, m as DefaultTextSize, n as DefaultThemeColor, c as DeployedInstance, D as DeploymentElement, d as DeploymentElementStyle, e as DeploymentNode, f as DeploymentNodeKind, g as DeploymentNodeKindSpecification, h as DeploymentRef, i as DeploymentRelation, b0 as DeploymentView, b1 as DeploymentViewRule, b2 as DeploymentViewRulePredicate, b3 as DeploymentViewRuleStyle, b4 as DiagramEdge, aA as DiagramNode, b5 as DiagramView, b6 as DynamicView, b7 as DynamicViewIncludeRule, b8 as DynamicViewParallelSteps, b9 as DynamicViewRule, ba as DynamicViewStep, bb as DynamicViewStepOrParallel, bc as EdgeId, q as Element, E as ElementKind, r as ElementKindSpecification, s as ElementKindSpecificationStyle, bw as ElementNotation, o as ElementShapes, u as ElementStyle, as as ElementThemeColorValues, ar as ElementThemeColors, bd as ElementView, a3 as EqualOperator, y as ExpressionV2, be as ExtendsElementView, a4 as Filterable, F as FqnExpr, z as FqnRef, Q as GenericLikeC4ModelData, G as GlobalDynamicPredicates, A as GlobalPredicateId, I as GlobalPredicates, J as GlobalStyleID, K as GlobalStyles, H as HexColorLiteral, a5 as KindEqual, S as LayoutedLikeC4ModelData, U as LikeC4ModelDump, b as LikeC4Theme, L as LikeC4View, v as Link, N as ModelGlobals, M as ModelLayer, ah as ModelRelation, bf as NodeId, a6 as NotOperator, a7 as OperatorPredicate, a8 as OrOperator, V as ParsedLikeC4ModelData, a9 as Participant, aa as ParticipantOperator, P as PredicateSelector, R as RelationExpr, ai as RelationId, aj as RelationshipArrowType, ak as RelationshipKind, al as RelationshipKindSpecification, am as RelationshipLineType, au as RelationshipThemeColorValues, at as RelationshipThemeColors, bg as ScopedElementView, av as ShapeSize, aw as SpacingSize, bh as StepEdgeId, bi as StepEdgeIdLiteral, ab as TagEqual, w as TagSpec, ax as TextSize, T as ThemeColorValues, ao as ThemeColors, x as TypedElement, bj as ViewAutoLayout, bm as ViewRule, bn as ViewRuleAutoLayout, bo as ViewRuleGlobalPredicateRef, bp as ViewRuleGlobalStyle, bq as ViewRuleGroup, br as ViewRulePredicate, bs as ViewRuleStyle, bt as ViewRuleStyleOrGlobalRef, bu as ViewWithHash, bv as ViewWithNotation, ac as WhereOperator, aB as extractStep, aC as getBBoxCenter, aD as getParallelStepsPrefix, W as isAndOperator, aE as isAutoLayoutDirection, aF as isDeploymentView, aG as isDynamicView, aH as isDynamicViewParallelSteps, aI as isElementView, aJ as isExtendsElementView, X as isKindEqual, Y as isNotOperator, Z as isOrOperator, _ as isParticipantOperator, aK as isScopedElementView, aL as isStepEdgeId, $ as isTagEqual, an as isThemeColor, aM as isViewRuleAutoLayout, aN as isViewRuleGlobalPredicateRef, aO as isViewRuleGlobalStyle, aP as isViewRuleGroup, aQ as isViewRulePredicate, aR as isViewRuleStyle, aS as stepEdgeId, a0 as whereOperatorAsPredicate } from '../shared/core.DJvmfnEi.mjs';
+import { d as NonEmptyArray, F as Fqn, D as DeploymentFqn } from '../shared/core.BuO4ncfY.mjs';
+export { A as AnyFqn, B as BuiltInIcon, C as Coalesce, b as DeploymentKind, E as EdgeId, a as ElementKind, f as ExclusiveUnion, m as GlobalFqn, G as GroupElementKind, i as Icon, j as IconUrl, I as IteratorLike, K as KeysOf, L as Link, g as NTuple, N as NodeId, e as NonEmptyReadonlyArray, h as Predicate, P as ProjectId, R as RelationId, l as RelationKind, c as RelationshipKind, p as StepEdgeId, S as StepEdgeIdLiteral, r as StepEdgeKind, T as Tag, V as ViewId, u as extractStep, n as isGlobalFqn, k as isGroupElementKind, t as isStepEdgeId, s as scalar, o as splitGlobalFqn, q as stepEdgeId } from '../shared/core.BuO4ncfY.mjs';
+export { A as Any, A as AnyAux, b as Aux, E as ExtractOnStage, M as ModelStage, S as SpecAux, U as Unknown, c as UnknownComputed, d as UnknownLayouted, e as UnknownParsed, _ as _stage, f as _type, a as aux, i as isOnStage } from '../shared/core.BaYE_r29.mjs';
+import { ap as BorderStyle, ar as ElementShape, ay as ThemeColor, b7 as ViewManualLayout, b2 as AutoLayoutDirection } from '../shared/core.DXzRBkuI.mjs';
+export { W as AbstractRelationship, ad as AndOperator, aY as AnyExcludePredicate, aX as AnyIncludePredicate, aK as AnyView, aZ as AnyViewRuleStyle, y as AuxFromDump, A as AuxFromLikeC4ModelData, B as BBox, ba as BaseParsedViewProperties, b9 as BaseViewProperties, ao as BorderStyles, az as Color, C as ColorLiteral, bh as ComputedDeploymentView, bi as ComputedDynamicView, bf as ComputedEdge, bg as ComputedElementView, l as ComputedLikeC4ModelData, be as ComputedNode, aI as ComputedView, at as CustomColor, au as CustomColorDefinitions, U as DefaultArrowType, H as DefaultElementShape, Q as DefaultLineStyle, J as DefaultPaddingSize, V as DefaultRelationshipColor, I as DefaultShapeSize, K as DefaultTextSize, z as DefaultThemeColor, p as DeployedInstance, q as DeploymentElement, r as DeploymentElementRef, D as DeploymentElementStyle, o as DeploymentNode, v as DeploymentRelation, u as DeploymentRelationship, bp as DeploymentViewExcludePredicate, bo as DeploymentViewIncludePredicate, bq as DeploymentViewPredicate, bs as DeploymentViewRule, br as DeploymentViewRuleStyle, bk as DiagramEdge, bj as DiagramNode, aG as DiagramView, by as DynamicViewIncludeRule, bv as DynamicViewParallelSteps, bz as DynamicViewRule, bu as DynamicViewStep, bx as DynamicViewStepOrParallel, O as Element, aq as ElementShapes, _ as ElementSpecification, N as ElementStyle, aB as ElementThemeColorValues, aC as ElementThemeColors, bD as ElementViewExcludePredicate, bC as ElementViewIncludePredicate, bE as ElementViewPredicate, bI as ElementViewRule, bF as ElementViewRuleGroup, bH as ElementViewRuleStyle, a3 as EqualOperator, E as Expression, ai as Filterable, F as FqnExpr, c as FqnRef, g as GlobalDynamicPredicates, G as GlobalPredicateId, f as GlobalPredicates, h as GlobalStyleID, i as GlobalStyles, as as HexColor, a6 as KindEqual, bm as LayoutedDeploymentView, bn as LayoutedDynamicView, bl as LayoutedElementView, m as LayoutedLikeC4ModelData, aG as LayoutedView, n as LikeC4ModelData, x as LikeC4ModelDump, L as LikeC4Theme, aF as LikeC4View, b as ModelExpression, M as ModelFqnExpr, j as ModelGlobals, Z as ModelRelation, a as ModelRelationExpr, bb as NodeNotation, ab as NotOperator, aj as OperatorPredicate, af as OrOperator, bt as ParsedDeploymentView, bA as ParsedDynamicView, bJ as ParsedElementView, k as ParsedLikeC4ModelData, aF as ParsedView, a8 as Participant, a9 as ParticipantOperator, d as Point, P as PredicateSelector, aJ as ProcessedView, e as RectBox, R as RelationExpr, Y as Relationship, aw as RelationshipArrowType, av as RelationshipLineType, a1 as RelationshipSpecification, aD as RelationshipThemeColorValues, aE as RelationshipThemeColors, an as ShapeSize, al as SpacingSize, w as SpecTypesFromDump, a2 as Specification, S as SpecificationDump, a4 as TagEqual, $ as TagSpecification, am as TextSize, T as ThemeColorValues, ax as ThemeColors, b6 as ViewAutoLayout, aL as ViewOnStage, aN as ViewRule, b4 as ViewRuleAutoLayout, b0 as ViewRuleGlobalPredicateRef, a_ as ViewRuleGlobalStyle, aO as ViewRulePredicate, b8 as ViewType, bd as ViewWithHash, bc as ViewWithNotation, aM as ViewWithType, ah as WhereOperator, X as XYPoint, bw as getParallelStepsPrefix, ae as isAndOperator, b3 as isAutoLayoutDirection, aR as isComputedView, t as isDeployedInstance, s as isDeploymentNode, aV as isDeploymentView, aH as isDiagramView, aW as isDynamicView, bB as isDynamicViewParallelSteps, aS as isElementView, aU as isExtendsElementView, a7 as isKindEqual, aH as isLayoutedView, ac as isNotOperator, ag as isOrOperator, aa as isParticipantOperator, aT as isScopedElementView, a0 as isTagColorSpecified, a5 as isTagEqual, aA as isThemeColor, b5 as isViewRuleAutoLayout, b1 as isViewRuleGlobalPredicateRef, a$ as isViewRuleGlobalStyle, bG as isViewRuleGroup, aP as isViewRulePredicate, aQ as isViewRuleStyle, ak as whereOperatorAsPredicate } from '../shared/core.DXzRBkuI.mjs';
 import 'type-fest';
 
-/**
- * OverviewGraph is a graph representation of all views in a model
- */
-declare namespace OverviewGraph {
-    type Node = {
-        id: string;
-        type: 'folder' | 'file';
-        path: string;
-        label: string;
-        parentId: string | null;
-        position: XYPoint;
-        width: number;
-        height: number;
-    } | {
-        id: string;
-        type: 'view';
-        viewId: ViewId;
-        label: string;
-        parentId: string | null;
-        position: XYPoint;
-        width: number;
-        height: number;
-    };
-    /**
-     * Edge represents a navigational link from one view to another
-     */
-    type Edge = {
-        id: string;
-        source: string;
-        target: string;
-        points: NonEmptyArray<Point>;
-    };
-}
-interface OverviewGraph {
-    nodes: OverviewGraph.Node[];
-    edges: OverviewGraph.Edge[];
-    bounds: BBox;
-}
-
 declare namespace ViewChange {
     interface ChangeElementStyle {
         op: 'change-element-style';
@@ -52,7 +14,7 @@ declare namespace ViewChange {
             shape?: ElementShape;
             color?: ThemeColor;
         };
-        targets: NonEmptyArray<Fqn>;
+        targets: NonEmptyArray<Fqn | DeploymentFqn>;
     }
     interface SaveManualLayout {
         op: 'save-manual-layout';
@@ -69,4 +31,4 @@ declare namespace ViewChange {
 }
 type ViewChange = ViewChange.ChangeElementStyle | ViewChange.SaveManualLayout | ViewChange.ChangeAutoLayout;
 
-export { AutoLayoutDirection, BBox, BorderStyle, ElementShape, Fqn, NonEmptyArray, OverviewGraph, Point, ThemeColor, ViewChange, ViewId, ViewManualLayout, XYPoint };
+export { AutoLayoutDirection, BorderStyle, DeploymentFqn, ElementShape, Fqn, NonEmptyArray, ThemeColor, ViewChange, ViewManualLayout };

package/dist/types/index.mjs

@@ -1,5 +1,132 @@
-export { A as AsFqn, B as BorderStyles, C as ComputedNode, z as ComputedView, v as DefaultArrowType, D as DefaultElementShape, x as DefaultLineStyle, f as DefaultPaddingSize, y as DefaultRelationshipColor, g as DefaultShapeSize, h as DefaultTextSize, b as DefaultThemeColor, c as DeploymentElement, H as DiagramNode, E as ElementKind, j as ElementShapes, k as ExpressionV2, F as FqnExpr, l as FqnRef, G as GlobalFqn, M as ModelLayer, R as RelationExpr, I as extractStep, J as getBBoxCenter, K as getParallelStepsPrefix, m as isAndOperator, L as isAutoLayoutDirection, N as isDeploymentView, O as isDynamicView, P as isDynamicViewParallelSteps, a as isElementView, i as isExtendsElementView, e as isGlobalFqn, p as isKindEqual, q as isNotOperator, r as isOrOperator, t as isParticipantOperator, d as isScopedElementView, Q as isStepEdgeId, u as isTagEqual, S as isViewRuleAutoLayout, T as isViewRuleGlobalPredicateRef, U as isViewRuleGlobalStyle, V as isViewRuleGroup, W as isViewRulePredicate, X as isViewRuleStyle, s as splitGlobalFqn, Y as stepEdgeId, w as whereOperatorAsPredicate } from '../shared/core.DgfwjBtu.mjs';
+export { f as DefaultArrowType, D as DefaultElementShape, g as DefaultLineStyle, m as DefaultPaddingSize, h as DefaultRelationshipColor, l as DefaultShapeSize, p as DefaultTextSize, a as DefaultThemeColor, A as DeploymentFqn, H as EdgeId, z as Fqn, F as FqnRef, B as GlobalFqn, G as GroupElementKind, N as NodeId, R as RelationId, S as StepEdgeKind, V as ViewId, b as _stage, _ as _type, I as extractStep, v as isAndOperator, i as isDeployedInstance, k as isDeploymentNode, C as isGlobalFqn, e as isGroupElementKind, r as isKindEqual, u as isNotOperator, j as isOnStage, x as isOrOperator, t as isParticipantOperator, d as isStepEdgeId, q as isTagEqual, E as splitGlobalFqn, s as stepEdgeId, w as whereOperatorAsPredicate } from '../shared/core.CUYDgv2-.mjs';
+export { E as Expression, F as FqnExpr, k as ModelExpression, M as ModelFqnExpr, j as ModelRelationExpr, R as RelationExpr, s as getParallelStepsPrefix, r as isAutoLayoutDirection, n as isComputedView, m as isDeploymentView, p as isDiagramView, l as isDynamicView, h as isDynamicViewParallelSteps, a as isElementView, i as isExtendsElementView, p as isLayoutedView, q as isScopedElementView, d as isViewRuleAutoLayout, f as isViewRuleGlobalPredicateRef, g as isViewRuleGlobalStyle, e as isViewRuleGroup, c as isViewRulePredicate, b as isViewRuleStyle } from '../shared/core.Bk7wEZFG.mjs';
+import { i as invariant } from '../shared/core.Cy9smucx.mjs';
+import '../shared/core.DbRvwARP.mjs';
 
+var BBox;
+((BBox2) => {
+  function center({ x, y, width, height }) {
+    return {
+      x: x + width / 2,
+      y: y + height / 2
+    };
+  }
+  BBox2.center = center;
+  function fromPoints(points) {
+    const { x1, y1, x2, y2 } = RectBox.fromPoints(points);
+    return {
+      x: x1,
+      y: y1,
+      width: x2 - x1,
+      height: y2 - y1
+    };
+  }
+  BBox2.fromPoints = fromPoints;
+  function merge(...boxes) {
+    invariant(boxes.length > 0, "No boxes provided");
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    for (const box of boxes) {
+      minX = Math.min(minX, box.x);
+      minY = Math.min(minY, box.y);
+      maxX = Math.max(maxX, box.x + box.width);
+      maxY = Math.max(maxY, box.y + box.height);
+    }
+    return {
+      x: minX,
+      y: minY,
+      width: maxX - minX,
+      height: maxY - minY
+    };
+  }
+  BBox2.merge = merge;
+  function toRectBox(box) {
+    return {
+      x1: box.x,
+      y1: box.y,
+      x2: box.x + box.width,
+      y2: box.y + box.height
+    };
+  }
+  BBox2.toRectBox = toRectBox;
+})(BBox || (BBox = {}));
+var RectBox;
+((RectBox2) => {
+  function center({ x1, y1, x2, y2 }) {
+    return {
+      x: (x1 + x2) / 2,
+      y: (y1 + y2) / 2
+    };
+  }
+  RectBox2.center = center;
+  function fromPoints(points) {
+    invariant(points.length > 0, "At least one point is required");
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    for (const [x, y] of points) {
+      minX = Math.min(minX, x);
+      minY = Math.min(minY, y);
+      maxX = Math.max(maxX, x);
+      maxY = Math.max(maxY, y);
+    }
+    return {
+      x1: minX,
+      y1: minY,
+      x2: maxX,
+      y2: maxY
+    };
+  }
+  RectBox2.fromPoints = fromPoints;
+  function merge(...boxes) {
+    invariant(boxes.length > 0, "No boxes provided");
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    for (const box of boxes) {
+      minX = Math.min(minX, box.x1);
+      minY = Math.min(minY, box.y1);
+      maxX = Math.max(maxX, box.x2);
+      maxY = Math.max(maxY, box.y2);
+    }
+    return {
+      x1: minX,
+      y1: minY,
+      x2: maxX,
+      y2: maxY
+    };
+  }
+  RectBox2.merge = merge;
+  function toBBox(box) {
+    return {
+      x: box.x1,
+      y: box.y1,
+      width: box.x2 - box.x1,
+      height: box.y2 - box.y1
+    };
+  }
+  RectBox2.toBBox = toBBox;
+})(RectBox || (RectBox = {}));
+
+function isTagColorSpecified(spec) {
+  const color = typeof spec === "string" ? spec : spec.color;
+  return color.startsWith("#") || color.startsWith("rgb");
+}
+
+const BorderStyles = ["solid", "dashed", "dotted", "none"];
+const ElementShapes = [
+  "rectangle",
+  "person",
+  "browser",
+  "mobile",
+  "cylinder",
+  "storage",
+  "queue"
+];
 const ThemeColors = [
   "amber",
   "blue",
@@ -14,7 +141,7 @@ const ThemeColors = [
   "sky"
 ];
 function isThemeColor(color) {
-  return color in ThemeColors;
+  return ThemeColors.includes(color);
 }
 
-export { ThemeColors, isThemeColor };
+export { BBox, BorderStyles, ElementShapes, RectBox, ThemeColors, isTagColorSpecified, isThemeColor };

package/dist/utils/index.d.mts

@@ -1,36 +1,7 @@
-export { I as IterableContainer, R as ReorderedArray, a as ancestorsFqn, c as commonAncestor, b as compareByFqnHierarchically, d as compareFqnHierarchically, h as hierarchyDistance, e as hierarchyLevel, i as isAncestor, f as isDescendantOf, g as isSameHierarchy, n as nameFromFqn, p as parentFqn, s as sortByFqnHierarchically, j as sortNaturalByFqn, k as sortParentsFirst } from '../shared/core.D2830qgg.mjs';
-import { N as NonEmptyArray, I as IteratorLike } from '../shared/core.SjLhMA7a.mjs';
-import { IsNumericLiteral } from 'type-fest';
-
-/**
- * Mnemonist DefaultMap Typings
- * =============================
- */
-declare class DefaultMap<K, V> implements Iterable<[K, V]> {
-
-  // Members
-  size: number;
-
-  // Constructor
-  constructor(factory: (key: K, index: number) => V);
-
-  // Methods
-  clear(): void;
-  set(key: K, value: V): this;
-  delete(key: K): boolean;
-  has(key: K): boolean;
-  get(key: K): V;
-  peek(key: K): V | undefined;
-  forEach(callback: (value: V, key: K, map: this) => void, scope?: any): void;
-  keys(): IterableIterator<K>;
-  values(): IterableIterator<V>;
-  entries(): IterableIterator<[K, V]>;
-  [Symbol.iterator](): IterableIterator<[K, V]>;
-  inspect(): any;
-
-  // Statics
-  static autoIncrement(): number;
-}
+export { D as DefaultMap } from '../shared/core.CywrQs86.mjs';
+export { I as IterableContainer, R as ReorderedArray, a as ancestorsFqn, c as commonAncestor, b as compareByFqnHierarchically, d as compareFqnHierarchically, h as hierarchyDistance, e as hierarchyLevel, i as isAncestor, f as isDescendantOf, g as isSameHierarchy, n as nameFromFqn, p as parentFqn, s as sortByFqnHierarchically, j as sortNaturalByFqn, k as sortParentsFirst } from '../shared/core.Pf5I9o0e.mjs';
+import { d as NonEmptyArray, I as IteratorLike } from '../shared/core.BuO4ncfY.mjs';
+import { Tagged, Simplify, Or, IfNever, IsLiteral, And, GreaterThan, IsNever, IsEqual, ReadonlyTuple, IsNumericLiteral } from 'type-fest';
 
 /**
  * Mnemonist DefaultWeakMap Typings
@@ -245,6 +216,10 @@ declare class BiMap<K, V> implements Iterable<[K, V]> {
   static from<I, J>(iterable: Iterable<[I, J]> | {[key: string]: J}): BiMap<I, J>;
 }
 
+declare function nonNullable<T>(value: T, message?: string | (() => string)): NonNullable<T>;
+declare function invariant(condition: any, message?: string): asserts condition;
+declare function nonexhaustive(value: never): never;
+
 /**
  * Common head of two arrays
  *
@@ -253,6 +228,26 @@ declare class BiMap<K, V> implements Iterable<[K, V]> {
 declare function commonHead<T>(sources: ReadonlyArray<T>, targets: ReadonlyArray<T>, equals?: (a: T, b: T) => boolean): T[];
 
 declare function compareNatural(a: string | undefined, b: string | undefined): -1 | 0 | 1;
+/**
+ * Compares two strings hierarchically based on their depth.
+ * From parent nodes to leaves
+ *
+ * @example
+ * const lines = [
+ *   'a.b.c',
+ *   'a',
+ *   'a.b',
+ *   'a.c.c',
+ * ]
+ * lines.sort(compareNaturalHierarchically('.'))
+ * // [
+ * //   'a',
+ * //   'a.b',
+ * //   'a.b.c',
+ * //   'a.c.c',
+ * // ]
+ */
+declare function compareNaturalHierarchically(separator?: string): (a: string | undefined, b: string | undefined) => number;
 
 declare function getOrCreate<K, V>(map: Map<K, V>, key: K, create: (key: K) => V): V;
 
@@ -270,19 +265,155 @@ declare function getOrCreate<K, V>(map: Map<K, V>, key: K, create: (key: K) => V
  */
 type IterableContainer<T = unknown> = ReadonlyArray<T> | readonly [];
 
-type ArraySetRequired<T extends IterableContainer, Min extends number, Iteration extends ReadonlyArray<unknown> = []> = number extends Min ? never : Iteration["length"] extends Min ? T : T extends readonly [] ? never : T extends [infer Head, ...infer Rest] ? [
-    Head,
-    ...ArraySetRequired<Rest, Min, [unknown, ...Iteration]>
-] : T extends readonly [infer Head, ...infer Rest] ? readonly [
-    Head,
-    ...ArraySetRequired<Rest, Min, [unknown, ...Iteration]>
-] : T extends Array<infer Item> ? [
-    Item,
-    ...ArraySetRequired<T, Min, [unknown, ...Iteration]>
-] : T extends ReadonlyArray<infer Item> ? readonly [
-    Item,
-    ...ArraySetRequired<T, Min, [unknown, ...Iteration]>
-] : never;
+declare const RemedaErrorSymbol: unique symbol;
+type RemedaTypeErrorOptions = {
+    type?: unknown;
+    metadata?: unknown;
+};
+/**
+ * Used for reporting type errors in a more useful way than `never`.
+ */
+type RemedaTypeError<Name extends string, Message extends string, Options extends RemedaTypeErrorOptions = {}> = Tagged<Options extends {
+    type: infer T;
+} ? T : typeof RemedaErrorSymbol, `RemedaTypeError(${Name}): ${Message}.`, Options extends {
+    metadata: infer Metadata;
+} ? Metadata : never>;
+
+/**
+ * Takes a tuple and returns the types that make up its parts. These parts
+ * follow TypeScript's only supported format for arrays/tuples:
+ * [<required>, <optional>, ...<rest>[], <suffix>].
+ *
+ * There are some limitations to what shapes TypeScript supports:
+ * tuples can only have a suffix if they also have a non-never rest element,
+ * **and** tuples cannot have both an optional part and a suffix; this means
+ * there are only 10 possible shapes for tuples:
+ *   1.  Empty Tuples: `[]`.
+ *   2.  Fixed Tuples: `[string, number]`.
+ *   3.  Optional Tuples: `[string?, number?]`.
+ *   4.  Mixed Tuples: `[string, number?]`.
+ *   5.  Arrays: `Array<string>`.
+ *   6.  Fixed-Prefix Arrays: `[string, ...Array<string>]`.
+ *   7.  Optional-Prefix Arrays: `[number?, ...Array<boolean>]`.
+ *   8.  Mixed-Prefix Arrays: `[string, number?, ...Array<boolean>]`.
+ *   9.  Fixed-Suffix Arrays: `[...Array<string>, string]`.
+ *   10. Fixed-Elements Arrays: `[string, ...Array<string>, string]`.
+ *
+ * @example [
+ *   ...TupleParts<T>["required"],
+ *   ...Partial<TupleParts<T>["optional"]>,
+ *   ...CoercedArray<TupleParts<T>["item"]>,
+ *   ...TupleParts<T>["suffix"],
+ * ].
+ */
+type TupleParts<T extends IterableContainer, Prefix extends Array<unknown> = []> = T extends readonly [infer Head, ...infer Tail] ? TupleParts<Tail, [...Prefix, Head]> : Simplify<{
+    /**
+     * A fixed tuple that defines the part of the tuple where all its
+     * elements are required. This will always be the first part of the
+     * tuple and will never contain any optional or rest elements. When the
+     * array doesn't have a required part this will be an empty tuple
+     * (`[]`).
+     */
+    required: Prefix;
+} & TuplePartsWithoutRequired<T>>;
+type TuplePartsWithoutRequired<T extends IterableContainer, Suffix extends Array<unknown> = []> = T extends readonly [...infer Head, infer Tail] ? TuplePartsWithoutRequired<Head, [Tail, ...Suffix]> : (Suffix extends readonly [] ? TuplePartsWithoutFixed<T> : // When the suffix is not empty we can skip the optional part and go
+{
+    optional: [];
+} & TuplePartsRest<T>) & {
+    /**
+     * A *fixed* tuple that defines the part of a tuple **after** a non-never
+     * rest parameter. These could never be optional elements, and could
+     * never contain another rest element. When the array doesn't have a
+     * required part this will be an empty tuple (`[]`).
+     */
+    suffix: Suffix;
+};
+type TuplePartsWithoutFixed<T extends IterableContainer, Optional extends Array<unknown> = []> = T extends readonly [(infer Head)?, ...infer Tail] ? Or<T extends readonly [] ? true : false, Array<T[number]> extends Tail ? true : false> extends true ? {
+    /**
+     * A *fixed* tuple that defines the part of a tuple where all its
+     * elements are suffixed with the optional operator (`?`); but with
+     * the optional operator removed (e.g. `[string?]` would be
+     * represented as `[string]`). These elements can only follow the
+     * `required` part (which could be empty).
+     * To add optional operator back wrap the result with the built-in
+     * `Partial` type.
+     * When the array doesn't have a required part this will be an empty
+     * tuple (`[]`).
+     *
+     * @example Partial<TupleParts<T>["optional"]>
+     */
+    optional: Optional;
+} & TuplePartsRest<T> : TuplePartsWithoutFixed<Tail, [...Optional, Head | undefined]> : RemedaTypeError<"TupleParts", "Unexpected tuple shape", {
+    type: never;
+    metadata: T;
+}>;
+type TuplePartsRest<T extends IterableContainer> = {
+    /**
+     * The type for the rest parameter of the tuple, if any. Unlike the
+     * other parts of the tuple, this is a single type and not
+     * represented as an array/tuple. When a tuple doesn't have a rest
+     * element, this will be `never`. To convert this to a matching array
+     * type that could be spread into a new type use the `CoercedArray`
+     * type which handles the `never` case correctly.
+     *
+     * @example CoercedArray<TupleParts<T>["item"]>
+     */
+    item: T extends readonly [] ? never : T[number];
+};
+
+/**
+ * We built our own version of Subtract instead of using type-fest's one
+ * because we needed a simpler implementation that isn't as prone to excessive
+ * recursion issues and that is clamped at 0 so that we don't need to handle
+ * negative values using even more utilities.
+ */
+type ClampedIntegerSubtract<Minuend, Subtrahend, SubtrahendBag extends Array<unknown> = [], ResultBag extends Array<unknown> = []> = [...SubtrahendBag, ...ResultBag]["length"] extends Minuend ? ResultBag["length"] : SubtrahendBag["length"] extends Subtrahend ? ClampedIntegerSubtract<Minuend, Subtrahend, SubtrahendBag, [
+    ...ResultBag,
+    unknown
+]> : ClampedIntegerSubtract<Minuend, Subtrahend, [
+    ...SubtrahendBag,
+    unknown
+], ResultBag>;
+
+/**
+ * `never[]` and `[]` are not the same type, and in some cases they aren't
+ * interchangeable.
+ *
+ * This type makes it easier to use the result of TupleParts when the input is a
+ * fixed-length tuple but we still want to spread the rest of the array. e.g.
+ * `[...CoercedArray<TupleParts<T>["item"]>, ...TupleParts<T>["suffix"]]`.
+ *
+ */
+type CoercedArray<T> = IfNever<T, [], Array<T>>;
+
+type ArrayRequiredPrefix<T extends IterableContainer, N extends number> = IsLiteral<N> extends true ? T extends unknown ? ClampedIntegerSubtract<N, [
+    ...TupleParts<T>["required"],
+    ...TupleParts<T>["suffix"]
+]["length"]> extends infer Remainder extends number ? Remainder extends 0 ? T : And<GreaterThan<Remainder, TupleParts<T>["optional"]["length"]>, IsNever<TupleParts<T>["item"]>> extends true ? RemedaTypeError<"ArrayRequiredPrefix", "The input tuple cannot satisfy the minimum", {
+    type: never;
+    metadata: [T, N];
+}> : WithSameReadonly<T, [
+    ...TupleParts<T>["required"],
+    ...OptionalTupleRequiredPrefix<TupleParts<T>["optional"], Remainder>,
+    ...ReadonlyTuple<TupleParts<T>["item"], ClampedIntegerSubtract<Remainder, TupleParts<T>["optional"]["length"]>>,
+    ...CoercedArray<TupleParts<T>["item"]>,
+    ...TupleParts<T>["suffix"]
+]> : RemedaTypeError<"ArrayRequiredPrefix", "Remainder didn't compute to a number?!", {
+    type: never;
+    metadata: [T, N];
+}> : RemedaTypeError<"ArrayRequiredPrefix", "Failed to distribute union?!", {
+    type: never;
+    metadata: T;
+}> : RemedaTypeError<"ArrayRequiredPrefix", "Only literal minimums are supported!", {
+    type: never;
+    metadata: N;
+}>;
+type WithSameReadonly<Source, Destination> = IsEqual<Source, Readonly<Source>> extends true ? Readonly<Destination> : Destination;
+type OptionalTupleRequiredPrefix<T extends Array<unknown>, N, Prefix extends Array<unknown> = []> = Prefix["length"] extends N ? [
+    ...Prefix,
+    ...Partial<T>
+] : T extends readonly [infer Head, ...infer Rest] ? OptionalTupleRequiredPrefix<Rest, N, [...Prefix, Head]> : Prefix;
+
 /**
  * Checks if the given array has at least the defined number of elements. When
  * the minimum used is a literal (e.g. `3`) the output is refined accordingly so
@@ -305,7 +436,7 @@ type ArraySetRequired<T extends IterableContainer, Min extends number, Iteration
  * @dataFirst
  * @category Array
  */
-declare function hasAtLeast<T extends IterableContainer, N extends number>(data: IterableContainer | T, minimum: IsNumericLiteral<N> extends true ? N : never): data is ArraySetRequired<T, N>;
+declare function hasAtLeast<T extends IterableContainer, N extends number>(data: IterableContainer | T, minimum: IsNumericLiteral<N> extends true ? N : never): data is ArrayRequiredPrefix<T, N>;
 declare function hasAtLeast(data: IterableContainer, minimum: number): boolean;
 /**
  * Checks if the given array has at least the defined number of elements. When
@@ -331,7 +462,7 @@ declare function hasAtLeast(data: IterableContainer, minimum: number): boolean;
  * @dataLast
  * @category Array
  */
-declare function hasAtLeast<N extends number>(minimum: IsNumericLiteral<N> extends true ? N : never): <T extends IterableContainer>(data: IterableContainer | T) => data is ArraySetRequired<T, N>;
+declare function hasAtLeast<N extends number>(minimum: IsNumericLiteral<N> extends true ? N : never): <T extends IterableContainer>(data: IterableContainer | T) => data is ArrayRequiredPrefix<T, N>;
 declare function hasAtLeast(minimum: number): (data: IterableContainer) => boolean;
 
 declare function isString(value: unknown): value is string;
@@ -364,6 +495,7 @@ declare function ifilter<T>(iterable: Iterable<T>, predicate: (v: T) => boolean)
  * @signature
  *   ifind(predicate)(data)
  */
+declare function ifind<T, S extends T>(predicate: (item: T) => item is S): (iterable: Iterable<T>) => S | undefined;
 declare function ifind<T>(predicate: (item: T) => boolean): (iterable: Iterable<T>) => T | undefined;
 /**
  * Finds the first element in the iterable that satisfies the predicate.
@@ -371,11 +503,21 @@ declare function ifind<T>(predicate: (item: T) => boolean): (iterable: Iterable<
  * @signature
  *  ifind(data, predicate)
  */
+declare function ifind<T, S extends T>(iterable: Iterable<T>, predicate: (item: T) => item is S): S | undefined;
 declare function ifind<T>(iterable: Iterable<T>, predicate: (item: T) => boolean): T | undefined;
 
 declare function iflat(): <T>(iterable: Iterable<IteratorLike<T>>) => IteratorLike<T>;
 declare function iflat<T>(iterable: Iterable<IteratorLike<T>>): IteratorLike<T>;
 
+declare function ihead<T>(): (iterable: Iterable<T>) => T | undefined;
+/**
+ * Finds the first element in the iterable that satisfies the predicate.
+ * Data first version of `find`.
+ * @signature
+ *  ifind(data, predicate)
+ */
+declare function ihead<T>(iterable: Iterable<T>): T | undefined;
+
 type MapFunction<T, S> = (item: T) => S;
 /**
  * Maps an iterable using a mapper function.
@@ -422,18 +564,44 @@ declare function toSet<T>(iterable: Iterable<T>): Set<T>;
 declare function iunique(): <T>(iterable: Iterable<T>) => IteratorLike<T>;
 declare function iunique<T>(iterable: Iterable<T>): IteratorLike<T>;
 
+/**
+ * Saves the value returned by fn() in a hidden property tag of obj object, so next time memoizeProp() is called,
+ * that value will be returned, and fn won't be called.
+ *
+ * @example
+ * ```ts
+ * class Model {
+ *   // using same Symbol
+ *   get computed1() {
+ *     return memoizeProp(this, Symbol.for('computed1'), () => doOnce())
+ *   }
+ *   // using string
+ *   get computed2() {
+ *     return memoizeProp(this, 'computed2', () => doOnce())
+ *   }
+ *
+ * }
+ * ```
+ */
+declare function memoizeProp<Tag extends symbol | string, Res>(obj: object, tag: Tag, fn: () => Res): Res;
+
 declare function delay(): Promise<string>;
 declare function delay(ms: number): Promise<string>;
 declare function delay(randomFrom: number, randomTo: number): Promise<string>;
 
+type RelationshipLike = {
+    source: {
+        model: string;
+    };
+    target: {
+        model: string;
+    };
+};
 /**
  * Compares two relations hierarchically.
  * From the most general (implicit) to the most specific.
  */
-declare const compareRelations: <T extends {
-    source: string;
-    target: string;
-}>(a: T, b: T) => number;
+declare const compareRelations: <T extends RelationshipLike>(a: T, b: T) => number;
 
 /**
  * Returns new set as a union of given sets
@@ -456,4 +624,4 @@ declare function stringHash(str: string): string;
 
 declare function objectHash(value: any): string;
 
-export { BiMap, DefaultMap, DefaultWeakMap, LinkedList, MultiMap, Queue, Stack, commonHead, compareNatural, compareRelations, delay, difference, equals as equalsSet, getOrCreate, hasAtLeast, ifilter, ifind, iflat, imap, intersection, ireduce, isIterable, isNonEmptyArray, isString, isome, iunique, objectHash, stringHash, symmetricDifference, toArray, toSet, union };
+export { BiMap, DefaultWeakMap, LinkedList, MultiMap, Queue, Stack, commonHead, compareNatural, compareNaturalHierarchically, compareRelations, delay, difference, equals as equalsSet, getOrCreate, hasAtLeast, ifilter, ifind, iflat, ihead, imap, intersection, invariant, ireduce, isIterable, isNonEmptyArray, isString, isome, iunique, memoizeProp, nonNullable, nonexhaustive, objectHash, stringHash, symmetricDifference, toArray, toSet, union };

package/dist/utils/index.mjs

@@ -1,8 +1,12 @@
-import { r as requireForeach, p as requireIterator, v as n } from '../shared/core.Cu-UdkSl.mjs';
-export { S as Stack, c as commonHead, h as difference, j as equalsSet, g as getOrCreate, i as hasAtLeast, a as ifind, b as iflat, k as intersection, d as isIterable, e as isome, f as iunique, o as objectHash, n as stringHash, s as symmetricDifference, u as union } from '../shared/core.Cu-UdkSl.mjs';
-import { j as getDefaultExportFromCjs, h as t, m as commonAncestor, q as compareFqnHierarchically } from '../shared/core.CQXU9DF7.mjs';
-export { D as DefaultMap, l as ancestorsFqn, o as compareByFqnHierarchically, k as compareNatural, r as hierarchyDistance, u as hierarchyLevel, c as ifilter, d as imap, a as isAncestor, i as isDescendantOf, e as isNonEmptyArray, g as isSameHierarchy, x as isString, n as nameFromFqn, p as parentFqn, v as sortByFqnHierarchically, w as sortNaturalByFqn, s as sortParentsFirst, b as toArray, t as toSet } from '../shared/core.CQXU9DF7.mjs';
-import { i as invariant } from '../shared/core.C-YXI-43.mjs';
+import { i as invariant } from '../shared/core.Cy9smucx.mjs';
+export { n as nonNullable, a as nonexhaustive } from '../shared/core.Cy9smucx.mjs';
+import { r as requireForeach, a as requireIterator, n } from '../shared/core.CpXlRyE5.mjs';
+export { S as Stack, c as commonHead, e as iflat, i as isIterable, b as iunique, o as objectHash } from '../shared/core.CpXlRyE5.mjs';
+import { g as getDefaultExportFromCjs, t, k as commonAncestor, q as compareFqnHierarchically } from '../shared/core.rmvsy0n3.mjs';
+export { D as DefaultMap, l as ancestorsFqn, h as compareByFqnHierarchically, m as compareNatural, o as compareNaturalHierarchically, r as hierarchyDistance, u as hierarchyLevel, b as ifilter, a as isAncestor, i as isDescendantOf, c as isNonEmptyArray, d as isSameHierarchy, w as isString, n as nameFromFqn, p as parentFqn, j as sortByFqnHierarchically, v as sortNaturalByFqn, s as sortParentsFirst } from '../shared/core.rmvsy0n3.mjs';
+export { d as difference, j as equalsSet, g as getOrCreate, i as hasAtLeast, c as ifind, e as ihead, a as intersection, b as isome, f as memoizeProp, k as stringHash, s as symmetricDifference, u as union } from '../shared/core.DoK86JEe.mjs';
+export { i as imap, a as toArray, t as toSet } from '../shared/core.BrCnZFTn.mjs';
+import '../shared/core.DbRvwARP.mjs';
 
 function o(r,n){let e=Math.ceil(r),t=Math.floor(n);if(t<e)throw new RangeError(`randomInteger: The range [${r.toString()},${n.toString()}] contains no integer`);return Math.floor(Math.random()*(t-e+1)+e)}
 
@@ -1287,8 +1291,8 @@ function delay(...args) {
 }
 
 const compareRelations = (a, b) => {
-  const parentA = commonAncestor(a.source, a.target);
-  const parentB = commonAncestor(b.source, b.target);
+  const parentA = commonAncestor(a.source.model, a.target.model);
+  const parentB = commonAncestor(b.source.model, b.target.model);
   if (parentA && !parentB) {
     return 1;
   }
@@ -1299,11 +1303,11 @@ const compareRelations = (a, b) => {
   if (compareParents !== 0) {
     return compareParents;
   }
-  const compareSource = compareFqnHierarchically(a.source, b.source);
+  const compareSource = compareFqnHierarchically(a.source.model, b.source.model);
   if (compareSource !== 0) {
     return compareSource;
   }
-  return compareFqnHierarchically(a.target, b.target);
+  return compareFqnHierarchically(a.target.model, b.target.model);
 };
 
-export { biMap as BiMap, defaultWeakMap as DefaultWeakMap, linkedList as LinkedList, multiMap as MultiMap, queue as Queue, commonAncestor, compareFqnHierarchically, compareRelations, delay, ireduce };
+export { biMap as BiMap, defaultWeakMap as DefaultWeakMap, linkedList as LinkedList, multiMap as MultiMap, queue as Queue, commonAncestor, compareFqnHierarchically, compareRelations, delay, invariant, ireduce };