@ls-stack/utils 1.13.2 → 2.0.0

package/dist/typingFnUtils.cjs

@@ -0,0 +1,55 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/typingFnUtils.ts
+var typingFnUtils_exports = {};
+__export(typingFnUtils_exports, {
+  asNonPartial: () => asNonPartial,
+  asType: () => asType,
+  narrowStringToUnion: () => narrowStringToUnion,
+  typedObjectEntries: () => typedObjectEntries,
+  typedObjectKeys: () => typedObjectKeys
+});
+module.exports = __toCommonJS(typingFnUtils_exports);
+function asNonPartial(obj) {
+  return obj;
+}
+function typedObjectEntries(obj) {
+  return Object.entries(obj);
+}
+function typedObjectKeys(obj) {
+  return Object.keys(obj);
+}
+function asType(value) {
+  return value;
+}
+function narrowStringToUnion(key, union) {
+  if (key && union.includes(key)) {
+    return key;
+  }
+  return void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  asNonPartial,
+  asType,
+  narrowStringToUnion,
+  typedObjectEntries,
+  typedObjectKeys
+});

package/dist/typingFnUtils.d.cts

@@ -0,0 +1,15 @@
+import { NonPartial } from './typingUtils.cjs';
+
+declare function asNonPartial<T extends Record<string, unknown>>(obj: T): NonPartial<T>;
+/** a wrapper to Object.entries with a better typing inference */
+declare function typedObjectEntries<T extends Record<string, unknown>>(obj: T): NonNullable<{
+    [K in keyof T]: [K, T[K]];
+}[keyof T]>[];
+/** a wrapper to Object.keys with a better typing inference */
+declare function typedObjectKeys<T extends Record<string, unknown>>(obj: T): (keyof T)[];
+/** a safe way to cast types, use to substitute the `as Type` */
+declare function asType<T = unknown>(value: T): T;
+/** narrow a string to a union of strings */
+declare function narrowStringToUnion<const T extends string>(key: string | undefined | null, union: T[]): T | undefined;
+
+export { asNonPartial, asType, narrowStringToUnion, typedObjectEntries, typedObjectKeys };

package/dist/typingFnUtils.js

@@ -24,4 +24,3 @@ export {
   typedObjectEntries,
   typedObjectKeys
 };
-//# sourceMappingURL=typingFnUtils.js.map

package/dist/typingTestUtils.cjs

@@ -0,0 +1,43 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/typingTestUtils.ts
+var typingTestUtils_exports = {};
+__export(typingTestUtils_exports, {
+  typingTest: () => typingTest
+});
+module.exports = __toCommonJS(typingTestUtils_exports);
+function test(title, func) {
+  func();
+}
+function describe(title, func) {
+  func();
+}
+function expectType() {
+  return {};
+}
+var typingTest = {
+  test,
+  describe,
+  expectType
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  typingTest
+});

package/dist/typingTestUtils.d.cts

@@ -0,0 +1,12 @@
+type TestTypeIsEqual<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;
+type TestTypeNotEqual<X, Y> = true extends TestTypeIsEqual<X, Y> ? false : true;
+declare function test(title: string, func: () => any): void;
+declare function describe(title: string, func: () => any): void;
+declare function expectType<T extends true>(): T;
+declare const typingTest: {
+    test: typeof test;
+    describe: typeof describe;
+    expectType: typeof expectType;
+};
+
+export { type TestTypeIsEqual, type TestTypeNotEqual, typingTest };

package/dist/typingTestUtils.js

@@ -16,4 +16,3 @@ var typingTest = {
 export {
   typingTest
 };
-//# sourceMappingURL=typingTestUtils.js.map

package/dist/typingUtils.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/typingUtils.ts
+var typingUtils_exports = {};
+module.exports = __toCommonJS(typingUtils_exports);

package/dist/typingUtils.d.cts

@@ -0,0 +1,11 @@
+type PartialRecord<K extends keyof any, T> = {
+    [P in K]?: T;
+};
+type NonPartial<T> = {
+    [K in keyof Required<T>]: T[K];
+};
+type ObjKeysWithValuesOfType<Obj extends Record<PropertyKey, unknown>, ValueType> = {
+    [K in keyof Obj]: Obj[K] extends ValueType ? K : never;
+}[keyof Obj];
+
+export type { NonPartial, ObjKeysWithValuesOfType, PartialRecord };

package/dist/typingUtils.js

@@ -1 +0,0 @@
-//# sourceMappingURL=typingUtils.js.map

package/dist/yamlStringify.cjs

@@ -0,0 +1,346 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/yamlStringify.ts
+var yamlStringify_exports = {};
+__export(yamlStringify_exports, {
+  yamlStringify: () => yamlStringify
+});
+module.exports = __toCommonJS(yamlStringify_exports);
+
+// src/assertions.ts
+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/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,
+  addRootObjSpaces = "beforeAndAfter"
+} = {}) {
+  if (isObject(obj) || Array.isArray(obj) || typeof obj === "function") {
+    return `${stringifyValue(obj, "", maxLineLength, !!showUndefined, maxDepth, 0, addRootObjSpaces)}
+`;
+  }
+  return JSON.stringify(obj) || "undefined";
+}
+function stringifyValue(value, indent, maxLineLength, showUndefined, maxDepth, depth, addObjSpaces) {
+  let result = "";
+  const childIndent = `${indent}  `;
+  if (isPlainObject(value)) {
+    if (Object.keys(value).length === 0) {
+      return "{}";
+    }
+    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,
+        addObjSpaces
+      );
+      if (!afterSpaceWasAdded && indent === "" && isObject(objVal) && prevValue && (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)) {
+        if (Object.keys(objVal).length === 0) {
+          result += `${indent}${key}: `;
+        } else {
+          result += `${indent}${key}:
+`;
+        }
+      } else {
+        result += `${indent}${key}: `;
+      }
+      result += valueString;
+      result += "\n";
+      if (indent === "") {
+        if (isObject(objVal)) {
+          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,
+          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,
+            addObjSpaces
+          );
+          arrayString = arrayString.trimStart();
+          result += arrayString;
+        } else {
+          result += stringifyValue(
+            item,
+            childIndent,
+            maxLineLength,
+            showUndefined,
+            maxDepth,
+            depth + 1,
+            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("'")) {
+        result += `"${value}"`;
+      } 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,
+      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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  yamlStringify
+});

package/dist/yamlStringify.d.cts

@@ -0,0 +1,8 @@
+declare function yamlStringify(obj: unknown, { maxLineLength, showUndefined, maxDepth, addRootObjSpaces, }?: {
+    maxLineLength?: number;
+    showUndefined?: boolean;
+    maxDepth?: number;
+    addRootObjSpaces?: 'before' | 'after' | 'beforeAndAfter' | false;
+}): string;
+
+export { yamlStringify };

package/dist/yamlStringify.js

@@ -1,13 +1,13 @@
 import {
   truncateString
-} from "./chunk-GLZ5MZC5.js";
+} from "./chunk-V2L472LS.js";
 import {
   bytesToHumanReadable
-} from "./chunk-MMKMF4GG.js";
+} from "./chunk-IATIXMCE.js";
 import {
   isObject,
   isPlainObject
-} from "./chunk-FYMTZQ42.js";
+} from "./chunk-4UGSP3L3.js";
 
 // src/yamlStringify.ts
 function yamlStringify(obj, {
@@ -289,4 +289,3 @@ function normalizeValue(value) {
 export {
   yamlStringify
 };
-//# sourceMappingURL=yamlStringify.js.map