@likec4/core 1.47.0 → 1.48.0

package/dist/_chunks/utils.mjs

@@ -0,0 +1,483 @@
+import { r as __toESM } from "./rolldown-runtime.mjs";
+import { N as e$2, O as e, Q as t, Z as t$4, a as t$2, f as e$1, t as t$1, w as t$3 } from "./libs/remeda.mjs";
+import { t as require_natural_compare_lite } from "./libs/natural-compare-lite.mjs";
+import { t as invariant } from "./invariant.mjs";
+import { c as import_set } from "./libs/mnemonist.mjs";
+import { t as defu } from "./libs/defu.mjs";
+import { n as defaultSchema } from "./libs/hast-util-sanitize.mjs";
+import { t as rehypeSanitize } from "./libs/rehype-sanitize.mjs";
+import { t as rehypeStringify } from "./libs/rehype-stringify.mjs";
+import { c as toString, t as fromMarkdown } from "./libs/mdast-util-from-markdown.mjs";
+import { t as remarkGfm } from "./libs/remark-gfm.mjs";
+import { t as remarkAlert } from "./libs/remark-github-blockquote-alert.mjs";
+import { t as remarkParse } from "./libs/remark-parse.mjs";
+import { t as remarkRehype } from "./libs/remark-rehype.mjs";
+import { t as unified } from "./libs/unified.mjs";
+import { hash } from "ohash";
+
+//#region src/utils/compare-natural.ts
+var import_natural_compare_lite = /* @__PURE__ */ __toESM(require_natural_compare_lite(), 1);
+function compareNatural(a, b) {
+	if (a === b) return 0;
+	if (e(a)) {
+		if (e(b)) return (0, import_natural_compare_lite.default)(a, b);
+		return 1;
+	}
+	return e(b) ? -1 : 0;
+}
+/**
+* Compares two strings lexicographically first, then hierarchically based on their depth.\
+* From parent nodes to leaves
+*
+* @example
+* const lines = [
+*   'b.c',
+*   'b',
+*   'a.b.c',
+* ]
+* lines.sort(compareNaturalHierarchically('.'))
+* // [
+* //   'a.b.c',
+* //   'b',
+* //   'b.c',
+* // ]
+*/
+function compareNaturalHierarchically(separator = ".", deepestFirst = false) {
+	return (a, b) => {
+		if (a === b) return 0;
+		if (!a) return -1;
+		if (!b) return 1;
+		const aParts = a.split(separator);
+		const bParts = b.split(separator);
+		const minLength = Math.min(aParts.length, bParts.length);
+		for (let i = 0; i < minLength; i++) {
+			const aPart = aParts[i];
+			const bPart = bParts[i];
+			const comparison = (0, import_natural_compare_lite.default)(aPart, bPart);
+			if (comparison !== 0) return comparison;
+		}
+		const diff = aParts.length - bParts.length;
+		return deepestFirst ? -1 * diff : diff;
+	};
+}
+
+//#endregion
+//#region src/utils/common-head.ts
+/**
+* Common head of two arrays
+*
+* @param equals - Equality function, defaults to `Object.is`
+*/
+function commonHead(sources, targets, equals) {
+	if (sources.length === 0 || targets.length === 0) return [];
+	equals ??= Object.is;
+	return t(t$1(sources, targets), t$2(([source, target]) => equals(source, target)), t$3(([source, _]) => source));
+}
+
+//#endregion
+//#region src/utils/guards.ts
+function isString(value) {
+	return value != null && typeof value === "string";
+}
+function isNonEmptyArray(arr) {
+	return !!arr && Array.isArray(arr) && arr.length > 0;
+}
+function hasProp(value, path) {
+	return value[path] != null;
+}
+/**
+* Creates a type guard that checks if a value matches any of the provided predicates.
+*
+* @template Predicates - A non-empty array of guard functions
+* @param predicates - The guard functions to test against
+* @returns A type guard function that returns true if the value matches any of the predicates
+*
+* @example
+* ```typescript
+* const isStringOrNumber = isAnyOf(isString, isNumber);
+*
+* if (isStringOrNumber(value)) {
+*   // value is now typed as string | number
+*   console.log(value);
+* }
+* ```
+*/
+function isAnyOf(...predicates) {
+	return (value) => {
+		return predicates.some((predicate) => predicate(value));
+	};
+}
+
+//#endregion
+//#region src/utils/fqn.ts
+function parentFqn(fqn) {
+	const lastDot = fqn.lastIndexOf(".");
+	if (lastDot > 0) return fqn.slice(0, lastDot);
+	return null;
+}
+function nameFromFqn(fqn) {
+	const lastDot = fqn.lastIndexOf(".");
+	if (lastDot > 0) return fqn.slice(lastDot + 1);
+	else return fqn;
+}
+const asString = (e) => isString(e) ? e : e.id;
+function isAncestor(arg1, arg2) {
+	const arg1Id = asString(arg1);
+	if (arg2) return asString(arg2).startsWith(arg1Id + ".");
+	return (ancestor) => {
+		const ancestorId = asString(ancestor);
+		return arg1Id.startsWith(ancestorId + ".");
+	};
+}
+function isSameHierarchy(one, another) {
+	if (!another) return (b) => isSameHierarchy(one, b);
+	const first = asString(one);
+	const second = asString(another);
+	return first === second || second.startsWith(first + ".") || first.startsWith(second + ".");
+}
+function isDescendantOf(descedant, ancestor) {
+	if (!ancestor) return (d) => isAncestor(descedant, d);
+	return isAncestor(ancestor, descedant);
+}
+/**
+* How deep in the hierarchy the element is.
+* Root element has depth 1
+*/
+function hierarchyLevel(elementOfFqn) {
+	return (isString(elementOfFqn) ? elementOfFqn : elementOfFqn.id).split(".").length;
+}
+/**
+* Calculate the distance as number of steps from one element to another, i.e.
+* going up to the common ancestor, then going down to the other element.
+* Sibling distance is always 1
+*
+* Can be used for hierarchical clustering
+*/
+function hierarchyDistance(one, another) {
+	const first = isString(one) ? one : one.id;
+	const second = isString(another) ? another : another.id;
+	if (first === second) return 0;
+	const firstDepth = hierarchyLevel(first);
+	const secondDepth = hierarchyLevel(second);
+	if (isSameHierarchy(first, second)) return Math.abs(firstDepth - secondDepth);
+	const ancestor = commonAncestor(first, second);
+	const ancestorDepth = ancestor ? hierarchyLevel(ancestor) : 0;
+	return firstDepth + secondDepth - (2 * ancestorDepth + 1);
+}
+function commonAncestor(first, second) {
+	const a = first.split(".");
+	if (a.length < 2) return null;
+	const b = second.split(".");
+	if (b.length < 2) return null;
+	let ancestor = [];
+	for (let i = 0; i < Math.min(a.length, b.length) - 1 && a[i] === b[i]; i++) ancestor.push(a[i]);
+	if (ancestor.length === 0) return null;
+	return ancestor.join(".");
+}
+/**
+* Get all ancestor elements (i.e. parent, parent’s parent, etc.)
+* going up from parent to the root
+*/
+function ancestorsFqn(fqn) {
+	const path = fqn.split(".");
+	path.pop();
+	if (path.length === 0) return [];
+	return path.reduce((acc, part, idx) => {
+		if (idx === 0) {
+			acc.push(part);
+			return acc;
+		}
+		acc.unshift(`${acc[0]}.${part}`);
+		return acc;
+	}, []);
+}
+/**
+* Compares two fully qualified names (fqns) hierarchically based on their depth.
+* From parent nodes to leaves
+*
+* @param {string} a - The first fqn to compare.
+* @param {string} b - The second fqn to compare.
+* @returns {number} - 0 if the fqns have the same depth.
+*                    - Positive number if a is deeper than b.
+*                    - Negative number if b is deeper than a.
+*/
+function compareFqnHierarchically(a, b) {
+	const depthA = a.split(".").length;
+	const depthB = b.split(".").length;
+	switch (true) {
+		case depthA > depthB: return 1;
+		case depthA < depthB: return -1;
+		default: return 0;
+	}
+}
+function compareByFqnHierarchically(a, b) {
+	return compareFqnHierarchically(a.id, b.id);
+}
+/**
+* Sorts an array of objects hierarchically based on their fully qualified names (FQN).
+* Objects are sorted by the number of segments in their FQN (defined by dot-separated ID).
+*
+* @typeParam T - Object type that contains an 'id' string property
+* @typeParam A - Type extending IterableContainer of T
+*
+* @param array - Array of objects to be sorted
+* @returns A new array with items sorted by their FQN hierarchy depth (number of segments)
+*
+* @example
+* ```ts
+* const items = [
+*   { id: "a.b.c" },
+*   { id: "a" },
+*   { id: "a.b" }
+* ];
+* sortByFqnHierarchically(items);
+* // Result: [
+* //   { id: "a" },
+* //   { id: "a.b" },
+* //   { id: "a.b.c" }
+* // ]
+* ```
+*/
+function sortByFqnHierarchically(array) {
+	return array.map((item) => ({
+		item,
+		fqn: item.id.split(".")
+	})).sort((a, b) => {
+		return a.fqn.length - b.fqn.length;
+	}).map(({ item }) => item);
+}
+function findTopAncestor(items, item) {
+	let parent = item;
+	for (const e of items) if (isAncestor(e, parent)) parent = e;
+	return parent !== item ? parent : null;
+}
+/**
+* Keeps initial order of the elements, but ensures that parents are before children
+*/
+function sortParentsFirst(array) {
+	const result = [];
+	const items = [...array];
+	let item;
+	while (item = items.shift()) {
+		let parent;
+		while (parent = findTopAncestor(items, item)) result.push(items.splice(items.indexOf(parent), 1)[0]);
+		result.push(item);
+	}
+	return result;
+}
+function sortNaturalByFqn(array, sort) {
+	if (!array || isString(array)) {
+		const dir = array ?? "asc";
+		return (arr) => sortNaturalByFqn(arr, dir);
+	}
+	const dir = sort === "desc" ? -1 : 1;
+	return array.map((item) => ({
+		item,
+		fqn: item.id.split(".")
+	})).sort((a, b) => {
+		if (a.fqn.length !== b.fqn.length) return (a.fqn.length - b.fqn.length) * dir;
+		for (let i = 0; i < a.fqn.length; i++) {
+			const compare = compareNatural(a.fqn[i], b.fqn[i]);
+			if (compare !== 0) return compare;
+		}
+		return 0;
+	}).map(({ item }) => item);
+}
+
+//#endregion
+//#region src/utils/getOrCreate.ts
+function getOrCreate(map, key, create) {
+	let entry = map.get(key);
+	if (!entry) {
+		entry = create(key);
+		map.set(key, entry);
+	}
+	return entry;
+}
+
+//#endregion
+//#region src/utils/memoize-prop.ts
+/**
+* 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())
+*   }
+*
+* }
+* ```
+*/
+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];
+}
+
+//#endregion
+//#region src/utils/promises.ts
+const DELAY = "LIKEC4_DELAY";
+function delay(...args) {
+	let ms = 100;
+	if (args.length === 2) ms = e$1(args[0], args[1]);
+	else if (args.length === 1) ms = args[0];
+	return new Promise((resolve) => {
+		setTimeout(() => {
+			resolve(DELAY);
+		}, ms ?? 100);
+	});
+}
+function promiseNextTick() {
+	return Promise.resolve().then(() => void 0);
+}
+function onNextTick(fn) {
+	Promise.resolve().then(fn);
+}
+
+//#endregion
+//#region src/utils/relations.ts
+/**
+* Compares two relations hierarchically.
+* From the most general (implicit) to the most specific (deepest in the tree)
+*/
+const compareRelations = (a, b) => {
+	const parentA = commonAncestor(a.source.id, a.target.id);
+	const parentB = commonAncestor(b.source.id, b.target.id);
+	if (parentA && !parentB) return 1;
+	if (!parentA && parentB) return -1;
+	const compareParents = parentA && parentB ? compareFqnHierarchically(parentA, parentB) : 0;
+	if (compareParents !== 0) return compareParents;
+	const compareSource = compareFqnHierarchically(a.source.id, b.source.id);
+	if (compareSource !== 0) return compareSource;
+	return compareFqnHierarchically(a.target.id, b.target.id);
+};
+
+//#endregion
+//#region src/utils/set.ts
+/**
+* Returns new set as a union of given sets
+* Keeps order of elements
+*/
+function union(...sets) {
+	let result = /* @__PURE__ */ new Set();
+	for (const set of sets) for (const value of set) result.add(value);
+	return result;
+}
+/**
+* Returns new set as an intersection of all sets
+* Keeps order from the first set
+*/
+function intersection(first, ...sets) {
+	let result = /* @__PURE__ */ new Set();
+	if (first.size === 0) return result;
+	let other = t$4(sets, 2) ? (0, import_set.intersection)(...sets) : sets[0];
+	if (other.size === 0) return result;
+	for (const value of first) if (other.has(value)) result.add(value);
+	return result;
+}
+/**
+* Returns new set as a difference of two sets (A-B)
+* Keeps order from the first set
+*/
+function difference(a, b) {
+	if (a.size === 0) return /* @__PURE__ */ new Set();
+	if (b.size === 0) return new Set(a);
+	let result = /* @__PURE__ */ new Set();
+	for (const value of a) if (!b.has(value)) result.add(value);
+	return result;
+}
+function equals(a, b) {
+	return a.size === b.size && [...a].every((value) => b.has(value));
+}
+function symmetricDifference(a, b) {
+	return (0, import_set.symmetricDifference)(a, b);
+}
+function hasIntersection(a, b) {
+	if (a.size === 0 || b.size === 0) return false;
+	if (b.size < a.size) [a, b] = [b, a];
+	for (const value of a) if (b.has(value)) return true;
+	return false;
+}
+
+//#endregion
+//#region src/utils/object-hash.ts
+function objectHash(value) {
+	invariant(typeof value === "object" && e$2(value), "objectHash: value must be an object");
+	return hash(value);
+}
+
+//#endregion
+//#region src/utils/string-hash.ts
+/**
+* @see https://gist.github.com/victor-homyakov/bcb7d7911e4a388b1c810f8c3ce17bcf
+*/
+function stringHash(str) {
+	let hash = 5381;
+	const len = str.length;
+	invariant(len > 0, "stringHash: empty string");
+	for (let i = 0; i < len; i++) hash = hash * 33 ^ str.charCodeAt(i);
+	return (hash >>> 0).toString(36);
+}
+
+//#endregion
+//#region src/utils/markdown/to-html.ts
+function parser() {
+	return unified().use(remarkParse).use(remarkGfm).use(remarkAlert).use(remarkRehype, { allowDangerousHtml: true }).use(rehypeSanitize, defu({
+		attributes: {
+			"*": ["className"],
+			"svg": [
+				"width",
+				"height",
+				"viewBox",
+				"fill",
+				"ariaHidden"
+			],
+			"path": [
+				"d",
+				"fill",
+				"stroke",
+				"strokeWidth",
+				"strokeLinecap",
+				"strokeLinejoin"
+			]
+		},
+		tagNames: [
+			"svg",
+			"g",
+			"path",
+			"div"
+		]
+	}, defaultSchema)).use(rehypeStringify, { allowDangerousHtml: true });
+}
+function markdownToHtml(markdown) {
+	return ("" + parser().processSync(markdown)).trim();
+}
+
+//#endregion
+//#region src/utils/markdown/to-text.ts
+/**
+* Converts markdown to plain text, removing any markdown formatting.
+* @param markdown - The markdown to convert.
+* @returns The plain text.
+*/
+function markdownToText(markdown) {
+	return toString(fromMarkdown(markdown), {
+		includeHtml: false,
+		includeImageAlt: false
+	});
+}
+
+//#endregion
+export { sortParentsFirst as A, isAncestor as C, parentFqn as D, nameFromFqn as E, commonHead as F, compareNatural as I, compareNaturalHierarchically as L, isAnyOf as M, isNonEmptyArray as N, sortByFqnHierarchically as O, isString as P, hierarchyLevel as S, isSameHierarchy as T, ancestorsFqn as _, difference as a, compareFqnHierarchically as b, intersection as c, compareRelations as d, delay as f, getOrCreate as g, memoizeProp as h, objectHash as i, hasProp as j, sortNaturalByFqn as k, symmetricDifference as l, promiseNextTick as m, markdownToHtml as n, equals as o, onNextTick as p, stringHash as r, hasIntersection as s, markdownToText as t, union as u, commonAncestor as v, isDescendantOf as w, hierarchyDistance as x, compareByFqnHierarchically as y };