@sv443-network/coreutils 3.3.0 → 3.5.0

package/dist/CoreUtils.mjs

@@ -368,12 +368,45 @@ function getCallStack(asArray, lines = Infinity) {
   if (typeof lines !== "number" || isNaN(lines) || lines < 0)
     throw new TypeError("lines parameter must be a non-negative number");
   try {
-    throw new Error("This is to capture a stack trace with CoreUtils.getCallStack(). (If you see this somewhere, you can safely ignore it.)");
+    throw new CustomError("GetCallStack", "Capturing a stack trace with CoreUtils.getCallStack(). If you see this anywhere, you can safely ignore it.");
   } catch (err) {
     const stack = (err.stack ?? "").split("\n").map((line) => line.trim()).slice(2, lines + 2);
     return asArray !== false ? stack : stack.join("\n");
   }
 }
+function createRecurringTask(options) {
+  var _a;
+  let iterations = 0;
+  let aborted = false;
+  (_a = options.signal) == null ? void 0 : _a.addEventListener("abort", () => {
+    aborted = true;
+  }, { once: true });
+  const runRecurringTask = async (initial = false) => {
+    var _a2;
+    if (aborted)
+      return;
+    try {
+      if ((options.immediate ?? true) || !initial) {
+        iterations++;
+        if (await ((_a2 = options.condition) == null ? void 0 : _a2.call(options, iterations - 1)) ?? true) {
+          const val = await options.task(iterations - 1);
+          if (options.onSuccess)
+            await options.onSuccess(val, iterations - 1);
+        }
+      }
+    } catch (err) {
+      if (options.onError)
+        await options.onError(err, iterations - 1);
+      if (options.abortOnError)
+        aborted = true;
+      if (!options.onError && !options.abortOnError)
+        throw err;
+    }
+    if (!aborted && (typeof options.maxIterations !== "number" || iterations < options.maxIterations))
+      setTimeout(runRecurringTask, options.timeout);
+  };
+  return runRecurringTask(true);
+}
 
 // lib/text.ts
 function autoPlural(term, num, pluralType = "auto") {
@@ -462,6 +495,173 @@ function truncStr(input, length, endStr = "...") {
   const finalStr = str.length > length ? str.substring(0, length - endStr.length) + endStr : str;
   return finalStr.length > length ? finalStr.substring(0, length) : finalStr;
 }
+var defaultTableLineCharset = {
+  single: {
+    horizontal: "\u2500",
+    vertical: "\u2502",
+    topLeft: "\u250C",
+    topRight: "\u2510",
+    bottomLeft: "\u2514",
+    bottomRight: "\u2518",
+    leftT: "\u251C",
+    rightT: "\u2524",
+    topT: "\u252C",
+    bottomT: "\u2534",
+    cross: "\u253C"
+  },
+  double: {
+    horizontal: "\u2550",
+    vertical: "\u2551",
+    topLeft: "\u2554",
+    topRight: "\u2557",
+    bottomLeft: "\u255A",
+    bottomRight: "\u255D",
+    leftT: "\u2560",
+    rightT: "\u2563",
+    topT: "\u2566",
+    bottomT: "\u2569",
+    cross: "\u256C"
+  },
+  none: {
+    horizontal: " ",
+    vertical: " ",
+    topLeft: " ",
+    topRight: " ",
+    bottomLeft: " ",
+    bottomRight: " ",
+    leftT: " ",
+    rightT: " ",
+    topT: " ",
+    bottomT: " ",
+    cross: " "
+  }
+};
+function createTable(rows, options) {
+  var _a;
+  const opts = {
+    columnAlign: "left",
+    truncateAbove: Infinity,
+    truncEndStr: "\u2026",
+    minPadding: 1,
+    lineStyle: "single",
+    applyCellStyle: () => void 0,
+    applyLineStyle: () => void 0,
+    lineCharset: defaultTableLineCharset,
+    ...options ?? {}
+  };
+  const defRange = (val, min, max) => clamp(typeof val !== "number" || isNaN(Number(val)) ? min : val, min, max);
+  opts.truncateAbove = defRange(opts.truncateAbove, 0, Infinity);
+  opts.minPadding = defRange(opts.minPadding, 0, Infinity);
+  const lnCh = opts.lineCharset[opts.lineStyle];
+  const stripAnsi = (str) => str.replace(/\u001b\[[0-9;]*m/g, "");
+  const stringRows = rows.map((row) => row.map((cell) => String(cell)));
+  const colCount = ((_a = rows[0]) == null ? void 0 : _a.length) ?? 0;
+  if (colCount === 0 || stringRows.length === 0)
+    return "";
+  if (isFinite(opts.truncateAbove)) {
+    const truncAnsi = (str, maxVisible, endStr) => {
+      const limit = maxVisible - endStr.length;
+      if (limit <= 0)
+        return endStr.slice(0, maxVisible);
+      let visible = 0;
+      let result = "";
+      let i = 0;
+      let hasAnsi = false;
+      while (i < str.length) {
+        if (str[i] === "\x1B" && str[i + 1] === "[") {
+          const seqEnd = str.indexOf("m", i + 2);
+          if (seqEnd !== -1) {
+            result += str.slice(i, seqEnd + 1);
+            hasAnsi = true;
+            i = seqEnd + 1;
+            continue;
+          }
+        }
+        if (visible === limit) {
+          result += endStr;
+          if (hasAnsi)
+            result += "\x1B[0m";
+          return result;
+        }
+        result += str[i];
+        visible++;
+        i++;
+      }
+      return result;
+    };
+    for (const row of stringRows)
+      for (let j = 0; j < row.length; j++)
+        if (stripAnsi(row[j] ?? "").length > opts.truncateAbove)
+          row[j] = truncAnsi(row[j] ?? "", opts.truncateAbove, opts.truncEndStr);
+  }
+  const colWidths = Array.from(
+    { length: colCount },
+    (_, j) => Math.max(0, ...stringRows.map((row) => stripAnsi(row[j] ?? "").length))
+  );
+  const applyLn = (i, j, ch) => {
+    const [before = "", after = ""] = opts.applyLineStyle(i, j) ?? [];
+    return `${before}${ch}${after}`;
+  };
+  const buildBorderRow = (lineIdx, leftCh, midCh, rightCh) => {
+    let result = "";
+    let j = 0;
+    result += applyLn(lineIdx, j++, leftCh);
+    for (let col = 0; col < colCount; col++) {
+      const cellWidth = (colWidths[col] ?? 0) + opts.minPadding * 2;
+      for (let ci = 0; ci < cellWidth; ci++)
+        result += applyLn(lineIdx, j++, lnCh.horizontal);
+      if (col < colCount - 1)
+        result += applyLn(lineIdx, j++, midCh);
+    }
+    result += applyLn(lineIdx, j++, rightCh);
+    return result;
+  };
+  const lines = [];
+  for (let rowIdx = 0; rowIdx < stringRows.length; rowIdx++) {
+    const row = stringRows[rowIdx] ?? [];
+    const lineIdxBase = rowIdx * 3;
+    if (opts.lineStyle !== "none") {
+      lines.push(
+        rowIdx === 0 ? buildBorderRow(lineIdxBase, lnCh.topLeft, lnCh.topT, lnCh.topRight) : buildBorderRow(lineIdxBase, lnCh.leftT, lnCh.cross, lnCh.rightT)
+      );
+    }
+    let contentLine = "";
+    let j = 0;
+    contentLine += applyLn(lineIdxBase + 1, j++, lnCh.vertical);
+    for (let colIdx = 0; colIdx < colCount; colIdx++) {
+      const cell = row[colIdx] ?? "";
+      const visLen = stripAnsi(cell).length;
+      const extra = (colWidths[colIdx] ?? 0) - visLen;
+      const align = (Array.isArray(opts.columnAlign) ? opts.columnAlign[colIdx] : opts.columnAlign) ?? "left";
+      let leftPad;
+      let rightPad;
+      switch (align) {
+        case "right":
+          leftPad = opts.minPadding + extra;
+          rightPad = opts.minPadding;
+          break;
+        case "centerLeft":
+          leftPad = opts.minPadding + Math.floor(extra / 2);
+          rightPad = opts.minPadding + Math.ceil(extra / 2);
+          break;
+        case "centerRight":
+          leftPad = opts.minPadding + Math.ceil(extra / 2);
+          rightPad = opts.minPadding + Math.floor(extra / 2);
+          break;
+        default:
+          leftPad = opts.minPadding;
+          rightPad = opts.minPadding + extra;
+      }
+      const [cellBefore = "", cellAfter = ""] = opts.applyCellStyle(rowIdx, colIdx) ?? [];
+      contentLine += " ".repeat(leftPad) + cellBefore + cell + cellAfter + " ".repeat(rightPad);
+      contentLine += applyLn(lineIdxBase + 1, j++, lnCh.vertical);
+    }
+    lines.push(contentLine);
+    if (opts.lineStyle !== "none" && rowIdx === stringRows.length - 1)
+      lines.push(buildBorderRow(lineIdxBase + 2, lnCh.bottomLeft, lnCh.bottomT, lnCh.bottomRight));
+  }
+  return lines.join("\n");
+}
 
 // node_modules/.pnpm/nanoevents@9.1.0/node_modules/nanoevents/index.js
 var createNanoEvents = () => ({
@@ -1172,6 +1372,7 @@ var FileStorageEngine = class extends DataStoreEngine {
 // lib/DataStoreSerializer.ts
 var DataStoreSerializer = class _DataStoreSerializer {
   stores;
+  // eslint-disable-line @typescript-eslint/no-explicit-any
   options;
   constructor(stores, options = {}) {
     if (!crypto || !crypto.subtle)
@@ -1184,7 +1385,10 @@ var DataStoreSerializer = class _DataStoreSerializer {
       ...options
     };
   }
-  /** Calculates the checksum of a string */
+  /**
+   * Calculates the checksum of a string. Uses {@linkcode computeHash()} with SHA-256 and digests as a hex string by default.  
+   * Override this in a subclass if a custom checksum method is needed.
+   */
   async calcChecksum(input) {
     return computeHash(input, "SHA-256");
   }
@@ -1315,8 +1519,8 @@ var Debouncer = class extends NanoEmitter {
    * @param timeout Timeout in milliseconds between letting through calls - defaults to 200
    * @param type The edge type to use for the debouncer - see {@linkcode DebouncerType} for details or [the documentation for an explanation and diagram](https://github.com/Sv443-Network/UserUtils/blob/main/docs.md#debouncer) - defaults to "immediate"
    */
-  constructor(timeout = 200, type = "immediate") {
-    super();
+  constructor(timeout = 200, type = "immediate", nanoEmitterOptions) {
+    super(nanoEmitterOptions);
     this.timeout = timeout;
     this.type = type;
   }
@@ -1347,7 +1551,7 @@ var Debouncer = class extends NanoEmitter {
   //#region timeout
   /** Sets the timeout for the debouncer */
   setTimeout(timeout) {
-    this.emit("change", this.timeout = timeout, this.type);
+    this.events.emit("change", this.timeout = timeout, this.type);
   }
   /** Returns the current timeout */
   getTimeout() {
@@ -1360,7 +1564,7 @@ var Debouncer = class extends NanoEmitter {
   //#region type
   /** Sets the edge type for the debouncer */
   setType(type) {
-    this.emit("change", this.timeout, this.type = type);
+    this.events.emit("change", this.timeout, this.type = type);
   }
   /** Returns the current edge type */
   getType() {
@@ -1371,7 +1575,7 @@ var Debouncer = class extends NanoEmitter {
   call(...args) {
     const cl = (...a) => {
       this.queuedCall = void 0;
-      this.emit("call", ...a);
+      this.events.emit("call", ...a);
       this.listeners.forEach((l) => l.call(this, ...a));
     };
     const setRepeatTimeout = () => {
@@ -1404,8 +1608,8 @@ var Debouncer = class extends NanoEmitter {
     }
   }
 };
-function debounce(fn, timeout = 200, type = "immediate") {
-  const debouncer = new Debouncer(timeout, type);
+function debounce(fn, timeout = 200, type = "immediate", nanoEmitterOptions) {
+  const debouncer = new Debouncer(timeout, type, nanoEmitterOptions);
   debouncer.addListener(fn);
   const func = ((...args) => debouncer.call(...args));
   func.debouncer = debouncer;
@@ -1437,10 +1641,13 @@ export {
   consumeGen,
   consumeStringGen,
   createProgressBar,
+  createRecurringTask,
+  createTable,
   darkenColor,
   debounce,
   decompress,
   defaultPbChars,
+  defaultTableLineCharset,
   digitCount,
   fetchAdvanced,
   formatNumber,