@likec4/core 0.37.0 → 0.40.0

package/dist/esm/colors.d.ts

@@ -0,0 +1,148 @@
+export declare const RelationColors: {
+    readonly lineColor: "#b1b1b1";
+    readonly labelColor: "#b1b1b1";
+};
+export declare const Colors: {
+    readonly primary: {
+        fill: "#3b82f6";
+        stroke: "#2563eb";
+        hiContrast: "#eff6ff";
+        loContrast: "#bfdbfe";
+    };
+    readonly blue: {
+        fill: "#3b82f6";
+        stroke: "#2563eb";
+        hiContrast: "#eff6ff";
+        loContrast: "#bfdbfe";
+    };
+    readonly secondary: {
+        fill: "#0284c7";
+        stroke: "#0369a1";
+        hiContrast: "#f0f9ff";
+        loContrast: "#e0f2fe";
+    };
+    readonly sky: {
+        fill: "#0284c7";
+        stroke: "#0369a1";
+        hiContrast: "#f0f9ff";
+        loContrast: "#e0f2fe";
+    };
+    readonly muted: {
+        fill: "#64748b";
+        stroke: "#475569";
+        hiContrast: "#f8fafc";
+        loContrast: "#e2e8f0";
+    };
+    readonly slate: {
+        fill: "#64748b";
+        stroke: "#475569";
+        hiContrast: "#f8fafc";
+        loContrast: "#e2e8f0";
+    };
+    readonly gray: {
+        readonly fill: "#737373";
+        readonly stroke: "#525252";
+        readonly hiContrast: "#fafafa";
+        readonly loContrast: "#e5e5e5";
+    };
+    readonly red: {
+        readonly fill: "#b54548";
+        readonly stroke: "#8c333a";
+        readonly hiContrast: "#f8fafc";
+        readonly loContrast: "#F9C6C6";
+    };
+    readonly green: {
+        readonly fill: "#428a4f";
+        readonly stroke: "#2d5d39";
+        readonly hiContrast: "#f8fafc";
+        readonly loContrast: "#c2f0c2";
+    };
+    readonly amber: {
+        readonly fill: "#d97706";
+        readonly stroke: "#b45309";
+        readonly hiContrast: "#f8fafc";
+        readonly loContrast: "#ffe0c2";
+    };
+    readonly indigo: {
+        readonly fill: "#6366f1";
+        readonly stroke: "#4f46e5";
+        readonly hiContrast: "#eef2ff";
+        readonly loContrast: "#c7d2fe";
+    };
+};
+export declare const defaultTheme: {
+    readonly font: "Helvetica";
+    readonly shadow: "#0a0a0a";
+    readonly relation: {
+        readonly lineColor: "#b1b1b1";
+        readonly labelColor: "#b1b1b1";
+    };
+    readonly colors: {
+        readonly primary: {
+            fill: "#3b82f6";
+            stroke: "#2563eb";
+            hiContrast: "#eff6ff";
+            loContrast: "#bfdbfe";
+        };
+        readonly blue: {
+            fill: "#3b82f6";
+            stroke: "#2563eb";
+            hiContrast: "#eff6ff";
+            loContrast: "#bfdbfe";
+        };
+        readonly secondary: {
+            fill: "#0284c7";
+            stroke: "#0369a1";
+            hiContrast: "#f0f9ff";
+            loContrast: "#e0f2fe";
+        };
+        readonly sky: {
+            fill: "#0284c7";
+            stroke: "#0369a1";
+            hiContrast: "#f0f9ff";
+            loContrast: "#e0f2fe";
+        };
+        readonly muted: {
+            fill: "#64748b";
+            stroke: "#475569";
+            hiContrast: "#f8fafc";
+            loContrast: "#e2e8f0";
+        };
+        readonly slate: {
+            fill: "#64748b";
+            stroke: "#475569";
+            hiContrast: "#f8fafc";
+            loContrast: "#e2e8f0";
+        };
+        readonly gray: {
+            readonly fill: "#737373";
+            readonly stroke: "#525252";
+            readonly hiContrast: "#fafafa";
+            readonly loContrast: "#e5e5e5";
+        };
+        readonly red: {
+            readonly fill: "#b54548";
+            readonly stroke: "#8c333a";
+            readonly hiContrast: "#f8fafc";
+            readonly loContrast: "#F9C6C6";
+        };
+        readonly green: {
+            readonly fill: "#428a4f";
+            readonly stroke: "#2d5d39";
+            readonly hiContrast: "#f8fafc";
+            readonly loContrast: "#c2f0c2";
+        };
+        readonly amber: {
+            readonly fill: "#d97706";
+            readonly stroke: "#b45309";
+            readonly hiContrast: "#f8fafc";
+            readonly loContrast: "#ffe0c2";
+        };
+        readonly indigo: {
+            readonly fill: "#6366f1";
+            readonly stroke: "#4f46e5";
+            readonly hiContrast: "#eef2ff";
+            readonly loContrast: "#c7d2fe";
+        };
+    };
+};

package/dist/{colors.js → esm/colors.js}

@@ -2,11 +2,11 @@ const blue = {
   // fill: colors.blue[500],
   // stroke: colors.blue[600],
   // hiContrast: colors.blue[50],
-  // loContrast: colors.blue[100],
+  // loContrast: colors.blue[200],
   fill: "#3b82f6",
   stroke: "#2563eb",
   hiContrast: "#eff6ff",
-  loContrast: "#dbeafe"
+  loContrast: "#bfdbfe"
 };
 const sky = {
   // fill: colors.sky[600],
@@ -29,10 +29,8 @@ const slate = {
   loContrast: "#e2e8f0"
 };
 export const RelationColors = {
-  // lineColor: colors.neutral[400],
-  // labelColor: colors.neutral[300],
-  lineColor: "#a3a3a3",
-  labelColor: "#d4d4d4"
+  lineColor: "#b1b1b1",
+  labelColor: "#b1b1b1"
 };
 export const Colors = {
   primary: blue,
@@ -56,28 +54,22 @@ export const Colors = {
     // stroke: colors.red[600],
     // hiContrast: colors.red[50],
     // loContrast: colors.red[200],
-    fill: "#ef4444",
-    stroke: "#dc2626",
+    fill: "#b54548",
+    stroke: "#8c333a",
     // hiContrast: '#fef2f2',
     // loContrast: '#fecaca',
-    hiContrast: "#111827",
-    // colors.gray[900],
-    loContrast: "#1f2937"
-    // colors.gray[800],
+    // hiContrast: '#191111', // colors.gray[900],
+    // loContrast: '#3b1219' // colors.gray[800],
+    hiContrast: "#f8fafc",
+    // hiContrast: '#f8fafc',
+    // loContrast: '#fdd8d8' // radix black red 12
+    loContrast: "#F9C6C6"
   },
   green: {
-    // fill: colors.green[600],
-    // stroke: colors.green[700],
-    // hiContrast: colors.green[50],
-    // loContrast: colors.green[200],
-    fill: "#16a34a",
-    stroke: "#15803d",
-    hiContrast: "#111827",
-    // colors.gray[900],
-    // hiContrast: '#f0fdf4',
-    loContrast: "#1f2937"
-    // colors.gray[800],
-    // loContrast: '#bbf7d0'
+    fill: "#428a4f",
+    stroke: "#2d5d39",
+    hiContrast: "#f8fafc",
+    loContrast: "#c2f0c2"
   },
   amber: {
     // fill: colors.amber[600],
@@ -88,9 +80,9 @@ export const Colors = {
     stroke: "#b45309",
     // hiContrast: '#fffbeb',
     // loContrast: '#fde68a',
-    hiContrast: "#111827",
+    hiContrast: "#f8fafc",
     // colors.gray[900],
-    loContrast: "#1f2937"
+    loContrast: "#ffe0c2"
     // colors.gray[800],
   },
   indigo: {

package/dist/esm/compute-view/EdgeBuilder.d.ts

@@ -0,0 +1,6 @@
+import type { ComputedEdge, Fqn, Relation } from '../types';
+export declare class EdgeBuilder {
+    private _relationsObj;
+    add(source: Fqn, target: Fqn, relation: Relation): this;
+    build(): ComputedEdge[];
+}

package/dist/esm/compute-view/compute-ctx.d.ts

@@ -0,0 +1,20 @@
+import type { ModelIndex } from '../model-index';
+import type { Fqn, Element, Relation, ViewRuleExpression, ElementView } from '../types';
+export type ComputeCtxPatch = {
+    elements?: Element[];
+    relations?: Relation[];
+    implicits?: Element[];
+};
+export declare class ComputeCtx {
+    index: ModelIndex;
+    root: Fqn | null;
+    elements: ReadonlySet<Element>;
+    relations: ReadonlySet<Relation>;
+    implicits: ReadonlySet<Element>;
+    readonly allElements: ReadonlySet<Element>;
+    constructor(index: ModelIndex, root: Fqn | null, elements?: ReadonlySet<Element>, relations?: ReadonlySet<Relation>, implicits?: ReadonlySet<Element>);
+    include({ elements, relations, implicits }: ComputeCtxPatch): ComputeCtx;
+    exclude({ elements, relations, implicits }: ComputeCtxPatch): ComputeCtx;
+    processViewRules(viewRules: ViewRuleExpression[]): ComputeCtx;
+    static create(view: ElementView, index: ModelIndex): ComputeCtx;
+}

package/dist/{compute-view → esm/compute-view}/compute-ctx.js

@@ -24,7 +24,9 @@ export class ComputeCtx {
     this.elements = elements;
     this.relations = relations;
     this.implicits = implicits;
+    this.allElements = /* @__PURE__ */ new Set([...this.elements, ...this.implicits]);
   }
+  allElements;
   include({ elements, relations, implicits }) {
     return new ComputeCtx(
       this.index,

package/dist/esm/compute-view/compute-element-view.d.ts

@@ -0,0 +1,3 @@
+import type { ModelIndex } from '../model-index';
+import { type ComputedView, type ElementView } from '../types';
+export declare function computeElementView(view: ElementView, index: ModelIndex): ComputedView;

package/dist/{compute-view → esm/compute-view}/compute-element-view.js

@@ -14,6 +14,7 @@ import { sortNodes } from "./utils/sortNodes.js";
 function reduceToMap(elementsIterator) {
   return Array.from(elementsIterator).sort(compareByFqnHierarchically).reduce((map, { id, color, shape, ...el }) => {
     let parent = parentFqn(id);
+    let level = 0;
     while (parent) {
       if (map.has(parent)) {
         break;
@@ -23,11 +24,13 @@ function reduceToMap(elementsIterator) {
     if (parent) {
       const parentNd = nonNullable(map.get(parent));
       parentNd.children.push(id);
+      level = parentNd.level + 1;
     }
     const node = {
       ...el,
       id,
       parent,
+      level,
       color: color ?? DefaultThemeColor,
       shape: shape ?? DefaultElementShape,
       children: [],
@@ -38,19 +41,29 @@ function reduceToMap(elementsIterator) {
     return map;
   }, /* @__PURE__ */ new Map());
 }
+const keepOriginalSortFromView = (_nodes, ctx) => {
+  const nodes = [...ctx.allElements].flatMap((e) => _nodes.get(e.id) || []);
+  for (const node of nodes) {
+    node.children = nodes.flatMap((n) => n.parent === node.id ? n.id : []);
+  }
+  return nodes;
+};
 export function computeElementView(view, index) {
   const ctx = ComputeCtx.create(view, index);
-  const allElements = [...ctx.elements, ...ctx.implicits].sort(compareByFqnHierarchically).reverse();
+  const leafsFirst = [...ctx.allElements].sort((a, b) => -1 * compareByFqnHierarchically(a, b));
   const elementsWithRelations = /* @__PURE__ */ new Set();
   const edgeBuilder = new EdgeBuilder();
   const anscestorOf = (id) => (e) => e.id === id || isAncestor(e.id, id);
   const sortedRelations = [...ctx.relations];
   for (const rel of sortedRelations) {
-    const source = find(allElements, anscestorOf(rel.source));
+    const source = find(leafsFirst, anscestorOf(rel.source));
     if (!source) {
       continue;
     }
-    const target = find(allElements, allPass([anscestorOf(rel.target), (e) => !isSameHierarchy(e, source)]));
+    const target = find(
+      leafsFirst,
+      allPass([anscestorOf(rel.target), (e) => !isSameHierarchy(e, source)])
+    );
     if (!target) {
       continue;
     }
@@ -58,8 +71,7 @@ export function computeElementView(view, index) {
     elementsWithRelations.add(target);
     edgeBuilder.add(source.id, target.id, rel);
   }
-  const elements = /* @__PURE__ */ new Set([...ctx.elements, ...elementsWithRelations]);
-  const nodesMap = reduceToMap(elements);
+  const nodesMap = reduceToMap(/* @__PURE__ */ new Set([...ctx.elements, ...elementsWithRelations]));
   const edges = edgeBuilder.build().map((edge) => {
     while (edge.parent) {
       if (nodesMap.has(edge.parent)) {
@@ -73,7 +85,7 @@ export function computeElementView(view, index) {
   });
   const nodes = applyViewRuleStyles(
     view.rules.filter(isViewRuleStyle),
-    sortNodes(nodesMap, edges)
+    sortNodes(keepOriginalSortFromView(nodesMap, ctx), edges)
     // map(e => nodesMap.get(e.id)!, Array.from(elements))
   );
   const autoLayoutRule = view.rules.find(isViewRuleAutoLayout);

package/dist/esm/compute-view/compute-predicates.d.ts

@@ -0,0 +1,16 @@
+import { Expr } from '../types';
+import { ComputeCtx } from './compute-ctx';
+export declare const includeElementRef: (ctx: ComputeCtx, expr: Expr.ElementRefExpr) => ComputeCtx;
+export declare const excludeElementRef: (ctx: ComputeCtx, expr: Expr.ElementRefExpr) => ComputeCtx;
+export declare const includeElementKindOrTag: (ctx: ComputeCtx, expr: Expr.ElementKindExpr | Expr.ElementTagExpr) => ComputeCtx;
+export declare const excludeElementKindOrTag: (ctx: ComputeCtx, expr: Expr.ElementKindExpr | Expr.ElementTagExpr) => ComputeCtx;
+export declare const includeWildcardRef: (ctx: ComputeCtx, _expr: Expr.WildcardExpr) => ComputeCtx;
+export declare const excludeWildcardRef: (ctx: ComputeCtx, _expr: Expr.WildcardExpr) => ComputeCtx;
+export declare const includeIncomingExpr: (ctx: ComputeCtx, expr: Expr.IncomingExpr) => ComputeCtx;
+export declare const excludeIncomingExpr: (ctx: ComputeCtx, expr: Expr.IncomingExpr) => ComputeCtx;
+export declare const includeOutgoingExpr: (ctx: ComputeCtx, expr: Expr.OutgoingExpr) => ComputeCtx;
+export declare const excludeOutgoingExpr: (ctx: ComputeCtx, expr: Expr.OutgoingExpr) => ComputeCtx;
+export declare const includeInOutExpr: (ctx: ComputeCtx, expr: Expr.InOutExpr) => ComputeCtx;
+export declare const excludeInOutExpr: (ctx: ComputeCtx, expr: Expr.InOutExpr) => ComputeCtx;
+export declare const includeRelationExpr: (ctx: ComputeCtx, expr: Expr.RelationExpr) => ComputeCtx;
+export declare const excludeRelationExpr: (ctx: ComputeCtx, expr: Expr.RelationExpr) => ComputeCtx;

package/dist/{compute-view → esm/compute-view}/compute-predicates.js

@@ -1,6 +1,6 @@
 import { anyPass, both, either, isNil, uniq } from "rambdax";
 import { Expr } from "../types/index.js";
-import { commonAncestor, isAncestor, isSameHierarchy, Relations } from "../utils/index.js";
+import { Relations, commonAncestor, isAncestor, isSameHierarchy } from "../utils/index.js";
 import { ComputeCtx } from "./compute-ctx.js";
 const { isAnyInOut, isBetween, isIncoming, isInside, isOutgoing, isAnyBetween } = Relations;
 export const includeElementRef = (ctx, expr) => {

package/dist/esm/compute-view/compute.d.ts

@@ -0,0 +1,14 @@
+import type { BaseError } from '../errors';
+import type { ModelIndex } from '../model-index';
+import { type ComputedView, type ElementView } from '../types';
+type ComputeViewResult = {
+    isSuccess: true;
+    view: ComputedView;
+} | {
+    isSuccess: false;
+    error: BaseError;
+    view: undefined;
+};
+export declare function computeView(view: ElementView, index: ModelIndex): ComputeViewResult;
+export declare function assignNavigateTo<R extends Iterable<ComputedView>>(views: R): R;
+export {};

package/dist/esm/compute-view/index.d.ts

@@ -0,0 +1,4 @@
+export * from './compute';
+export * from './resolve-extended-views';
+export * from './resolve-relative-paths';
+export * from './EdgeBuilder';

package/dist/{compute-view → esm/compute-view}/index.js

@@ -1,3 +1,4 @@
 export * from "./compute.js";
 export * from "./resolve-extended-views.js";
+export * from "./resolve-relative-paths.js";
 export * from "./EdgeBuilder.js";

package/dist/esm/compute-view/resolve-extended-views.d.ts

@@ -0,0 +1,6 @@
+import { type ElementView } from '../types';
+/**
+ * Resolve rules of extended views
+ * (Removes invalid views)
+ */
+export declare function resolveRulesExtendedViews<V extends Record<any, ElementView>>(unresolvedViews: V): V;

package/dist/{compute-view → esm/compute-view}/resolve-extended-views.js

@@ -1,7 +1,6 @@
-import pkg from "@dagrejs/graphlib";
-import { invariant, nonNullable } from "../errors/index.js";
+import graphlib from "@dagrejs/graphlib";
 import { isExtendsElementView } from "../types/index.js";
-const { Graph, alg } = pkg;
+const { Graph, alg } = graphlib;
 export function resolveRulesExtendedViews(unresolvedViews) {
   const g = new Graph({
     directed: true,
@@ -9,22 +8,26 @@ export function resolveRulesExtendedViews(unresolvedViews) {
     compound: false
   });
   for (const view of Object.values(unresolvedViews)) {
-    if (!isExtendsElementView(view)) {
-      g.setNode(view.id);
-      continue;
-    }
-    if (unresolvedViews[view.extends]) {
-      g.setEdge(view.extends, view.id);
+    g.setNode(view.id);
+    if (isExtendsElementView(view)) {
+      g.setEdge(view.id, view.extends);
     }
   }
-  if (!alg.isAcyclic(g)) {
-    alg.findCycles(g).flat().map((id) => g.removeNode(id));
+  const cycles = alg.findCycles(g);
+  if (cycles.length > 0) {
+    cycles.flat().forEach((id) => g.removeNode(id));
   }
-  return alg.topsort(g).reduce((acc, id) => {
-    const view = nonNullable(unresolvedViews[id], `Cannot find view ${id}`);
+  const ordered = alg.postorder(g, g.sources());
+  return ordered.reduce((acc, id) => {
+    const view = unresolvedViews[id];
+    if (!view) {
+      return acc;
+    }
     if (isExtendsElementView(view)) {
       const extendsFrom = acc[view.extends];
-      invariant(extendsFrom, `Cannot find base view '${view.extends}' for '${view.id}'`);
+      if (!extendsFrom) {
+        return acc;
+      }
       return Object.assign(acc, {
         [view.id]: {
           ...extendsFrom,

package/dist/esm/compute-view/resolve-relative-paths.d.ts

@@ -0,0 +1,2 @@
+import type { ElementView } from '../types';
+export declare function resolveRelativePaths(views: ElementView[]): ElementView[];

package/dist/esm/compute-view/resolve-relative-paths.js

@@ -0,0 +1,76 @@
+import { uniq, zip } from "rambdax";
+import { hasAtLeast } from "remeda";
+import { invariant } from "../errors/index.js";
+function commonAncestorPath(views, sep = "/") {
+  if (views.length <= 1)
+    return "";
+  const uniqURIs = uniq(views.flatMap(({ docUri }) => docUri ? [docUri] : []));
+  if (uniqURIs.length === 0)
+    return "";
+  if (uniqURIs.length === 1) {
+    invariant(hasAtLeast(uniqURIs, 1));
+    return new URL(uniqURIs[0]).pathname;
+  }
+  invariant(hasAtLeast(uniqURIs, 2), "Expected at least 2 unique URIs");
+  const [baseUri, ...tail] = uniqURIs;
+  const parts = new URL(baseUri).pathname.split(sep);
+  let endOfPrefix = parts.length;
+  for (const uri of tail) {
+    if (uri === baseUri) {
+      continue;
+    }
+    const compare = new URL(uri).pathname.split(sep);
+    for (let i = 0; i < endOfPrefix; i++) {
+      if (compare[i] !== parts[i]) {
+        endOfPrefix = i;
+      }
+    }
+    if (endOfPrefix === 0)
+      return "";
+  }
+  const prefix = parts.slice(0, endOfPrefix).join(sep);
+  return prefix.endsWith(sep) ? prefix : prefix + sep;
+}
+export function resolveRelativePaths(views) {
+  const commonPrefix = commonAncestorPath(views);
+  return views.map((view) => {
+    if (!view.docUri) {
+      return {
+        ...view,
+        parts: []
+      };
+    }
+    const path = new URL(view.docUri).pathname;
+    const parts = path.replace(commonPrefix, "").split("/");
+    parts.pop();
+    return {
+      ...view,
+      parts
+    };
+  }).sort((a, b) => {
+    if (a.parts.length === b.parts.length) {
+      if (a.parts.length === 0) {
+        return 0;
+      }
+      if (a.parts.length === 1 && hasAtLeast(a.parts, 1) && hasAtLeast(b.parts, 1)) {
+        return a.parts[0].localeCompare(b.parts[0]);
+      }
+      for (const [_a, _b] of zip(a.parts, b.parts)) {
+        const compare = _a.localeCompare(_b);
+        if (compare !== 0) {
+          return compare;
+        }
+      }
+      return 0;
+    }
+    return a.parts.length - b.parts.length;
+  }).map(({ parts, ...view }) => {
+    if (view.docUri) {
+      return {
+        ...view,
+        relativePath: parts.join("/")
+      };
+    }
+    return view;
+  });
+}

package/dist/esm/compute-view/utils/anyPossibleRelations.d.ts

@@ -0,0 +1,2 @@
+import type { Element } from '../../types';
+export declare function anyPossibleRelations(elements: Element[]): Generator<[source: Element, target: Element]>;

package/dist/esm/compute-view/utils/applyViewRuleStyles.d.ts

@@ -0,0 +1,2 @@
+import type { ComputedNode, ViewRuleStyle } from '../../types';
+export declare function applyViewRuleStyles(rules: ViewRuleStyle[], _nodes: ComputedNode[]): ComputedNode[];

package/dist/esm/compute-view/utils/sortNodes.d.ts

@@ -0,0 +1,19 @@
+import type { ComputedEdge, ComputedNode } from '../../types';
+export declare function sortNodes(_nodes: ComputedNode[], edges: ComputedEdge[]): {
+    children: import("../../types").Fqn[];
+    id: import("../../types").Fqn;
+    kind: import("../../types").ElementKind;
+    parent: import("../../types").Fqn | null;
+    title: string;
+    description: string | null;
+    technology: string | null;
+    tags: import("../../types").NonEmptyArray<import("../../types").Tag> | null;
+    links: import("../../types").NonEmptyArray<string> | null;
+    inEdges: import("../../types").EdgeId[];
+    outEdges: import("../../types").EdgeId[];
+    shape: import("../../types").ElementShape;
+    color: import("../../types").ThemeColor;
+    icon?: import("../../types").IconUrl | undefined;
+    navigateTo?: import("../../types").ViewID | undefined;
+    level: number;
+}[];

package/dist/esm/compute-view/utils/sortNodes.js

@@ -0,0 +1,37 @@
+import pkg from "@dagrejs/graphlib";
+const { Graph, alg } = pkg;
+function fillChildren(nodes) {
+  return nodes.map((node) => ({
+    ...node,
+    children: nodes.flatMap((n) => n.parent === node.id ? n.id : [])
+  }));
+}
+export function sortNodes(_nodes, edges) {
+  if (edges.length === 0) {
+    return fillChildren(_nodes);
+  }
+  const g = new Graph({
+    compound: true,
+    directed: true,
+    multigraph: false
+  });
+  for (const e of edges) {
+    g.setEdge(e.source, e.target);
+  }
+  for (const n of _nodes) {
+    g.setNode(n.id);
+    if (n.parent) {
+      g.setEdge(n.id, n.parent);
+    }
+  }
+  const unprocessed = [..._nodes];
+  const sorted = [];
+  const ordered = alg.postorder(g, g.sources()).reverse();
+  for (const id of ordered) {
+    const inx = unprocessed.findIndex((n) => n.id === id);
+    if (inx >= 0) {
+      sorted.push(...unprocessed.splice(inx, 1));
+    }
+  }
+  return fillChildren(sorted.concat(unprocessed));
+}

package/dist/esm/errors/index.d.ts

@@ -0,0 +1,45 @@
+import { CustomError } from 'ts-custom-error';
+export interface BaseErrorOptions {
+    cause?: unknown;
+}
+/**
+ * Base class for all errors in the LikeC4 library.
+ */
+export declare class BaseError extends CustomError {
+    constructor(message: string, options?: BaseErrorOptions);
+}
+export declare class InvalidArgError extends BaseError {
+    constructor(message: string, options?: BaseErrorOptions);
+}
+/**
+ * Unknown error, mosly probably a bug, unhandled case or coming from a third-party library.
+ */
+export declare class UnknownError extends BaseError {
+    constructor(message: string, options?: BaseErrorOptions);
+}
+export declare class NullableError extends BaseError {
+    constructor(message: string, options?: BaseErrorOptions);
+}
+export declare class InvariantError extends BaseError {
+    constructor(message: string, options?: BaseErrorOptions);
+}
+export declare function nonNullable<T>(value: T, message?: string): T & {};
+export declare class RelationRefError extends BaseError {
+    constructor(message: string, options?: BaseErrorOptions);
+}
+export declare function normalizeError(e: unknown): BaseError;
+export declare function serializeError(e: unknown): {
+    name: string;
+    message: string;
+    error: BaseError;
+};
+export declare function throwNormalizedError(e: unknown): never;
+export declare function invariant(condition: any, message?: string): asserts condition;
+export declare class NonExhaustiveError extends BaseError {
+    constructor(message: string, options?: BaseErrorOptions);
+}
+export declare function nonexhaustive(value: never): never;
+export declare class InvalidModelError extends BaseError {
+    constructor(message: string, options?: BaseErrorOptions);
+}
+export declare function ensureModel(condition: any, message?: string): asserts condition;