@likec4/core 1.32.1 → 1.33.0

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

@@ -0,0 +1,41 @@
+import { E as ElementModel, e as DeploymentElementModel } from './core.OLInHaJx.mjs';
+import { A as Any } from './core.De___iBS.mjs';
+import { F as Fqn } from './core.668kXpZq.mjs';
+
+interface Connection<Elem = ElementModel<Any> | DeploymentElementModel<Any>, Id = string> {
+    readonly id: Id;
+    readonly source: Elem;
+    readonly target: Elem;
+    /**
+     * Common ancestor of the source and target elements.
+     * Represents the boundary of the connection.
+     */
+    readonly boundary: Elem | null;
+    /**
+     * Human readable expression of the connection
+     * Mostly used for testing and debugging
+     */
+    readonly expression: string;
+    mergeWith(this: Connection<Elem, Id>, other: typeof this): typeof this;
+    nonEmpty(): boolean;
+    difference(this: Connection<Elem, Id>, other: typeof this): typeof this;
+    intersect(this: Connection<Elem, Id>, other: typeof this): typeof this;
+    equals(other: Connection): boolean;
+}
+declare namespace Connection {
+    type ConnectionPredicate = <C extends Connection<{
+        id: string;
+    }, any>>(connection: C) => boolean;
+    type ElementId = Fqn | string;
+    export const isInside: (fqn: ElementId) => ConnectionPredicate;
+    export const isDirectedBetween: (source: ElementId, target: ElementId) => ConnectionPredicate;
+    export const isAnyBetween: (source: ElementId, target: ElementId) => ConnectionPredicate;
+    export const isIncoming: (target: ElementId) => ConnectionPredicate;
+    export const isOutgoing: (source: ElementId) => ConnectionPredicate;
+    export const isAnyInOut: (source: ElementId) => ConnectionPredicate;
+    export {  };
+}
+
+declare const customInspectSymbol: unique symbol;
+
+export { Connection as C, customInspectSymbol as c };

package/dist/shared/{core.DoK86JEe.mjs → core.CpwrZi3D.mjs}

@@ -1,11 +1,8 @@
 import { u } from './core.DbRvwARP.mjs';
-import { t } from './core.rmvsy0n3.mjs';
-import { i as invariant } from './core.Cy9smucx.mjs';
+import { i as invariant } from './core.D4npX2q8.mjs';
 
 function i(...e){return u(n,e)}var n=(e,r)=>e.length>=r;
 
-function m(...a){return u(o,a,p)}var o=(a,e)=>a.map(e),p=a=>(e,t,r)=>({done:false,hasNext:true,next:a(e,t,r)});
-
 var set = {};
 
 /**
@@ -376,74 +373,6 @@ function requireSet () {
 
 var setExports = /*@__PURE__*/ requireSet();
 
-function getOrCreate(map, key, create) {
-  let entry = map.get(key);
-  if (!entry) {
-    entry = create(key);
-    map.set(key, entry);
-  }
-  return entry;
-}
-
-function ifind(arg1, arg2) {
-  const pred = arg2 ?? arg1;
-  invariant(t(pred));
-  function _find(iter) {
-    for (const value of iter) {
-      if (pred(value)) {
-        return value;
-      }
-    }
-    return;
-  }
-  if (!arg2) {
-    return _find;
-  }
-  return _find(arg1);
-}
-
-function ihead(iterable) {
-  if (!iterable) {
-    return _head;
-  }
-  return _head(iterable);
-}
-function _head(iter) {
-  for (const value of iter) {
-    return value;
-  }
-  return;
-}
-
-function isome(arg1, arg2) {
-  const pred = arg2 ?? arg1;
-  invariant(t(pred));
-  function _some(iter) {
-    for (const value of iter) {
-      if (pred(value)) {
-        return true;
-      }
-    }
-    return false;
-  }
-  if (!arg2) {
-    return _some;
-  }
-  return _some(arg1);
-}
-
-function memoizeProp(obj, tag, fn) {
-  const tagSymbol = typeof tag === "symbol" ? tag : Symbol.for(tag);
-  if (!obj.hasOwnProperty(tagSymbol)) {
-    Object.defineProperty(obj, tagSymbol, {
-      enumerable: false,
-      writable: false,
-      value: fn()
-    });
-  }
-  return obj[tagSymbol];
-}
-
 function union(...sets) {
   let result = /* @__PURE__ */ new Set();
   for (const set of sets) {
@@ -515,4 +444,4 @@ function stringHash(str) {
   return (hash >>> 0).toString(36);
 }
 
-export { intersection as a, isome as b, ifind as c, difference as d, ihead as e, memoizeProp as f, getOrCreate as g, hasIntersection as h, i, equals as j, stringHash as k, m, symmetricDifference as s, union as u };
+export { intersection as a, stringHash as b, difference as d, equals as e, hasIntersection as h, i, symmetricDifference as s, union as u };

package/dist/shared/{core.CpXlRyE5.mjs → core.CtKXPqN_.mjs}

@@ -1,16 +1,13 @@
-import { g as getDefaultExportFromCjs, C } from './core.rmvsy0n3.mjs';
+import { r as getDefaultExportFromCjs, C } from './core.C_C-3c1S.mjs';
 import { u as u$1 } from './core.DbRvwARP.mjs';
-import { m } from './core.DoK86JEe.mjs';
-import { i as invariant } from './core.Cy9smucx.mjs';
+import { m } from './core.ByrmCl9I.mjs';
+import { l } from './core.8KM0D6va.mjs';
+import { i as invariant } from './core.D4npX2q8.mjs';
 
 function d(...e){return u$1(i,e,o$1)}var i=(e,n)=>e.length<n.length?e.map((t,r)=>[t,n[r]]):n.map((t,r)=>[e[r],t]),o$1=e=>(n,t)=>({hasNext:true,next:[n,e[t]],done:t>=e.length-1});
 
 function u(...e){return u$1(o,e)}function o(e,a){let n=[];for(let[i,r]of e.entries()){if(!a(r,i,e))break;n.push(r);}return n}
 
-function n(e){return e!==void 0}
-
-function l(n){return n!=null}
-
 var support = {};
 
 var hasRequiredSupport;
@@ -446,34 +443,6 @@ function commonHead(sources, targets, equals) {
   );
 }
 
-function isIterable(something) {
-  return l(something) && typeof something === "object" && Symbol.iterator in something;
-}
-
-function iflat(iterable) {
-  return iterable ? _iflat(iterable) : _iflat;
-}
-function* _iflat(iterable) {
-  for (const inner of iterable) {
-    yield* inner;
-  }
-  return;
-}
-
-function iunique(iterable) {
-  return iterable ? _iunique(iterable) : _iunique;
-}
-function* _iunique(iterable) {
-  const seen = /* @__PURE__ */ new Set();
-  for (const item of iterable) {
-    if (!seen.has(item)) {
-      seen.add(item);
-      yield item;
-    }
-  }
-  return;
-}
-
 function commonjsRequire(path) {
 	throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
 }
@@ -505,4 +474,4 @@ function objectHash(value) {
   });
 }
 
-export { Stack as S, requireIterator as a, iunique as b, commonHead as c, d, iflat as e, isIterable as i, l, n, objectHash as o, requireForeach as r, u };
+export { Stack as S, requireIterator as a, commonHead as c, d, objectHash as o, requireForeach as r, u };

package/dist/shared/core.CxGKeL-L.mjs

@@ -0,0 +1,144 @@
+import { i as invariant } from './core.D4npX2q8.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",
+  "gray",
+  "slate",
+  "green",
+  "indigo",
+  "muted",
+  "primary",
+  "red",
+  "secondary",
+  "sky"
+];
+function isThemeColor(color) {
+  return ThemeColors.includes(color);
+}
+
+export { BBox as B, ElementShapes as E, RectBox as R, ThemeColors as T, BorderStyles as a, isThemeColor as b, isTagColorSpecified as i };

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

@@ -0,0 +1,69 @@
+import { TupleToUnion, Tagged } from 'type-fest';
+
+/**
+ * For padding, margin, etc.
+ */
+type SpacingSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+type TextSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+type ShapeSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+declare const BorderStyles: readonly ["solid", "dashed", "dotted", "none"];
+type BorderStyle = TupleToUnion<typeof BorderStyles>;
+declare const ElementShapes: readonly ["rectangle", "person", "browser", "mobile", "cylinder", "storage", "queue"];
+type ElementShape = TupleToUnion<typeof ElementShapes>;
+type HexColor = `#${string}`;
+type ColorLiteral = HexColor | `rgb(${number},${number},${number})` | `rgba(${number},${number},${number},${number})`;
+type CustomColor<T = string> = Tagged<T, 'CustomColor'>;
+type CustomColorDefinitions = {
+    [key: string]: ThemeColorValues;
+};
+type RelationshipLineType = 'dashed' | 'solid' | 'dotted';
+type RelationshipArrowType = 'none' | 'normal' | 'onormal' | 'dot' | 'odot' | 'diamond' | 'odiamond' | 'crow' | 'open' | 'vee';
+declare const ThemeColors: readonly ["amber", "blue", "gray", "slate", "green", "indigo", "muted", "primary", "red", "secondary", "sky"];
+type ThemeColor = typeof ThemeColors[number];
+/**
+ * Backward compatibility alias
+ * @deprecated Use {@link ThemeColor} instead
+ */
+type Color = ThemeColor | ColorLiteral;
+declare function isThemeColor(color: string): color is ThemeColor;
+interface ElementThemeColorValues {
+    fill: ColorLiteral;
+    stroke: ColorLiteral;
+    hiContrast: ColorLiteral;
+    loContrast: ColorLiteral;
+}
+type ElementThemeColors = {
+    [key in ThemeColor]: ElementThemeColorValues;
+};
+interface RelationshipThemeColorValues {
+    lineColor: ColorLiteral;
+    labelBgColor: ColorLiteral;
+    labelColor: ColorLiteral;
+}
+interface ThemeColorValues {
+    elements: ElementThemeColorValues;
+    relationships: RelationshipThemeColorValues;
+}
+type RelationshipThemeColors = {
+    [key in ThemeColor]: RelationshipThemeColorValues;
+};
+interface LikeC4Theme {
+    font: 'Arial';
+    shadow: ColorLiteral;
+    relationships: RelationshipThemeColors;
+    elements: ElementThemeColors;
+    sizes: {
+        [key in ShapeSize]: {
+            width: number;
+            height: number;
+        };
+    };
+    spacing: {
+        [key in SpacingSize]: number;
+    };
+    textSizes: {
+        [key in TextSize]: number;
+    };
+}
+
+export { BorderStyles as B, type ColorLiteral as C, ElementShapes as E, type HexColor as H, type LikeC4Theme as L, type RelationshipLineType as R, type SpacingSize as S, type TextSize as T, type ShapeSize as a, type BorderStyle as b, type ElementShape as c, type CustomColor as d, type CustomColorDefinitions as e, type RelationshipArrowType as f, ThemeColors as g, type ThemeColor as h, type Color as i, isThemeColor as j, type ElementThemeColorValues as k, type ElementThemeColors as l, type RelationshipThemeColorValues as m, type ThemeColorValues as n, type RelationshipThemeColors as o };

package/dist/shared/{core.Cy9smucx.mjs → core.D4npX2q8.mjs}

@@ -1,5 +1,3 @@
-function t(r){return typeof r=="string"}
-
 function nonNullable(value, message) {
   if (typeof value === "undefined" || value == null) {
     const msg = typeof message === "function" ? message() : message;
@@ -17,4 +15,4 @@ function nonexhaustive(value) {
   throw new Error(`NonExhaustive value: ${value}`);
 }
 
-export { nonexhaustive as a, invariant as i, nonNullable as n, t };
+export { nonNullable as a, invariant as i, nonexhaustive as n };

package/dist/shared/core.D56nCp7e.mjs

@@ -0,0 +1,168 @@
+import { m as memoizeProp, b as markdownToText, a as markdownToHtml } from './core.B0oEIXqd.mjs';
+import { n as nonexhaustive } from './core.D4npX2q8.mjs';
+
+function n(e){return !!e}
+
+const DefaultThemeColor = "primary";
+const DefaultElementShape = "rectangle";
+const DefaultShapeSize = "md";
+const DefaultPaddingSize = "md";
+const DefaultTextSize = "md";
+const DefaultLineStyle = "dashed";
+const DefaultArrowType = "normal";
+const DefaultRelationshipColor = "gray";
+
+const richtxt = Symbol.for("richtxt");
+const symb_text = Symbol.for("text");
+const symb_html = Symbol.for("html");
+const emptyTxt = "";
+class RichText {
+  static _cache = /* @__PURE__ */ new WeakMap();
+  /**
+   * Creates and memoizes a RichText instance.
+   * @see ElementModel.description
+   * @example
+   *
+   *  get description(): RichTextOrEmpty {
+   *    return RichText.memoize(this, this.$element.description)
+   *  }
+   */
+  static memoize(obj, source) {
+    return memoizeProp(obj, richtxt, () => RichText.from(source));
+  }
+  /**
+   * Creates a RichText instance from a source.
+   */
+  static from(source) {
+    if (source === null || source === void 0 || source === RichText.EMPTY) {
+      return RichText.EMPTY;
+    }
+    if (source instanceof RichText) {
+      return source;
+    }
+    if (typeof source === "string") {
+      return RichText.from({ txt: source });
+    }
+    if ("isEmpty" in source && source.isEmpty) {
+      return RichText.EMPTY;
+    }
+    if ("md" in source && source.md.trim() === emptyTxt) {
+      return RichText.EMPTY;
+    }
+    if ("txt" in source && source.txt.trim() === emptyTxt) {
+      return RichText.EMPTY;
+    }
+    const _source = source;
+    const cached = RichText._cache.get(_source);
+    if (cached) {
+      return cached;
+    }
+    const rt = new RichText(_source);
+    RichText._cache.set(_source, rt);
+    return rt;
+  }
+  /**
+   * This is a workaround for the fact that we need instance of RichText for `instanceof` checks
+   * It is invalid inheritance (returning `null` from getters), and we cast to @see RichTextEmpty
+   */
+  static EMPTY = new class extends RichText {
+    isEmpty = true;
+    nonEmpty = false;
+    isMarkdown = false;
+    $source = null;
+    constructor() {
+      super({ txt: emptyTxt });
+    }
+    get text() {
+      return null;
+    }
+    get md() {
+      return null;
+    }
+    get html() {
+      return null;
+    }
+  }();
+  $source;
+  isEmpty;
+  nonEmpty;
+  isMarkdown;
+  /**
+   * Private constructor to prevent direct instantiation.
+   * Use {@link RichText.from} or {@link RichText.memoize} instead.
+   */
+  constructor(source) {
+    this.isMarkdown = false;
+    if (typeof source === "string") {
+      this.$source = { txt: source };
+      this.isEmpty = source.trim() === emptyTxt;
+    } else {
+      this.$source = source;
+      this.isEmpty = true;
+      if ("md" in source) {
+        this.isEmpty = source.md === emptyTxt;
+        this.isMarkdown = true;
+      } else {
+        this.isEmpty = source.txt === emptyTxt;
+      }
+    }
+    this.nonEmpty = !this.isEmpty;
+  }
+  /**
+   * Returns the text content of the rich text.
+   * If the source is a string, it returns the string.
+   * If the source is a markdown, it returns the markdown.
+   */
+  get text() {
+    if (this.isEmpty || this.$source === null) {
+      return emptyTxt;
+    }
+    const source = this.$source;
+    if ("txt" in source) {
+      return source.txt;
+    }
+    return memoizeProp(this, symb_text, () => markdownToText(source.md));
+  }
+  /**
+   * Returns the markdown content of the rich text.
+   * If the source is a string, it returns the string.
+   * If the source is a markdown, it returns the markdown.
+   */
+  get md() {
+    if (this.isEmpty || this.$source === null) {
+      return emptyTxt;
+    }
+    const source = this.$source;
+    if ("md" in source) {
+      return source.md;
+    }
+    if ("txt" in source) {
+      return source.txt;
+    }
+    nonexhaustive(source);
+  }
+  /**
+   * Returns the html content of the rich text.
+   * If the source is a string, it returns the string.
+   * If the source is a markdown, it returns the HTML.
+   */
+  get html() {
+    if (this.isEmpty || this.$source === null) {
+      return emptyTxt;
+    }
+    const markdown = this.$source.md ?? this.$source.txt;
+    return memoizeProp(this, symb_html, () => markdownToHtml(markdown));
+  }
+  equals(other) {
+    if (this === other) return true;
+    if (!(other instanceof RichText)) return false;
+    if (this.isEmpty && other.isEmpty) return true;
+    if (this.isEmpty !== other.isEmpty || this.isMarkdown !== other.isMarkdown) return false;
+    if (this.isMarkdown) {
+      return this.$source?.md === other.$source?.md;
+    }
+    return this.$source?.txt === other.$source?.txt;
+  }
+}
+
+export { DefaultThemeColor as D, RichText as R, DefaultElementShape as a, DefaultShapeSize as b, DefaultPaddingSize as c, DefaultTextSize as d, DefaultLineStyle as e, DefaultArrowType as f, DefaultRelationshipColor as g, n };