@ls-stack/utils 3.23.0 → 3.24.1

package/lib/testUtils.cjs

@@ -20,6 +20,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/testUtils.ts
 var testUtils_exports = {};
 __export(testUtils_exports, {
+  compactSnapshot: () => compactSnapshot,
   createLoggerStore: () => createLoggerStore,
   getResultFn: () => getResultFn,
   waitController: () => waitController
@@ -30,6 +31,17 @@ module.exports = __toCommonJS(testUtils_exports);
 function isObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function isPlainObject(value) {
+  if (!value || typeof value !== "object") return false;
+  const proto = Object.getPrototypeOf(value);
+  if (proto === null) {
+    return true;
+  }
+  const Ctor = Object.hasOwnProperty.call(proto, "constructor") && proto.constructor;
+  if (Ctor === Object) return true;
+  const objectCtorString = Object.prototype.constructor.toString();
+  return typeof Ctor == "function" && Function.toString.call(Ctor) === objectCtorString;
+}
 
 // src/assertions.ts
 var isObject2 = isObject;
@@ -153,6 +165,368 @@ function defer() {
   return { resolve, reject, promise };
 }
 
+// src/conversions.ts
+function bytesToHumanReadable(bytes) {
+  if (bytes < 1024) {
+    return `${bytes} B`;
+  }
+  const kb = bytes / 1024;
+  if (kb < 1024) {
+    return `${kb.toFixed(2)} KB`;
+  }
+  const mb = kb / 1024;
+  if (mb < 1024) {
+    return `${mb.toFixed(2)} MB`;
+  }
+  const gb = mb / 1024;
+  return `${gb.toFixed(2)} GB`;
+}
+
+// src/stringUtils.ts
+function truncateString(str, length, ellipsis = "\u2026") {
+  if (str.length <= length) return str;
+  return str.slice(0, length - 1) + ellipsis;
+}
+
+// src/yamlStringify.ts
+function yamlStringify(obj, {
+  maxLineLength = 100,
+  showUndefined,
+  maxDepth = 50,
+  collapseObjects = false,
+  addRootObjSpaces = "beforeAndAfter"
+} = {}) {
+  if (isObject(obj) || Array.isArray(obj) || typeof obj === "function") {
+    return `${stringifyValue(obj, "", maxLineLength, !!showUndefined, maxDepth, 0, collapseObjects, addRootObjSpaces)}
+`;
+  }
+  return JSON.stringify(obj) || "undefined";
+}
+function stringifyValue(value, indent, maxLineLength, showUndefined, maxDepth, depth, collapseObjects, addObjSpaces) {
+  let result = "";
+  const childIndent = `${indent}  `;
+  if (isPlainObject(value)) {
+    if (Object.keys(value).length === 0) {
+      return "{}";
+    }
+    if (collapseObjects && depth > 0) {
+      const entries = Object.entries(value).filter(
+        ([, val]) => val !== void 0 || showUndefined
+      );
+      const isSimpleObject = entries.every(
+        ([, val]) => {
+          if (typeof val === "string") {
+            return !val.includes("'") && !val.includes('"') && !val.includes("\\");
+          }
+          return typeof val === "number" || typeof val === "boolean" || val === null || val === void 0;
+        }
+      );
+      if (isSimpleObject && entries.length > 0) {
+        let line = "{ ";
+        line += entries.map(([key, val]) => {
+          let valueStr;
+          if (typeof val === "string") {
+            if (val.includes("'") && !val.includes('"')) {
+              valueStr = `"${val}"`;
+            } else if (val.includes('"') && !val.includes("'")) {
+              valueStr = `'${val}'`;
+            } else if (val.includes("'") && val.includes('"')) {
+              valueStr = `"${val.replace(/"/g, '\\"')}"`;
+            } else {
+              valueStr = `'${val}'`;
+            }
+          } else {
+            valueStr = String(val);
+          }
+          return `${key}: ${valueStr}`;
+        }).join(", ");
+        line += " }";
+        if (line.length <= maxLineLength) {
+          return line;
+        }
+      }
+    }
+    let prevValue;
+    let afterSpaceWasAdded = false;
+    for (let [key, objVal] of Object.entries(value)) {
+      if (objVal === void 0 && !showUndefined) {
+        continue;
+      }
+      if (depth > maxDepth) {
+        objVal = `{max depth reached}`;
+      }
+      const normalizedValue2 = normalizeValue(objVal);
+      if (normalizedValue2 !== null) {
+        objVal = normalizedValue2[1];
+        key = `${key}{${normalizedValue2[0]}}`;
+      }
+      const valueString = stringifyValue(
+        objVal,
+        childIndent,
+        maxLineLength,
+        showUndefined,
+        maxDepth,
+        depth + 1,
+        collapseObjects,
+        addObjSpaces
+      );
+      const willBeCollapsed = isObject(objVal) && (Object.keys(objVal).length === 0 || collapseObjects && depth + 1 > 0 && Object.entries(objVal).filter(([, val]) => val !== void 0 || showUndefined).every(([, val]) => {
+        if (typeof val === "string") {
+          return !val.includes("'") && !val.includes('"') && !val.includes("\\");
+        }
+        return typeof val === "number" || typeof val === "boolean" || val === null || val === void 0;
+      }));
+      const prevWasCollapsed = prevValue && isObject(prevValue) && (Object.keys(prevValue).length === 0 || collapseObjects && depth + 1 > 0 && Object.entries(prevValue).filter(([, val]) => val !== void 0 || showUndefined).every(([, val]) => {
+        if (typeof val === "string") {
+          return !val.includes("'") && !val.includes('"') && !val.includes("\\");
+        }
+        return typeof val === "number" || typeof val === "boolean" || val === null || val === void 0;
+      }));
+      if (!afterSpaceWasAdded && indent === "" && isObject(objVal) && !willBeCollapsed && prevValue && !prevWasCollapsed && (addObjSpaces === "before" || addObjSpaces === "beforeAndAfter")) {
+        result += "\n";
+      }
+      if (Array.isArray(objVal)) {
+        const arrayIsSingleLine = valueString.split("\n").length === 1;
+        if (arrayIsSingleLine && !valueString.trim().startsWith("-")) {
+          result += `${indent}${key}: `;
+        } else {
+          result += `${indent}${key}:
+`;
+        }
+      } else if (isObject(objVal)) {
+        const isCollapsedObject = valueString.startsWith("{") && !valueString.includes("\n");
+        if (Object.keys(objVal).length === 0 || isCollapsedObject) {
+          result += `${indent}${key}: `;
+        } else {
+          result += `${indent}${key}:
+`;
+        }
+      } else {
+        result += `${indent}${key}: `;
+      }
+      result += valueString;
+      result += "\n";
+      if (indent === "") {
+        const isCollapsedObject = valueString.startsWith("{") && !valueString.includes("\n") && valueString.length > 2;
+        if (isObject(objVal) && !isCollapsedObject) {
+          if (addObjSpaces === "after" || addObjSpaces === "beforeAndAfter") {
+            result += "\n";
+            afterSpaceWasAdded = true;
+          } else {
+            afterSpaceWasAdded = false;
+          }
+        }
+      }
+      prevValue = objVal;
+    }
+    return result.trimEnd();
+  }
+  if (Array.isArray(value)) {
+    let arrayWasAdded = false;
+    if (value.length === 0 || value.every(
+      (item) => typeof item === "string" || typeof item === "number" || typeof item === "boolean" || item === null || item === void 0
+    )) {
+      let line = "";
+      line += `[`;
+      line += value.map((item) => {
+        let valueToUse = item;
+        if (depth > maxDepth) {
+          valueToUse = `{max depth reached}`;
+        }
+        if (typeof valueToUse === "string" && valueToUse.includes("\n")) {
+          valueToUse = valueToUse.replace(/\n/g, "\\n");
+        }
+        return stringifyValue(
+          valueToUse,
+          "",
+          maxLineLength,
+          showUndefined,
+          maxDepth,
+          depth + 1,
+          collapseObjects,
+          addObjSpaces
+        );
+      }).join(", ");
+      line += "]";
+      if (line.length <= maxLineLength) {
+        result += line;
+        arrayWasAdded = true;
+      }
+    }
+    if (!arrayWasAdded) {
+      for (let item of value) {
+        if (depth > maxDepth) {
+          item = `{max depth reached}`;
+        }
+        result += `${indent}- `;
+        if (Array.isArray(item) || isObject(item)) {
+          let arrayString = stringifyValue(
+            item,
+            childIndent,
+            maxLineLength,
+            showUndefined,
+            maxDepth,
+            depth + 1,
+            collapseObjects,
+            addObjSpaces
+          );
+          arrayString = arrayString.trimStart();
+          result += arrayString;
+        } else {
+          result += stringifyValue(
+            item,
+            childIndent,
+            maxLineLength,
+            showUndefined,
+            maxDepth,
+            depth + 1,
+            collapseObjects,
+            addObjSpaces
+          );
+        }
+        result += "\n";
+      }
+    }
+    return result.trimEnd();
+  }
+  if (typeof value === "string") {
+    if (value.includes("\n")) {
+      const lines = value.split("\n");
+      for (const [i, line] of lines.entries()) {
+        if (i === 0) {
+          if (value.endsWith("\n")) {
+            result += `|`;
+          } else {
+            result += `|-`;
+          }
+          result += `
+${indent}${line}
+`;
+        } else {
+          result += `${indent}${line}
+`;
+        }
+      }
+    } else {
+      if (value.includes("'") && !value.includes('"')) {
+        result += `"${value}"`;
+      } else if (value.includes('"') && !value.includes("'")) {
+        result += `'${value}'`;
+      } else if (value.includes("'") && value.includes('"')) {
+        result += `"${value.replace(/"/g, '\\"')}"`;
+      } else {
+        result += `'${value}'`;
+      }
+    }
+    return result.trimEnd();
+  }
+  if (typeof value === "number" || typeof value === "boolean" || value === null || value === void 0) {
+    return String(value).trimEnd();
+  }
+  const normalizedValue = normalizeValue(value);
+  if (normalizedValue !== null) {
+    return stringifyValue(
+      {
+        [`${normalizedValue[0]}#`]: normalizedValue[1]
+      },
+      indent,
+      maxLineLength,
+      showUndefined,
+      maxDepth,
+      depth + 1,
+      collapseObjects,
+      addObjSpaces
+    );
+  }
+  return JSON.stringify(value);
+}
+function normalizeValue(value) {
+  if (value === null || isPlainObject(value) || Array.isArray(value)) {
+    return null;
+  }
+  if (value instanceof Map) {
+    const mapEntries = Array.from(value.entries());
+    let mapValue;
+    if (mapEntries.every(([key]) => typeof key === "string")) {
+      const mapObjValue = {};
+      for (const [key, val] of mapEntries) {
+        mapObjValue[key] = val;
+      }
+      mapValue = mapObjValue;
+    } else {
+      mapValue = mapEntries.map(([key, val]) => ({
+        key,
+        value: val
+      }));
+    }
+    return ["Map", mapValue];
+  }
+  if (value instanceof Set) {
+    const setValue = Array.from(value);
+    return ["Set", setValue];
+  }
+  if (value instanceof Date) {
+    return ["Date", value.toISOString()];
+  }
+  if (value instanceof RegExp) {
+    return ["RegExp", value.toString()];
+  }
+  if (value instanceof Error) {
+    return [
+      "Error",
+      {
+        message: value.message,
+        name: value.name,
+        stack: value.stack
+      }
+    ];
+  }
+  if (value instanceof File) {
+    return [
+      "File",
+      {
+        name: value.name,
+        type: value.type,
+        lastModified: new Date(value.lastModified).toISOString(),
+        size: bytesToHumanReadable(value.size)
+      }
+    ];
+  }
+  if (typeof value === "object") {
+    if ("toJSON" in value && typeof value.toJSON === "function") {
+      return [value.constructor.name, value.toJSON()];
+    }
+    if ("toString" in value && typeof value.toString === "function") {
+      const stringValue = value.toString();
+      if (stringValue.toString() !== "[object Object]") {
+        return [value.constructor.name, stringValue];
+      }
+    }
+    const objectValue = { ...value };
+    const displayValue = {};
+    let addedKeys = 0;
+    for (const [key, item] of Object.entries(objectValue)) {
+      if (addedKeys > 4) {
+        displayValue["...and more properties"] = Object.keys(objectValue).length - 4;
+        break;
+      }
+      if (typeof item === "string" || typeof item === "number" || typeof item === "boolean" || item === null || item === void 0) {
+        displayValue[key] = item;
+        addedKeys++;
+      }
+    }
+    return [String(value.constructor.name), displayValue];
+  }
+  if (typeof value === "function") {
+    const functionString = value.toString();
+    return [
+      `Function`,
+      functionString.includes("\n") ? truncateString(functionString.split("\n").join(""), 40) : functionString
+    ];
+  }
+  return null;
+}
+
 // src/testUtils.ts
 function createLoggerStore({
   filterKeys: defaultFilterKeys,
@@ -379,8 +753,210 @@ function waitController() {
     }
   };
 }
+function matchesKeyPattern(fullPath, key, pattern, currentPath) {
+  if (fullPath === pattern) {
+    return true;
+  }
+  if (pattern.startsWith("*.")) {
+    const propName = pattern.slice(2);
+    return currentPath !== "" && key === propName;
+  }
+  if (pattern.startsWith("*") && !pattern.startsWith("*.")) {
+    const propName = pattern.slice(1);
+    return key === propName;
+  }
+  if (!pattern.includes("*")) {
+    return currentPath === "" && key === pattern;
+  }
+  return false;
+}
+function isParentOfPattern(path, pattern) {
+  if (pattern.includes("*")) {
+    const patternParts = pattern.split(".");
+    const pathParts = path.split(".");
+    if (pathParts.length >= patternParts.length) {
+      return false;
+    }
+    for (let i = 0; i < pathParts.length; i++) {
+      const pathPart = pathParts[i];
+      const patternPart = patternParts[i];
+      if (patternPart === "*") {
+        continue;
+      }
+      if (pathPart !== patternPart) {
+        return false;
+      }
+    }
+    return true;
+  } else {
+    return pattern.startsWith(`${path}.`);
+  }
+}
+function applyKeyFiltering(value, { rejectKeys, filterKeys }, currentPath = "", visited = /* @__PURE__ */ new Set()) {
+  if (!isPlainObject(value) && !Array.isArray(value)) {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    if (visited.has(value)) {
+      throw new Error(
+        "Circular reference detected in array during key filtering"
+      );
+    }
+    visited.add(value);
+    try {
+      return value.map(
+        (item, index) => applyKeyFiltering(
+          item,
+          { rejectKeys, filterKeys },
+          currentPath ? `${currentPath}[${index}]` : `[${index}]`,
+          visited
+        )
+      );
+    } finally {
+      visited.delete(value);
+    }
+  }
+  if (isPlainObject(value)) {
+    if (visited.has(value)) {
+      throw new Error(
+        "Circular reference detected in object during key filtering"
+      );
+    }
+    visited.add(value);
+    try {
+      const result = {};
+      for (const [key, itemValue] of Object.entries(value)) {
+        const fullPath = currentPath ? `${currentPath}.${key}` : key;
+        if (rejectKeys?.some(
+          (rejectPath) => matchesKeyPattern(fullPath, key, rejectPath, currentPath)
+        )) {
+          continue;
+        }
+        if (filterKeys) {
+          const exactMatch = filterKeys.some(
+            (filterPath) => matchesKeyPattern(fullPath, key, filterPath, currentPath)
+          );
+          const isParent = filterKeys.some(
+            (filterPath) => isParentOfPattern(fullPath, filterPath)
+          );
+          if (!exactMatch && !isParent) {
+            continue;
+          }
+          if (exactMatch) {
+            result[key] = applyKeyFiltering(
+              itemValue,
+              { rejectKeys },
+              fullPath,
+              visited
+            );
+          } else {
+            result[key] = applyKeyFiltering(
+              itemValue,
+              { rejectKeys, filterKeys },
+              fullPath,
+              visited
+            );
+          }
+        } else {
+          result[key] = applyKeyFiltering(
+            itemValue,
+            { rejectKeys, filterKeys },
+            fullPath,
+            visited
+          );
+        }
+      }
+      return result;
+    } finally {
+      visited.delete(value);
+    }
+  }
+  return value;
+}
+function compactSnapshot(value, {
+  collapseObjects = true,
+  maxLineLength = 100,
+  showUndefined = false,
+  showBooleansAs = true,
+  rejectKeys,
+  filterKeys,
+  ...options
+} = {}) {
+  let processedValue = value;
+  if (rejectKeys || filterKeys) {
+    processedValue = applyKeyFiltering(processedValue, {
+      rejectKeys: Array.isArray(rejectKeys) ? rejectKeys : rejectKeys ? [rejectKeys] : void 0,
+      filterKeys: Array.isArray(filterKeys) ? filterKeys : filterKeys ? [filterKeys] : void 0
+    });
+  }
+  processedValue = showBooleansAs ? replaceBooleansWithEmoji(processedValue, showBooleansAs) : processedValue;
+  return `
+${yamlStringify(processedValue, {
+    collapseObjects,
+    maxLineLength,
+    showUndefined,
+    ...options
+  })}`;
+}
+function replaceBooleansWithEmoji(value, showBooleansAs, visited = /* @__PURE__ */ new Set()) {
+  if (showBooleansAs === false) {
+    return value;
+  }
+  const defaultTrueText = "\u2705";
+  const defaultFalseText = "\u274C";
+  const config = typeof showBooleansAs === "boolean" ? { trueText: defaultTrueText, falseText: defaultFalseText } : {
+    trueText: showBooleansAs.trueText ?? defaultTrueText,
+    falseText: showBooleansAs.falseText ?? defaultFalseText,
+    props: showBooleansAs.props ?? {},
+    ignoreProps: showBooleansAs.ignoreProps ?? []
+  };
+  function processValue(val, propName) {
+    if (typeof val === "boolean") {
+      if (propName && config.ignoreProps?.includes(propName)) {
+        return val;
+      }
+      if (propName && config.props?.[propName]) {
+        const propConfig = config.props[propName];
+        if (propConfig === true) {
+          return val ? config.trueText : config.falseText;
+        }
+        return val ? propConfig.trueText ?? config.trueText : propConfig.falseText ?? config.falseText;
+      }
+      return val ? config.trueText : config.falseText;
+    }
+    if (Array.isArray(val)) {
+      if (visited.has(val)) {
+        throw new Error("Circular reference detected in array");
+      }
+      visited.add(val);
+      try {
+        return val.map((item) => processValue(item));
+      } finally {
+        visited.delete(val);
+      }
+    }
+    if (isPlainObject(val)) {
+      if (visited.has(val)) {
+        throw new Error("Circular reference detected in object");
+      }
+      visited.add(val);
+      try {
+        const result = {};
+        for (const [key, itemValue] of Object.entries(val)) {
+          result[key] = processValue(itemValue, key);
+        }
+        return result;
+      } finally {
+        visited.delete(val);
+      }
+    }
+    return val;
+  }
+  return processValue(value);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  compactSnapshot,
   createLoggerStore,
   getResultFn,
   waitController

package/lib/testUtils.d.cts

@@ -1,3 +1,5 @@
+import { YamlStringifyOptions } from './yamlStringify.cjs';
+
 declare function createLoggerStore({ filterKeys: defaultFilterKeys, rejectKeys: defaultRejectKeys, splitLongLines: defaultSplitLongLines, maxLineLengthBeforeSplit: defaultMaxLineLengthBeforeSplit, fromLastSnapshot: defaultFromLastSnapshot, arrays: defaultArrays, changesOnly: defaultChangesOnly, useEmojiForBooleans: defaultUseEmojiForBooleans, }?: {
     filterKeys?: string[];
     rejectKeys?: string[];
@@ -39,5 +41,69 @@ declare function waitController(): {
     stopWaiting: () => void;
     stopWaitingAfter: (ms: number) => void;
 };
+declare function compactSnapshot(value: unknown, { collapseObjects, maxLineLength, showUndefined, showBooleansAs, rejectKeys, filterKeys, ...options }?: YamlStringifyOptions & {
+    showBooleansAs?: boolean | {
+        props?: Record<string, {
+            trueText?: string;
+            falseText?: string;
+        } | true>;
+        ignoreProps?: string[];
+        trueText?: string;
+        falseText?: string;
+    };
+    /**
+     * Reject (exclude) keys from the snapshot using pattern matching.
+     *
+     * **Pattern Syntax:**
+     * - `'prop'` - Only root-level properties named 'prop'
+     * - `'prop.nested'` - Exact nested property paths like `obj.prop.nested`
+     * - `'*prop'` - Any property named exactly 'prop' at any level (root or nested)
+     * - `'*.prop'` - Any nested property named 'prop' (excludes root-level matches)
+     *
+     * **Examples:**
+     * ```typescript
+     * // Reject root-level 'secret' only
+     * rejectKeys: ['secret']
+     *
+     * // Reject nested 'password' properties only
+     * rejectKeys: ['*.password']
+     *
+     * // Reject any 'apiKey' property at any level
+     * rejectKeys: ['*apiKey']
+     *
+     * // Reject specific nested path
+     * rejectKeys: ['user.settings.theme']
+     * ```
+     */
+    rejectKeys?: string[] | string;
+    /**
+     * Filter (include only) keys that match the specified patterns.
+     *
+     * **Pattern Syntax:** (same as rejectKeys)
+     * - `'prop'` - Only root-level properties named 'prop'
+     * - `'prop.nested'` - Exact nested property paths like `obj.prop.nested`
+     * - `'*prop'` - Any property named exactly 'prop' at any level (root or nested)
+     * - `'*.prop'` - Any nested property named 'prop' (excludes root-level matches)
+     *
+     * **Examples:**
+     * ```typescript
+     * // Include only root-level 'user'
+     * filterKeys: ['user']
+     *
+     * // Include all 'name' properties at any level
+     * filterKeys: ['*name']
+     *
+     * // Include only nested 'id' properties
+     * filterKeys: ['*.id']
+     *
+     * // Include specific nested paths
+     * filterKeys: ['user.profile.email', 'settings.theme']
+     * ```
+     *
+     * **Note:** When filtering, parent paths are automatically included if needed
+     * to preserve the structure for nested matches.
+     */
+    filterKeys?: string[] | string;
+}): string;
 
-export { createLoggerStore, getResultFn, waitController };
+export { compactSnapshot, createLoggerStore, getResultFn, waitController };