@likec4/core 1.32.2 → 1.34.0

package/dist/shared/{core.rmvsy0n3.mjs → core.C_C-3c1S.mjs}

@@ -1,189 +1,13 @@
-import { t as t$1, i as invariant } from './core.Cy9smucx.mjs';
+import { t } from './core.zLlww-07.mjs';
 
 var e={done:true,hasNext:false},s={done:false,hasNext:false},a=()=>e;
 
 function C(t,...o){let n=t,u=o.map(e=>"lazy"in e?y(e):void 0),p=0;for(;p<o.length;){if(u[p]===void 0||!B(n)){let i=o[p];n=i(n),p+=1;continue}let r=[];for(let i=p;i<o.length;i++){let l=u[i];if(l===void 0||(r.push(l),l.isSingle))break}let a=[];for(let i of n)if(f(i,a,r))break;let{isSingle:s}=r.at(-1);n=s?a[0]:a,p+=r.length;}return n}function f(t,o,n){if(n.length===0)return o.push(t),false;let u=t,p=s,e=false;for(let[r,a]of n.entries()){let{index:s,items:i}=a;if(i.push(u),p=a(u,s,i),a.index+=1,p.hasNext){if(p.hasMany??false){for(let l of p.next)if(f(l,o,n.slice(r+1)))return  true;return e}u=p.next;}if(!p.hasNext)break;p.done&&(e=true);}return p.hasNext&&o.push(u),e}function y(t){let{lazy:o,lazyArgs:n}=t,u=o(...n);return Object.assign(u,{isSingle:o.single??false,index:0,items:[]})}function B(t){return typeof t=="string"||typeof t=="object"&&t!==null&&Symbol.iterator in t}
 
-function t(n){return typeof n=="function"}
-
 function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
 
-/**
- * Mnemonist DefaultMap
- * =====================
- *
- * JavaScript implementation of a default map that will return a constructed
- * value any time one tries to access an inexisting key. It's quite similar
- * to python's defaultdict.
- */
-
-var defaultMap;
-var hasRequiredDefaultMap;
-
-function requireDefaultMap () {
-	if (hasRequiredDefaultMap) return defaultMap;
-	hasRequiredDefaultMap = 1;
-	/**
-	 * DefaultMap.
-	 *
-	 * @constructor
-	 */
-	function DefaultMap(factory) {
-	  if (typeof factory !== 'function')
-	    throw new Error('mnemonist/DefaultMap.constructor: expecting a function.');
-
-	  this.items = new Map();
-	  this.factory = factory;
-	  this.size = 0;
-	}
-
-	/**
-	 * Method used to clear the structure.
-	 *
-	 * @return {undefined}
-	 */
-	DefaultMap.prototype.clear = function() {
-
-	  // Properties
-	  this.items.clear();
-	  this.size = 0;
-	};
-
-	/**
-	 * Method used to get the value set for given key. If the key does not exist,
-	 * the value will be created using the provided factory.
-	 *
-	 * @param  {any} key - Target key.
-	 * @return {any}
-	 */
-	DefaultMap.prototype.get = function(key) {
-	  var value = this.items.get(key);
-
-	  if (typeof value === 'undefined') {
-	    value = this.factory(key, this.size);
-	    this.items.set(key, value);
-	    this.size++;
-	  }
-
-	  return value;
-	};
-
-	/**
-	 * Method used to get the value set for given key. If the key does not exist,
-	 * a value won't be created.
-	 *
-	 * @param  {any} key - Target key.
-	 * @return {any}
-	 */
-	DefaultMap.prototype.peek = function(key) {
-	  return this.items.get(key);
-	};
-
-	/**
-	 * Method used to set a value for given key.
-	 *
-	 * @param  {any} key   - Target key.
-	 * @param  {any} value - Value.
-	 * @return {DefaultMap}
-	 */
-	DefaultMap.prototype.set = function(key, value) {
-	  this.items.set(key, value);
-	  this.size = this.items.size;
-
-	  return this;
-	};
-
-	/**
-	 * Method used to test the existence of a key in the map.
-	 *
-	 * @param  {any} key   - Target key.
-	 * @return {boolean}
-	 */
-	DefaultMap.prototype.has = function(key) {
-	  return this.items.has(key);
-	};
-
-	/**
-	 * Method used to delete target key.
-	 *
-	 * @param  {any} key   - Target key.
-	 * @return {boolean}
-	 */
-	DefaultMap.prototype.delete = function(key) {
-	  var deleted = this.items.delete(key);
-
-	  this.size = this.items.size;
-
-	  return deleted;
-	};
-
-	/**
-	 * Method used to iterate over each of the key/value pairs.
-	 *
-	 * @param  {function}  callback - Function to call for each item.
-	 * @param  {object}    scope    - Optional scope.
-	 * @return {undefined}
-	 */
-	DefaultMap.prototype.forEach = function(callback, scope) {
-	  scope = arguments.length > 1 ? scope : this;
-
-	  this.items.forEach(callback, scope);
-	};
-
-	/**
-	 * Iterators.
-	 */
-	DefaultMap.prototype.entries = function() {
-	  return this.items.entries();
-	};
-
-	DefaultMap.prototype.keys = function() {
-	  return this.items.keys();
-	};
-
-	DefaultMap.prototype.values = function() {
-	  return this.items.values();
-	};
-
-	/**
-	 * Attaching the #.entries method to Symbol.iterator if possible.
-	 */
-	if (typeof Symbol !== 'undefined')
-	  DefaultMap.prototype[Symbol.iterator] = DefaultMap.prototype.entries;
-
-	/**
-	 * Convenience known methods.
-	 */
-	DefaultMap.prototype.inspect = function() {
-	  return this.items;
-	};
-
-	if (typeof Symbol !== 'undefined')
-	  DefaultMap.prototype[Symbol.for('nodejs.util.inspect.custom')] = DefaultMap.prototype.inspect;
-
-	/**
-	 * Typical factories.
-	 */
-	DefaultMap.autoIncrement = function() {
-	  var i = 0;
-
-	  return function() {
-	    return i++;
-	  };
-	};
-
-	/**
-	 * Exporting.
-	 */
-	defaultMap = DefaultMap;
-	return defaultMap;
-}
-
-var defaultMapExports = /*@__PURE__*/ requireDefaultMap();
-const DefaultMap = /*@__PURE__*/getDefaultExportFromCjs(defaultMapExports);
-
 var naturalCompareLite = {exports: {}};
 
 var hasRequiredNaturalCompareLite;
@@ -253,13 +77,13 @@ const compare = /*@__PURE__*/getDefaultExportFromCjs(naturalCompareLiteExports);
 
 function compareNatural(a, b) {
   if (a === b) return 0;
-  if (t$1(a)) {
-    if (t$1(b)) {
+  if (t(a)) {
+    if (t(b)) {
       return compare(a, b);
     }
     return 1;
   }
-  return t$1(b) ? -1 : 0;
+  return t(b) ? -1 : 0;
 }
 function compareNaturalHierarchically(separator = ".") {
   return (a, b) => {
@@ -448,21 +272,4 @@ function sortNaturalByFqn(array, sort) {
   }).map(({ item }) => item);
 }
 
-function ifilter(arg1, arg2) {
-  const pred = arg2 ?? arg1;
-  invariant(t(pred));
-  function* _filter(iter) {
-    for (const value of iter) {
-      if (pred(value)) {
-        yield value;
-      }
-    }
-    return;
-  }
-  if (!arg2) {
-    return _filter;
-  }
-  return _filter(arg1);
-}
-
-export { C, DefaultMap as D, isAncestor as a, ifilter as b, isNonEmptyArray as c, isSameHierarchy as d, a as e, s as f, getDefaultExportFromCjs as g, compareByFqnHierarchically as h, isDescendantOf as i, sortByFqnHierarchically as j, commonAncestor as k, ancestorsFqn as l, compareNatural as m, nameFromFqn as n, compareNaturalHierarchically as o, parentFqn as p, compareFqnHierarchically as q, hierarchyDistance as r, sortParentsFirst as s, t, hierarchyLevel as u, sortNaturalByFqn as v, isString as w };
+export { C, compareNaturalHierarchically as a, ancestorsFqn as b, compareNatural as c, commonAncestor as d, compareByFqnHierarchically as e, compareFqnHierarchically as f, hierarchyLevel as g, hierarchyDistance as h, isAncestor as i, isDescendantOf as j, isSameHierarchy as k, sortNaturalByFqn as l, sortParentsFirst as m, nameFromFqn as n, isNonEmptyArray as o, parentFqn as p, isString as q, getDefaultExportFromCjs as r, sortByFqnHierarchically as s, s as t, a as u };

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.D3xEWj5B.d.mts

@@ -0,0 +1,41 @@
+import { E as ElementModel, e as DeploymentElementModel } from './core.DrS4Bf4y.mjs';
+import { A as Any } from './core.DAj3LuFH.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.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 };