@ls-stack/utils 3.23.0 → 3.24.1

package/docs/testUtils.md

@@ -8,13 +8,37 @@
 
 ## Functions
 
+### compactSnapshot()
+
+```ts
+function compactSnapshot(value, __namedParameters): string;
+```
+
+Defined in: [packages/utils/src/testUtils.ts:487](https://github.com/lucasols/utils/blob/main/packages/utils/src/testUtils.ts#L487)
+
+#### Parameters
+
+##### value
+
+`unknown`
+
+##### \_\_namedParameters
+
+[`YamlStringifyOptions`](yamlStringify.md#yamlstringifyoptions) & `object` = `{}`
+
+#### Returns
+
+`string`
+
+***
+
 ### createLoggerStore()
 
 ```ts
 function createLoggerStore(__namedParameters): object;
 ```
 
-Defined in: [packages/utils/src/testUtils.ts:8](https://github.com/lucasols/utils/blob/main/packages/utils/src/testUtils.ts#L8)
+Defined in: [packages/utils/src/testUtils.ts:10](https://github.com/lucasols/utils/blob/main/packages/utils/src/testUtils.ts#L10)
 
 #### Parameters
 
@@ -246,7 +270,7 @@ get snapshotFromLast(): string;
 function getResultFn<T>(fnGetter, wrapper?): T;
 ```
 
-Defined in: [packages/utils/src/testUtils.ts:274](https://github.com/lucasols/utils/blob/main/packages/utils/src/testUtils.ts#L274)
+Defined in: [packages/utils/src/testUtils.ts:276](https://github.com/lucasols/utils/blob/main/packages/utils/src/testUtils.ts#L276)
 
 #### Type Parameters
 
@@ -276,7 +300,7 @@ Defined in: [packages/utils/src/testUtils.ts:274](https://github.com/lucasols/ut
 function waitController(): object;
 ```
 
-Defined in: [packages/utils/src/testUtils.ts:289](https://github.com/lucasols/utils/blob/main/packages/utils/src/testUtils.ts#L289)
+Defined in: [packages/utils/src/testUtils.ts:291](https://github.com/lucasols/utils/blob/main/packages/utils/src/testUtils.ts#L291)
 
 #### Returns
 

package/docs/yamlStringify.md

@@ -6,39 +6,77 @@
 
 # yamlStringify
 
-## Functions
+## Type Aliases
 
-### yamlStringify()
+### YamlStringifyOptions
 
 ```ts
-function yamlStringify(obj, __namedParameters): string;
+type YamlStringifyOptions = object;
 ```
 
 Defined in: [packages/utils/src/yamlStringify.ts:5](https://github.com/lucasols/utils/blob/main/packages/utils/src/yamlStringify.ts#L5)
 
-#### Parameters
+#### Properties
 
-##### obj
+##### addRootObjSpaces?
 
-`unknown`
+```ts
+optional addRootObjSpaces: "before" | "after" | "beforeAndAfter" | false;
+```
 
-##### \_\_namedParameters
+Defined in: [packages/utils/src/yamlStringify.ts:15](https://github.com/lucasols/utils/blob/main/packages/utils/src/yamlStringify.ts#L15)
+
+##### collapseObjects?
 
-###### addRootObjSpaces?
+```ts
+optional collapseObjects: boolean;
+```
+
+Defined in: [packages/utils/src/yamlStringify.ts:13](https://github.com/lucasols/utils/blob/main/packages/utils/src/yamlStringify.ts#L13)
+
+##### maxDepth?
+
+```ts
+optional maxDepth: number;
+```
 
-`false` \| `"beforeAndAfter"` \| `"before"` \| `"after"` = `'beforeAndAfter'`
+Defined in: [packages/utils/src/yamlStringify.ts:11](https://github.com/lucasols/utils/blob/main/packages/utils/src/yamlStringify.ts#L11)
 
-###### maxDepth?
+##### maxLineLength?
 
-`number` = `50`
+```ts
+optional maxLineLength: number;
+```
 
-###### maxLineLength?
+Defined in: [packages/utils/src/yamlStringify.ts:7](https://github.com/lucasols/utils/blob/main/packages/utils/src/yamlStringify.ts#L7)
 
-`number` = `100`
+##### showUndefined?
 
-###### showUndefined?
+```ts
+optional showUndefined: boolean;
+```
+
+Defined in: [packages/utils/src/yamlStringify.ts:9](https://github.com/lucasols/utils/blob/main/packages/utils/src/yamlStringify.ts#L9)
+
+## Functions
+
+### yamlStringify()
+
+```ts
+function yamlStringify(obj, __namedParameters): string;
+```
+
+Defined in: [packages/utils/src/yamlStringify.ts:18](https://github.com/lucasols/utils/blob/main/packages/utils/src/yamlStringify.ts#L18)
+
+#### Parameters
+
+##### obj
+
+`unknown`
+
+##### \_\_namedParameters
 
-`boolean`
+[`YamlStringifyOptions`](#yamlstringifyoptions) = `{}`
 
 #### Returns
 

package/lib/chunk-JAPKLFIK.js

@@ -0,0 +1,353 @@
+import {
+  bytesToHumanReadable
+} from "./chunk-IATIXMCE.js";
+import {
+  truncateString
+} from "./chunk-4REIIZQY.js";
+import {
+  isObject,
+  isPlainObject
+} from "./chunk-JF2MDHOJ.js";
+
+// 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;
+}
+
+export {
+  yamlStringify
+};