@likec4/core 1.32.2 → 1.34.0

package/dist/shared/{core.BuO4ncfY.d.mts → core.668kXpZq.d.mts}

@@ -1,60 +1,48 @@
-import { IsAny, UnionToIntersection, Simplify, Tagged } from 'type-fest';
+import { Tagged } from 'type-fest';
 
-type NonEmptyArray<T> = [T, ...T[]];
-type NonEmptyReadonlyArray<T> = readonly [T, ...T[]];
-type KeysOf<T> = keyof T extends infer K extends string ? K : never;
-type AllNever<Expressions> = UnionToIntersection<{
-    [Name in keyof Expressions]: {
-        -readonly [Key in keyof Expressions[Name]]?: never;
-    };
-}[keyof Expressions]>;
+type ProjectId<T = string> = Tagged<T, 'ProjectID'>;
+type MarkdownOrString = {
+    txt: string;
+    md?: never;
+} | {
+    md: string;
+    txt?: never;
+};
 /**
+ * Converts a MarkdownOrString object or a plain string into a simple string representation.
+ * This utility function handles different types of text content and normalizes them to a string format.
+ *
+ * @param value - The content to be flattened.
+ *   Can be one of:
+ *   - A plain string
+ *   - A MarkdownOrString object with either txt or md property
+ *   - undefined or null
+ *
+ * @returns The string content contained within the input value.
+ *   - Returns the input directly if it's already a string
+ *   - Returns the txt property if available in a MarkdownOrString object
+ *   - Falls back to the md property if txt is not available
+ *   - Returns null if:
+ *     - The input is null or undefined
+ *     - The resulting string value is empty, whitespace, or null
+ *
  * @example
- * ```ts
- *   type Variant1 = {
- *     a: string
- *   }
- *   type Variant2 = {
- *     b: number
- *   }
+ * // String input
+ * flattenMarkdownOrString("Hello world") // Returns: "Hello world"
+ * flattenMarkdownOrString("   ") // Returns: null
  *
- *   type Variants = ExclusiveUnion<{
- *     Variant1: Variant1,
- *     Variant2: Variant2
- *   }>
+ * // MarkdownOrString with txt property
+ * flattenMarkdownOrString({ txt: "Plain text" }) // Returns: "Plain text"
+ * flattenMarkdownOrString({ txt: "   " }) // Returns: null
  *
- *   // Fail here
- *   const variant1: Variants = {
- *      a: 'one',
- *      b: 1
- *   }
- * ```
- */
-type ExclusiveUnion<Expressions, All = AllNever<Expressions>> = Expressions extends object ? {
-    [Name in keyof Expressions]: Simplify<Omit<All, keyof Expressions[Name]> & Expressions[Name]>;
-}[keyof Expressions] : never;
-/**
- * Copy from https://github.com/remeda/remeda/blob/main/src/internal/types/NTuple.ts
- * An array with *exactly* N elements in it.
+ * // MarkdownOrString with md property
+ * flattenMarkdownOrString({ md: "**Bold markdown**" }) // Returns: "**Bold markdown**"
  *
- * Only literal N values are supported. For very large N the type might result
- * in a recurse depth error. For negative N the type would result in an infinite
- * recursion. None of these have protections because this is an internal type!
+ * // Null input
+ * flattenMarkdownOrString(null) // Returns: null
  */
-type NTuple<T, N extends number, Result extends Array<unknown> = []> = Result['length'] extends N ? Result : NTuple<T, N, [...Result, T]>;
-type IteratorLike<T> = IteratorObject<T, BuiltinIteratorReturn>;
-type Predicate<T> = (x: T) => boolean;
-interface Link {
-    title?: string;
-    url: string;
-    relative?: string;
-}
-/**
- * Coalesce `V` to a string if it is `any`
- */
-type Coalesce<V extends string, OrIfAny = string> = IsAny<V> extends true ? OrIfAny : V;
-
-type ProjectId<T = string> = Tagged<T, 'ProjectID'>;
+declare function flattenMarkdownOrString(value: MarkdownOrString | string): string;
+declare function flattenMarkdownOrString(value: MarkdownOrString | string | undefined | null): string | null;
 type BuiltInIcon = 'none' | `${'aws' | 'azure' | 'gcp' | 'tech'}:${string}`;
 type Icon = Tagged<string, 'Icon'> | BuiltInIcon;
 type IconUrl = Icon;
@@ -123,6 +111,7 @@ declare const scalar_GlobalFqn: typeof GlobalFqn;
 type scalar_GroupElementKind = GroupElementKind;
 type scalar_Icon = Icon;
 type scalar_IconUrl = IconUrl;
+type scalar_MarkdownOrString = MarkdownOrString;
 declare const scalar_NodeId: typeof NodeId;
 type scalar_ProjectId<T = string> = ProjectId<T>;
 declare const scalar_RelationId: typeof RelationId;
@@ -134,13 +123,14 @@ declare const scalar_StepEdgeKind: typeof StepEdgeKind;
 type scalar_Tag<T = string> = Tag<T>;
 declare const scalar_ViewId: typeof ViewId;
 declare const scalar_extractStep: typeof extractStep;
+declare const scalar_flattenMarkdownOrString: typeof flattenMarkdownOrString;
 declare const scalar_isGlobalFqn: typeof isGlobalFqn;
 declare const scalar_isGroupElementKind: typeof isGroupElementKind;
 declare const scalar_isStepEdgeId: typeof isStepEdgeId;
 declare const scalar_splitGlobalFqn: typeof splitGlobalFqn;
 declare const scalar_stepEdgeId: typeof stepEdgeId;
 declare namespace scalar {
-  export { type scalar_AnyFqn as AnyFqn, type scalar_BuiltInIcon as BuiltInIcon, scalar_DeploymentFqn as DeploymentFqn, type scalar_DeploymentKind as DeploymentKind, scalar_EdgeId as EdgeId, type scalar_ElementKind as ElementKind, scalar_Fqn as Fqn, scalar_GlobalFqn as GlobalFqn, type scalar_GroupElementKind as GroupElementKind, type scalar_Icon as Icon, type scalar_IconUrl as IconUrl, scalar_NodeId as NodeId, type scalar_ProjectId as ProjectId, scalar_RelationId as RelationId, type scalar_RelationKind as RelationKind, type scalar_RelationshipKind as RelationshipKind, type scalar_StepEdgeId as StepEdgeId, type scalar_StepEdgeIdLiteral as StepEdgeIdLiteral, scalar_StepEdgeKind as StepEdgeKind, type scalar_Tag as Tag, scalar_ViewId as ViewId, scalar_extractStep as extractStep, scalar_isGlobalFqn as isGlobalFqn, scalar_isGroupElementKind as isGroupElementKind, scalar_isStepEdgeId as isStepEdgeId, scalar_splitGlobalFqn as splitGlobalFqn, scalar_stepEdgeId as stepEdgeId };
+  export { type scalar_AnyFqn as AnyFqn, type scalar_BuiltInIcon as BuiltInIcon, scalar_DeploymentFqn as DeploymentFqn, type scalar_DeploymentKind as DeploymentKind, scalar_EdgeId as EdgeId, type scalar_ElementKind as ElementKind, scalar_Fqn as Fqn, scalar_GlobalFqn as GlobalFqn, type scalar_GroupElementKind as GroupElementKind, type scalar_Icon as Icon, type scalar_IconUrl as IconUrl, type scalar_MarkdownOrString as MarkdownOrString, scalar_NodeId as NodeId, type scalar_ProjectId as ProjectId, scalar_RelationId as RelationId, type scalar_RelationKind as RelationKind, type scalar_RelationshipKind as RelationshipKind, type scalar_StepEdgeId as StepEdgeId, type scalar_StepEdgeIdLiteral as StepEdgeIdLiteral, scalar_StepEdgeKind as StepEdgeKind, type scalar_Tag as Tag, scalar_ViewId as ViewId, scalar_extractStep as extractStep, scalar_flattenMarkdownOrString as flattenMarkdownOrString, scalar_isGlobalFqn as isGlobalFqn, scalar_isGroupElementKind as isGroupElementKind, scalar_isStepEdgeId as isStepEdgeId, scalar_splitGlobalFqn as splitGlobalFqn, scalar_stepEdgeId as stepEdgeId };
 }
 
-export { type AnyFqn as A, type BuiltInIcon as B, type Coalesce as C, DeploymentFqn as D, EdgeId as E, Fqn as F, GroupElementKind as G, type IteratorLike as I, type KeysOf as K, type Link as L, NodeId as N, type ProjectId as P, RelationId as R, type StepEdgeIdLiteral as S, type Tag as T, ViewId as V, type ElementKind as a, type DeploymentKind as b, type RelationshipKind as c, type NonEmptyArray as d, type NonEmptyReadonlyArray as e, type ExclusiveUnion as f, type NTuple as g, type Predicate as h, type Icon as i, type IconUrl as j, isGroupElementKind as k, type RelationKind as l, GlobalFqn as m, isGlobalFqn as n, splitGlobalFqn as o, type StepEdgeId as p, stepEdgeId as q, StepEdgeKind as r, scalar as s, isStepEdgeId as t, extractStep as u };
+export { type AnyFqn as A, type BuiltInIcon as B, DeploymentFqn as D, type ElementKind as E, Fqn as F, GroupElementKind as G, type Icon as I, type MarkdownOrString as M, NodeId as N, type ProjectId as P, type RelationKind as R, type StepEdgeIdLiteral as S, type Tag as T, ViewId as V, type IconUrl as a, type DeploymentKind as b, type RelationshipKind as c, RelationId as d, GlobalFqn as e, flattenMarkdownOrString as f, isGlobalFqn as g, splitGlobalFqn as h, isGroupElementKind as i, EdgeId as j, type StepEdgeId as k, stepEdgeId as l, StepEdgeKind as m, isStepEdgeId as n, extractStep as o, scalar as s };

package/dist/shared/core.8KM0D6va.mjs

@@ -0,0 +1,33 @@
+function n(e){return e!==void 0}
+
+function l(n){return n!=null}
+
+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;
+}
+
+export { isIterable as a, iunique as b, iflat as i, l, n };

package/dist/shared/core.B0oEIXqd.mjs

@@ -0,0 +1,47 @@
+import rehypeRaw from 'rehype-raw';
+import rehypeSanitize from 'rehype-sanitize';
+import rehypeStringify from 'rehype-stringify';
+import remarkGfm from 'remark-gfm';
+import remarkParse from 'remark-parse';
+import remarkRehype from 'remark-rehype';
+import { unified } from 'unified';
+import { fromMarkdown } from 'mdast-util-from-markdown';
+import { toString } from 'mdast-util-to-string';
+
+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 remark() {
+  return unified().use(remarkParse).use(remarkGfm).use(remarkRehype, {
+    // Tight paragraphs prevent extra newlines
+    allowDangerousHtml: true,
+    clobberPrefix: "",
+    tableCellPadding: false,
+    tight: true
+  }).use(rehypeRaw).use(rehypeSanitize).use(rehypeStringify, {
+    // Prevent extra closing newlines
+    closeSelfClosing: true,
+    tightSelfClosing: true
+  });
+}
+function markdownToHtml(markdown) {
+  return String(remark().processSync(markdown.trim())).trim();
+}
+
+function markdownToText(markdown) {
+  return toString(fromMarkdown(markdown), {
+    includeHtml: false,
+    includeImageAlt: false
+  });
+}
+
+export { markdownToHtml as a, markdownToText as b, memoizeProp as m };

package/dist/shared/core.BH9nN-_I.mjs

@@ -0,0 +1,22 @@
+import { i as invariant } from './core.D4npX2q8.mjs';
+
+function t(n){return typeof n=="function"}
+
+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 { ifilter as i, t };

package/dist/shared/core.BMCb0wJI.mjs

@@ -0,0 +1,177 @@
+import { r as getDefaultExportFromCjs } from './core.C_C-3c1S.mjs';
+
+/**
+ * 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);
+
+export { DefaultMap as D };