@ls-stack/utils 3.65.0 → 3.67.0

package/dist/serializeXML.mjs

@@ -0,0 +1,74 @@
+import { s as isTruthy } from "./typeGuards-B1mzA-Rz.mjs";
+import { filterAndMap } from "./arrayUtils.mjs";
+
+//#region src/serializeXML.ts
+const XML_TAG_NAME_REGEX = /^[a-zA-Z_][a-zA-Z0-9._-]*$/;
+const XML_PREFIX_REGEX = /^xml/i;
+const XML_ESCAPE_MAP = {
+	"&": "&",
+	"<": "&lt;",
+	">": "&gt;",
+	"\"": "&quot;",
+	"'": "&#39;"
+};
+const XML_ESCAPE_REGEX = /[&<>"']/g;
+function serializeXML(node, options) {
+	if (Array.isArray(node)) {
+		const EMPTY_LINE_MARKER = "\0EMPTY_LINE\0";
+		return node.filter(isTruthy).map((n) => {
+			if (n.type === "emptyLine") return EMPTY_LINE_MARKER;
+			return serializeWithLevel(n, options, 0);
+		}).filter(isTruthy).join(options?.indent ? "\n" : "").replace(new RegExp(EMPTY_LINE_MARKER, "g"), "");
+	}
+	return serializeWithLevel(node, options, 0);
+}
+function serializeWithLevel(node, options = {}, level) {
+	const { indent, escapeText: globalEscapeText = false, validateTagName = true, invalidNodes = "throw" } = options;
+	const indentStr = indent ? getIndentString(indent, level) : "";
+	const newline = indent ? "\n" : "";
+	if (node.type === "comment") return `${indentStr}<!-- ${(node.escapeText !== void 0 ? node.escapeText : globalEscapeText) ? escapeXml(node.content) : node.content} -->`;
+	if (node.type === "emptyLine") return "";
+	const { name, attrs: attributes = {}, children, escapeText: nodeEscapeText } = node;
+	const shouldEscapeText = nodeEscapeText !== void 0 ? nodeEscapeText : globalEscapeText;
+	if (validateTagName && !isValidXmlTagName(name)) {
+		if (invalidNodes === "throw") throw new Error(`Invalid XML tag name: "${name}"`);
+		return "";
+	}
+	const attributesStr = filterAndMap(Object.entries(attributes), ([key, value]) => value !== null && value !== void 0 ? `${key}="${escapeXml(String(value))}"` : false).join(" ");
+	const attributesPart = attributesStr ? ` ${attributesStr}` : "";
+	if (children === void 0) return `${indentStr}<${name}${attributesPart} />`;
+	if (typeof children === "string") {
+		const processedText = shouldEscapeText ? escapeXml(children) : children;
+		if (processedText.includes("\n") && indent) {
+			const lines = processedText.split("\n");
+			const contentIndent = getIndentString(indent, level + 1);
+			return `${indentStr}<${name}${attributesPart}>\n${contentIndent}${lines.map((line, index) => {
+				if (line.trim() === "") return "";
+				return index === 0 ? line : contentIndent + line;
+			}).join("\n")}\n${indentStr}</${name}>`;
+		}
+		return `${indentStr}<${name}${attributesPart}>${processedText}</${name}>`;
+	}
+	if (children.length === 0) return `${indentStr}<${name}${attributesPart}></${name}>`;
+	const serializedChildren = filterAndMap(children, (child) => {
+		if (!child) return false;
+		return serializeWithLevel(child, options, level + 1) || false;
+	});
+	if (serializedChildren.length === 0) return `${indentStr}<${name}${attributesPart}></${name}>`;
+	return `${indentStr}<${name}${attributesPart}>${newline}${serializedChildren.join(newline)}${newline}${indentStr}</${name}>`;
+}
+function getIndentString(indent, level) {
+	if (typeof indent === "string") return indent.repeat(level);
+	return " ".repeat(indent * level);
+}
+function isValidXmlTagName(name) {
+	if (!name) return false;
+	if (XML_PREFIX_REGEX.test(name)) return false;
+	return XML_TAG_NAME_REGEX.test(name);
+}
+function escapeXml(text) {
+	return text.replace(XML_ESCAPE_REGEX, (char) => XML_ESCAPE_MAP[char]);
+}
+
+//#endregion
+export { serializeXML };

package/dist/{shallowEqual.d.cts → shallowEqual.d.mts}

@@ -1,4 +1,5 @@
+//#region src/shallowEqual.d.ts
 /** Shallow equal version of https://github.com/lukeed/dequal */
 declare function shallowEqual(foo: any, bar: any): boolean;
-
-export { shallowEqual };
+//#endregion
+export { shallowEqual };

package/dist/shallowEqual.mjs

@@ -0,0 +1,54 @@
+//#region src/shallowEqual.ts
+var has = Object.prototype.hasOwnProperty;
+function find(iter, tar, key) {
+	for (key of iter.keys()) if (key === tar) return key;
+}
+/** Shallow equal version of https://github.com/lukeed/dequal */
+function shallowEqual(foo, bar) {
+	var ctor, len, tmp;
+	if (foo === bar) return true;
+	if (foo && bar && (ctor = foo.constructor) === bar.constructor) {
+		if (ctor === Date) return shallowEqual(foo.getTime(), bar.getTime());
+		if (ctor === RegExp) return foo.toString() === bar.toString();
+		if (ctor === Array) {
+			if ((len = foo.length) === bar.length) while (len-- && foo[len] === bar[len]);
+			return len === -1;
+		}
+		if (ctor === Set) {
+			if (foo.size !== bar.size) return false;
+			for (len of foo) {
+				tmp = len;
+				if (tmp && typeof tmp === "object") {
+					tmp = find(bar, tmp);
+					if (!tmp) return false;
+				}
+				if (!bar.has(tmp)) return false;
+			}
+			return true;
+		}
+		if (ctor === Map) {
+			if (foo.size !== bar.size) return false;
+			for (len of foo) {
+				tmp = len[0];
+				if (tmp && typeof tmp === "object") {
+					tmp = find(bar, tmp);
+					if (!tmp) return false;
+				}
+				if (len[1] !== bar.get(tmp)) return false;
+			}
+			return true;
+		}
+		if (!ctor || typeof foo === "object") {
+			len = 0;
+			for (ctor in foo) {
+				if (has.call(foo, ctor) && ++len && !has.call(bar, ctor)) return false;
+				if (!(ctor in bar) || !(foo[ctor] === bar[ctor])) return false;
+			}
+			return Object.keys(bar).length === len;
+		}
+	}
+	return foo !== foo && bar !== bar;
+}
+
+//#endregion
+export { shallowEqual };

package/dist/sleep.d.mts

@@ -0,0 +1,4 @@
+//#region src/sleep.d.ts
+declare function sleep(ms: number): Promise<unknown>;
+//#endregion
+export { sleep };

package/dist/sleep.mjs

@@ -0,0 +1,7 @@
+//#region src/sleep.ts
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+//#endregion
+export { sleep };

package/dist/stringUtils-DjhWOiYn.mjs

@@ -0,0 +1,113 @@
+//#region src/stringUtils.ts
+/**
+* A util to create more legible conditional concatenated strings
+*
+* @example
+*   joinStrings('a', 'b', 'c'); // 'abc'
+*   joinStrings('a', false, 'c'); // 'ac'
+*   joinStrings('a', addBString ? 'b' : null, 'c'); // 'ac' if addBString is false, 'abc' if addBString is true
+*
+* @param args
+*/
+function concatStrings(...args) {
+	const strings = [];
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (!arg) continue;
+		if (Array.isArray(arg)) {
+			strings.push(concatStrings(...arg));
+			continue;
+		}
+		strings.push(arg);
+	}
+	return strings.join("");
+}
+/** @deprecated Use {@link concatStrings} instead */
+const joinStrings = concatStrings;
+function formatNum(num, maxDecimalsOrOptions = 2) {
+	const options = typeof maxDecimalsOrOptions === "number" ? { maximumFractionDigits: maxDecimalsOrOptions } : maxDecimalsOrOptions;
+	return num.toLocaleString("en-US", options);
+}
+/** Check if a string is `snake_case` */
+function isSnakeCase(str) {
+	return /^[a-z0-9_]+$/.test(str);
+}
+/** Check if a string is `kebab-case` */
+function isKebabCase(str) {
+	return /^[a-z0-9]+(-[a-z0-9]+)*$/.test(str);
+}
+/** Check if a string is `PascalCase` */
+function isPascalCase(str) {
+	return /^[A-Z][a-zA-Z0-9]*$/.test(str);
+}
+/** Check if a string is `camelCase` */
+function isCamelCase(str) {
+	return /^[a-z][a-zA-Z0-9]*$/.test(str);
+}
+/** Check if a string is `Title Case` */
+function isTitleCase(str) {
+	return /^[A-Z][a-z0-9]*( ([A-Z][a-z0-9]*|[0-9]+))*$/.test(str);
+}
+/** Check if a string is `Sentence Case` */
+function isSentenceCase(str) {
+	return /^[A-Z][a-z0-9]*( [a-z0-9]+)*$/.test(str);
+}
+/** Check if a string is `CONSTANT_CASE` */
+function isConstantCase(str) {
+	return /^[A-Z_][A-Z0-9_]*$/.test(str);
+}
+/** Check if a string is `dot.case` */
+function isDotCase(str) {
+	return /^[a-z0-9]+(\.[a-z0-9]+)*$/.test(str);
+}
+/** Check if a string is `path/case` */
+function isPathCase(str) {
+	return /^[a-z0-9]+(\/[a-z0-9]+)*$/.test(str);
+}
+/** Convert a string to `kebab-case` */
+function convertToKebabCase(str) {
+	return convertToSnakeCase(str).replace(/_/g, "-");
+}
+/** Convert a string to `snake_case` */
+function convertToSnakeCase(str) {
+	return str.replace(/[\s\-.]+/g, "_").replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z])([A-Z][a-z])/g, "$1_$2").toLowerCase().replace(/[^a-z0-9_]/g, "").replace(/^_+|_+$/g, "").replace(/_+/g, "_");
+}
+/** Convert a string to `PascalCase` */
+function convertToPascalCase(str) {
+	return str.split(/[\s_-]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+}
+/** Convert a string to `camelCase` */
+function convertToCamelCase(str) {
+	const pascalCase = convertToPascalCase(str);
+	return pascalCase.charAt(0).toLowerCase() + pascalCase.slice(1);
+}
+/** Convert a string to `Sentence Case` */
+function convertToSentenceCase(str) {
+	return str.replace(/[\s\-.]+/g, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z])([A-Z][a-z])/g, "$1 $2").split(/[\s_-]+/).map((word) => word.toLowerCase()).join(" ").replace(/^\w/, (char) => char.toUpperCase());
+}
+/** Convert a string to `Title Case` */
+function convertToTitleCase(str) {
+	return str.replace(/[\s\-.]+/g, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z])([A-Z][a-z])/g, "$1 $2").split(/[\s_-]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ");
+}
+/** Convert a string to `CONSTANT_CASE` */
+function convertToConstantCase(str) {
+	return convertToSnakeCase(str).toUpperCase();
+}
+/** Convert a string to `dot.case` */
+function convertToDotCase(str) {
+	return convertToSnakeCase(str).replace(/_/g, ".");
+}
+/** Convert a string to `path/case` */
+function convertToPathCase(str) {
+	return convertToSnakeCase(str).replace(/_/g, "/");
+}
+function truncateString(str, length, ellipsis = "…") {
+	if (str.length <= length) return str;
+	return str.slice(0, length - 1) + ellipsis;
+}
+function removeANSIColors(str) {
+	return str.replace(/\u001b\[\d+m/g, "");
+}
+
+//#endregion
+export { truncateString as C, removeANSIColors as S, isPathCase as _, convertToKebabCase as a, isTitleCase as b, convertToSentenceCase as c, formatNum as d, isCamelCase as f, isPascalCase as g, isKebabCase as h, convertToDotCase as i, convertToSnakeCase as l, isDotCase as m, convertToCamelCase as n, convertToPascalCase as o, isConstantCase as p, convertToConstantCase as r, convertToPathCase as s, concatStrings as t, convertToTitleCase as u, isSentenceCase as v, joinStrings as x, isSnakeCase as y };

package/dist/{stringUtils.d.cts → stringUtils.d.mts}

@@ -1,3 +1,4 @@
+//#region src/stringUtils.d.ts
 type Arg = string | false | undefined | null;
 /**
  * A util to create more legible conditional concatenated strings
@@ -51,5 +52,5 @@ declare function convertToDotCase(str: string): string;
 declare function convertToPathCase(str: string): string;
 declare function truncateString(str: string, length: number, ellipsis?: string): string;
 declare function removeANSIColors(str: string): string;
-
-export { concatStrings, convertToCamelCase, convertToConstantCase, convertToDotCase, convertToKebabCase, convertToPascalCase, convertToPathCase, convertToSentenceCase, convertToSnakeCase, convertToTitleCase, formatNum, isCamelCase, isConstantCase, isDotCase, isKebabCase, isPascalCase, isPathCase, isSentenceCase, isSnakeCase, isTitleCase, joinStrings, removeANSIColors, truncateString };
+//#endregion
+export { concatStrings, convertToCamelCase, convertToConstantCase, convertToDotCase, convertToKebabCase, convertToPascalCase, convertToPathCase, convertToSentenceCase, convertToSnakeCase, convertToTitleCase, formatNum, isCamelCase, isConstantCase, isDotCase, isKebabCase, isPascalCase, isPathCase, isSentenceCase, isSnakeCase, isTitleCase, joinStrings, removeANSIColors, truncateString };

package/dist/stringUtils.mjs

@@ -0,0 +1,3 @@
+import { C as truncateString, S as removeANSIColors, _ as isPathCase, a as convertToKebabCase, b as isTitleCase, c as convertToSentenceCase, d as formatNum, f as isCamelCase, g as isPascalCase, h as isKebabCase, i as convertToDotCase, l as convertToSnakeCase, m as isDotCase, n as convertToCamelCase, o as convertToPascalCase, p as isConstantCase, r as convertToConstantCase, s as convertToPathCase, t as concatStrings, u as convertToTitleCase, v as isSentenceCase, x as joinStrings, y as isSnakeCase } from "./stringUtils-DjhWOiYn.mjs";
+
+export { concatStrings, convertToCamelCase, convertToConstantCase, convertToDotCase, convertToKebabCase, convertToPascalCase, convertToPathCase, convertToSentenceCase, convertToSnakeCase, convertToTitleCase, formatNum, isCamelCase, isConstantCase, isDotCase, isKebabCase, isPascalCase, isPathCase, isSentenceCase, isSnakeCase, isTitleCase, joinStrings, removeANSIColors, truncateString };

package/dist/{testUtils.d.ts → testUtils.d.mts}

@@ -1,45 +1,65 @@
-import { YamlStringifyOptions } from './yamlStringify.js';
+import { YamlStringifyOptions } from "./yamlStringify.mjs";
 
-declare function createLoggerStore({ filterKeys: defaultFilterKeys, rejectKeys: defaultRejectKeys, splitLongLines: defaultSplitLongLines, maxLineLengthBeforeSplit: defaultMaxLineLengthBeforeSplit, fromLastSnapshot: defaultFromLastSnapshot, arrays: defaultArrays, changesOnly: defaultChangesOnly, useEmojiForBooleans: defaultUseEmojiForBooleans, }?: {
+//#region src/testUtils.d.ts
+declare function createLoggerStore({
+  filterKeys: defaultFilterKeys,
+  rejectKeys: defaultRejectKeys,
+  splitLongLines: defaultSplitLongLines,
+  maxLineLengthBeforeSplit: defaultMaxLineLengthBeforeSplit,
+  fromLastSnapshot: defaultFromLastSnapshot,
+  arrays: defaultArrays,
+  changesOnly: defaultChangesOnly,
+  useEmojiForBooleans: defaultUseEmojiForBooleans
+}?: {
+  filterKeys?: string[];
+  rejectKeys?: string[];
+  splitLongLines?: true;
+  maxLineLengthBeforeSplit?: number;
+  fromLastSnapshot?: boolean;
+  arrays?: 'all' | 'firstAndLast' | 'length' | {
+    firstNItems: number;
+  };
+  changesOnly?: boolean;
+  useEmojiForBooleans?: boolean;
+}): {
+  add: (render: Record<string, unknown> | readonly Record<string, unknown>[]) => void;
+  reset: (keepLastRender?: boolean) => void;
+  getSnapshot: ({
+    arrays,
+    changesOnly,
+    filterKeys,
+    rejectKeys,
+    includeLastSnapshotEndMark,
+    splitLongLines,
+    maxLineLengthBeforeSplit,
+    fromLastSnapshot,
+    useEmojiForBooleans
+  }?: {
+    arrays?: "all" | "firstAndLast" | "length" | {
+      firstNItems: number;
+    };
+    changesOnly?: boolean;
     filterKeys?: string[];
     rejectKeys?: string[];
-    splitLongLines?: true;
+    includeLastSnapshotEndMark?: boolean;
+    splitLongLines?: boolean;
     maxLineLengthBeforeSplit?: number;
     fromLastSnapshot?: boolean;
-    arrays?: 'all' | 'firstAndLast' | 'length' | {
-        firstNItems: number;
-    };
-    changesOnly?: boolean;
     useEmojiForBooleans?: boolean;
-}): {
-    add: (render: Record<string, unknown> | readonly Record<string, unknown>[]) => void;
-    reset: (keepLastRender?: boolean) => void;
-    getSnapshot: ({ arrays, changesOnly, filterKeys, rejectKeys, includeLastSnapshotEndMark, splitLongLines, maxLineLengthBeforeSplit, fromLastSnapshot, useEmojiForBooleans, }?: {
-        arrays?: "all" | "firstAndLast" | "length" | {
-            firstNItems: number;
-        };
-        changesOnly?: boolean;
-        filterKeys?: string[];
-        rejectKeys?: string[];
-        includeLastSnapshotEndMark?: boolean;
-        splitLongLines?: boolean;
-        maxLineLengthBeforeSplit?: number;
-        fromLastSnapshot?: boolean;
-        useEmojiForBooleans?: boolean;
-    }) => string;
-    waitNextLog: (timeout?: number) => Promise<void>;
-    readonly changesSnapshot: string;
-    readonly snapshot: string;
-    readonly snapshotFromLast: string;
-    logsCount: () => number;
-    readonly rendersTime: number[];
-    addMark: (label: string) => void;
+  }) => string;
+  waitNextLog: (timeout?: number) => Promise<void>;
+  readonly changesSnapshot: string;
+  readonly snapshot: string;
+  readonly snapshotFromLast: string;
+  logsCount: () => number;
+  readonly rendersTime: number[];
+  addMark: (label: string) => void;
 };
 declare function getResultFn<T extends (...args: any[]) => any>(fnGetter: () => T, wrapper?: (...args: any[]) => any): T;
 declare function waitController(): {
-    wait: Promise<void>;
-    stopWaiting: () => void;
-    stopWaitingAfter: (ms: number) => void;
+  wait: Promise<void>;
+  stopWaiting: () => void;
+  stopWaitingAfter: (ms: number) => void;
 };
 /**
  * Produces a more compact and readable snapshot of a value using yaml. By
@@ -111,23 +131,34 @@ declare function waitController(): {
  *   supported.
  * @returns The compact snapshot of the value.
  */
-declare function compactSnapshot(value: unknown, { collapseObjects, maxLineLength, showUndefined, showBooleansAs, replaceValues, rejectKeys, filterKeys, sortKeys, sortPatterns, ...options }?: YamlStringifyOptions & {
-    showBooleansAs?: boolean | {
-        props?: Record<string, {
-            trueText?: string;
-            falseText?: string;
-        } | true>;
-        ignoreProps?: string[];
-        trueText?: string;
-        falseText?: string;
-    };
-    replaceValues?: (value: unknown, path: string) => false | {
-        newValue: unknown;
-    };
-    rejectKeys?: string[] | string;
-    filterKeys?: string[] | string;
-    sortKeys?: 'asc' | 'desc' | 'simpleValuesFirst' | false;
-    sortPatterns?: string[];
+declare function compactSnapshot(value: unknown, {
+  collapseObjects,
+  maxLineLength,
+  showUndefined,
+  showBooleansAs,
+  replaceValues,
+  rejectKeys,
+  filterKeys,
+  sortKeys,
+  sortPatterns,
+  ...options
+}?: YamlStringifyOptions & {
+  showBooleansAs?: boolean | {
+    props?: Record<string, {
+      trueText?: string;
+      falseText?: string;
+    } | true>;
+    ignoreProps?: string[];
+    trueText?: string;
+    falseText?: string;
+  };
+  replaceValues?: (value: unknown, path: string) => false | {
+    newValue: unknown;
+  };
+  rejectKeys?: string[] | string;
+  filterKeys?: string[] | string;
+  sortKeys?: 'asc' | 'desc' | 'simpleValuesFirst' | false;
+  sortPatterns?: string[];
 }): string;
-
-export { compactSnapshot, createLoggerStore, getResultFn, waitController };
+//#endregion
+export { compactSnapshot, createLoggerStore, getResultFn, waitController };