@ls-stack/utils 3.22.0 → 3.24.0

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
+};

package/lib/concurrentCalls.cjs

@@ -44,7 +44,6 @@ function invariant(condition, error = "Invariant violation") {
   }
 }
 var isFunction2 = isFunction;
-var isPromise2 = isPromise;
 
 // src/arrayUtils.ts
 function truncateArray(array, maxLength, appendIfTruncated) {
@@ -80,23 +79,17 @@ var ConcurrentCalls = class {
   }
   resultifyAdd(...calls) {
     const processedCalls = calls.map((call) => {
-      if (isPromise2(call)) {
-        return call.then((value) => import_t_result.Result.ok(value)).catch((err) => import_t_result.Result.err((0, import_t_result.unknownToError)(err)));
-      } else {
-        const originalFn = call;
-        return async () => {
-          try {
-            const valueOrPromise = originalFn();
-            const value = isPromise2(valueOrPromise) ? await valueOrPromise : valueOrPromise;
-            return import_t_result.Result.ok(value);
-          } catch (err) {
-            return import_t_result.Result.err((0, import_t_result.unknownToError)(err));
-          }
-        };
-      }
+      return async () => {
+        try {
+          const valueOrPromise = call();
+          const value = isPromise(valueOrPromise) ? await valueOrPromise : valueOrPromise;
+          return import_t_result.Result.ok(value);
+        } catch (err) {
+          return import_t_result.Result.err((0, import_t_result.unknownToError)(err));
+        }
+      };
     });
-    const correctlyTypedProcessedCalls = processedCalls;
-    return this.add(...correctlyTypedProcessedCalls);
+    return this.add(...processedCalls);
   }
   async runAll({ delayStart } = {}) {
     invariant(!this.#alreadyRun, "Already run");
@@ -105,15 +98,10 @@ var ConcurrentCalls = class {
       const asyncResults = await Promise.all(
         this.#pendingCalls.map(async (fn, i) => {
           try {
-            const isP = isPromise2(fn);
             if (delayStart) {
-              invariant(
-                !isP,
-                "Delay start is not supported direct promise calls"
-              );
               await sleep(delayStart(i));
             }
-            const result = await (isP ? fn : fn());
+            const result = await fn();
             if (!result.ok) throw result.error;
             return result.value;
           } catch (exception) {
@@ -135,15 +123,10 @@ var ConcurrentCalls = class {
     const settledResults = await Promise.allSettled(
       this.#pendingCalls.map(async (callOrPromise, i) => {
         try {
-          const isP = isPromise2(callOrPromise);
           if (delayStart) {
-            invariant(
-              !isP,
-              "Delay start is not supported for direct promise calls"
-            );
             await sleep(delayStart(i));
           }
-          const result = await (isP ? callOrPromise : callOrPromise());
+          const result = await callOrPromise();
           if (!result.ok) {
             throw result.error;
           }
@@ -190,9 +173,10 @@ var ConcurrentCallsWithMetadata = class {
   }
   resultifyAdd(...items) {
     const processedItems = items.map(({ fn, metadata }) => {
-      const cb = isPromise2(fn) ? (0, import_t_result.resultify)(fn) : () => (0, import_t_result.resultify)(async () => {
-        const result = await fn();
-        return result;
+      const cb = () => (0, import_t_result.resultify)(async () => {
+        const valueOrPromise = fn();
+        const value = isPromise(valueOrPromise) ? await valueOrPromise : valueOrPromise;
+        return value;
       });
       return {
         fn: cb,
@@ -214,7 +198,7 @@ var ConcurrentCallsWithMetadata = class {
           if (delayStart) {
             await sleep(delayStart(i));
           }
-          const result = await (isPromise2(call.fn) ? call.fn : call.fn());
+          const result = await call.fn();
           if (!result.ok) {
             throw { metadata: call.metadata, error: result.error };
           }
@@ -261,7 +245,7 @@ var ConcurrentCallsWithMetadata = class {
           if (delayStart) {
             await sleep(delayStart(i));
           }
-          const result = await (isPromise2(call.fn) ? call.fn : call.fn());
+          const result = await call.fn();
           if (!result.ok) {
             throw result.error;
           }

package/lib/concurrentCalls.d.cts

@@ -12,7 +12,7 @@ type FailedCall<M, E extends Error = Error> = {
     metadata: M;
     error: E;
 };
-type Action<R, E extends Error> = (() => Promise<Result<R, E>>) | Promise<Result<R, E>>;
+type Action<R, E extends Error> = () => Promise<Result<R, E>>;
 type SettledResultWithMetadata<R, M, E extends Error = Error> = {
     ok: true;
     value: R;
@@ -26,7 +26,7 @@ type SettledResultWithMetadata<R, M, E extends Error = Error> = {
 declare class ConcurrentCalls<R = unknown, E extends Error = Error> {
     #private;
     add(...calls: Action<R, E>[]): this;
-    resultifyAdd(...calls: (Promise<R> | (() => R) | (() => Promise<R>))[]): this;
+    resultifyAdd(...calls: ((() => R) | (() => Promise<R>))[]): this;
     runAll({ delayStart }?: RunProps): Promise<Result<R[], E>>;
     runAllSettled({ delayStart }?: RunProps): Promise<{
         allFailed: boolean;
@@ -50,7 +50,7 @@ declare class ConcurrentCallsWithMetadata<M extends ValidMetadata, R = unknown,
         metadata: M;
     }[]): this;
     resultifyAdd(...items: {
-        fn: (() => R) | (() => Promise<R>) | Promise<R>;
+        fn: (() => R) | (() => Promise<R>);
         metadata: M;
     }[]): this;
     runAll({ delayStart }?: RunProps): Promise<Result<SucceededCall<R, M>[], FailedCall<M, E>>>;

package/lib/concurrentCalls.d.ts

@@ -12,7 +12,7 @@ type FailedCall<M, E extends Error = Error> = {
     metadata: M;
     error: E;
 };
-type Action<R, E extends Error> = (() => Promise<Result<R, E>>) | Promise<Result<R, E>>;
+type Action<R, E extends Error> = () => Promise<Result<R, E>>;
 type SettledResultWithMetadata<R, M, E extends Error = Error> = {
     ok: true;
     value: R;
@@ -26,7 +26,7 @@ type SettledResultWithMetadata<R, M, E extends Error = Error> = {
 declare class ConcurrentCalls<R = unknown, E extends Error = Error> {
     #private;
     add(...calls: Action<R, E>[]): this;
-    resultifyAdd(...calls: (Promise<R> | (() => R) | (() => Promise<R>))[]): this;
+    resultifyAdd(...calls: ((() => R) | (() => Promise<R>))[]): this;
     runAll({ delayStart }?: RunProps): Promise<Result<R[], E>>;
     runAllSettled({ delayStart }?: RunProps): Promise<{
         allFailed: boolean;
@@ -50,7 +50,7 @@ declare class ConcurrentCallsWithMetadata<M extends ValidMetadata, R = unknown,
         metadata: M;
     }[]): this;
     resultifyAdd(...items: {
-        fn: (() => R) | (() => Promise<R>) | Promise<R>;
+        fn: (() => R) | (() => Promise<R>);
         metadata: M;
     }[]): this;
     runAll({ delayStart }?: RunProps): Promise<Result<SucceededCall<R, M>[], FailedCall<M, E>>>;

package/lib/concurrentCalls.js

@@ -8,10 +8,11 @@ import {
   truncateArray
 } from "./chunk-SRVMMYSW.js";
 import {
-  invariant,
-  isPromise
+  invariant
 } from "./chunk-C2SVCIWE.js";
-import "./chunk-JF2MDHOJ.js";
+import {
+  isPromise
+} from "./chunk-JF2MDHOJ.js";
 
 // src/concurrentCalls.ts
 import { Result, resultify, unknownToError } from "t-result";
@@ -24,23 +25,17 @@ var ConcurrentCalls = class {
   }
   resultifyAdd(...calls) {
     const processedCalls = calls.map((call) => {
-      if (isPromise(call)) {
-        return call.then((value) => Result.ok(value)).catch((err) => Result.err(unknownToError(err)));
-      } else {
-        const originalFn = call;
-        return async () => {
-          try {
-            const valueOrPromise = originalFn();
-            const value = isPromise(valueOrPromise) ? await valueOrPromise : valueOrPromise;
-            return Result.ok(value);
-          } catch (err) {
-            return Result.err(unknownToError(err));
-          }
-        };
-      }
+      return async () => {
+        try {
+          const valueOrPromise = call();
+          const value = isPromise(valueOrPromise) ? await valueOrPromise : valueOrPromise;
+          return Result.ok(value);
+        } catch (err) {
+          return Result.err(unknownToError(err));
+        }
+      };
     });
-    const correctlyTypedProcessedCalls = processedCalls;
-    return this.add(...correctlyTypedProcessedCalls);
+    return this.add(...processedCalls);
   }
   async runAll({ delayStart } = {}) {
     invariant(!this.#alreadyRun, "Already run");
@@ -49,15 +44,10 @@ var ConcurrentCalls = class {
       const asyncResults = await Promise.all(
         this.#pendingCalls.map(async (fn, i) => {
           try {
-            const isP = isPromise(fn);
             if (delayStart) {
-              invariant(
-                !isP,
-                "Delay start is not supported direct promise calls"
-              );
               await sleep(delayStart(i));
             }
-            const result = await (isP ? fn : fn());
+            const result = await fn();
             if (!result.ok) throw result.error;
             return result.value;
           } catch (exception) {
@@ -79,15 +69,10 @@ var ConcurrentCalls = class {
     const settledResults = await Promise.allSettled(
       this.#pendingCalls.map(async (callOrPromise, i) => {
         try {
-          const isP = isPromise(callOrPromise);
           if (delayStart) {
-            invariant(
-              !isP,
-              "Delay start is not supported for direct promise calls"
-            );
             await sleep(delayStart(i));
           }
-          const result = await (isP ? callOrPromise : callOrPromise());
+          const result = await callOrPromise();
           if (!result.ok) {
             throw result.error;
           }
@@ -134,9 +119,10 @@ var ConcurrentCallsWithMetadata = class {
   }
   resultifyAdd(...items) {
     const processedItems = items.map(({ fn, metadata }) => {
-      const cb = isPromise(fn) ? resultify(fn) : () => resultify(async () => {
-        const result = await fn();
-        return result;
+      const cb = () => resultify(async () => {
+        const valueOrPromise = fn();
+        const value = isPromise(valueOrPromise) ? await valueOrPromise : valueOrPromise;
+        return value;
       });
       return {
         fn: cb,
@@ -158,7 +144,7 @@ var ConcurrentCallsWithMetadata = class {
           if (delayStart) {
             await sleep(delayStart(i));
           }
-          const result = await (isPromise(call.fn) ? call.fn : call.fn());
+          const result = await call.fn();
           if (!result.ok) {
             throw { metadata: call.metadata, error: result.error };
           }
@@ -205,7 +191,7 @@ var ConcurrentCallsWithMetadata = class {
           if (delayStart) {
             await sleep(delayStart(i));
           }
-          const result = await (isPromise(call.fn) ? call.fn : call.fn());
+          const result = await call.fn();
           if (!result.ok) {
             throw result.error;
           }