@ls-stack/utils 3.24.1 → 3.25.0

package/lib/chunk-XXYTMSFH.js

@@ -0,0 +1,240 @@
+import {
+  isPlainObject
+} from "./chunk-JF2MDHOJ.js";
+
+// src/filterObjectOrArrayKeys.ts
+function filterObjectOrArrayKeys(objOrArray, {
+  filterKeys,
+  rejectKeys,
+  rejectEmptyObjectsInArray = true
+}) {
+  const toArray = (v) => v === void 0 ? [] : Array.isArray(v) ? v : [v];
+  const filterPatternsRaw = toArray(filterKeys);
+  const rejectPatternsRaw = toArray(rejectKeys);
+  const hasFilters = filterPatternsRaw.length > 0;
+  const hasRejects = rejectPatternsRaw.length > 0;
+  function parsePattern(pattern) {
+    const tokens = [];
+    let i = 0;
+    const n = pattern.length;
+    const pushKey = (name) => {
+      if (name.length === 0) return;
+      tokens.push({ type: "KEY", name });
+    };
+    while (i < n) {
+      const ch = pattern[i];
+      if (ch === ".") {
+        i += 1;
+        continue;
+      }
+      if (ch === "[") {
+        const end = pattern.indexOf("]", i + 1);
+        const inside = end === -1 ? pattern.slice(i + 1) : pattern.slice(i + 1, end);
+        if (inside === "*") {
+          tokens.push({ type: "INDEX_ANY" });
+        } else if (inside.includes("-")) {
+          const parts = inside.split("-");
+          const startStr = parts[0] ?? "";
+          const endStr = parts[1] ?? "";
+          const start = parseInt(startStr, 10);
+          const endNum = endStr === "*" ? null : parseInt(endStr, 10);
+          tokens.push({
+            type: "INDEX_RANGE",
+            start,
+            end: endNum === null || Number.isFinite(endNum) ? endNum : null
+          });
+        } else if (inside.length > 0) {
+          const idx = parseInt(inside, 10);
+          tokens.push({ type: "INDEX", index: idx });
+        }
+        i = end === -1 ? n : end + 1;
+        continue;
+      }
+      if (ch === "*") {
+        if (pattern[i + 1] === "*") {
+          tokens.push({ type: "WILDCARD_ANY" });
+          i += 2;
+          let j2 = i;
+          while (j2 < n) {
+            const c = pattern[j2];
+            if (c === "." || c === "[") break;
+            j2 += 1;
+          }
+          if (j2 > i) {
+            pushKey(pattern.slice(i, j2));
+            i = j2;
+          }
+          continue;
+        } else {
+          tokens.push({ type: "WILDCARD_ONE" });
+          i += 1;
+          continue;
+        }
+      }
+      let j = i;
+      while (j < n) {
+        const c = pattern[j];
+        if (c === "." || c === "[") break;
+        j += 1;
+      }
+      pushKey(pattern.slice(i, j));
+      i = j;
+    }
+    return tokens;
+  }
+  const filterPatterns = filterPatternsRaw.map(parsePattern);
+  const rejectPatterns = rejectPatternsRaw.map(parsePattern);
+  function matchPath(path, pattern) {
+    function rec(pi, pti) {
+      if (pti >= pattern.length) return pi === path.length;
+      const pt = pattern[pti];
+      if (pt.type === "WILDCARD_ANY") {
+        if (rec(pi, pti + 1)) return true;
+        if (pi < path.length) return rec(pi + 1, pti);
+        return false;
+      }
+      if (pt.type === "WILDCARD_ONE") {
+        let j = pi;
+        let sawKey = false;
+        while (j < path.length) {
+          if (path[j].type === "KEY") sawKey = true;
+          if (sawKey && rec(j, pti + 1)) return true;
+          j += 1;
+        }
+        return false;
+      }
+      if (pi >= path.length) return false;
+      const ct = path[pi];
+      switch (pt.type) {
+        case "KEY":
+          if (ct.type === "KEY" && ct.name === pt.name)
+            return rec(pi + 1, pti + 1);
+          if (ct.type === "INDEX") return rec(pi + 1, pti);
+          return false;
+        case "INDEX":
+          if (ct.type === "INDEX" && ct.index === pt.index)
+            return rec(pi + 1, pti + 1);
+          return false;
+        case "INDEX_ANY":
+          if (ct.type === "INDEX") return rec(pi + 1, pti + 1);
+          return false;
+        case "INDEX_RANGE":
+          if (ct.type === "INDEX") {
+            const okLower = ct.index >= pt.start;
+            const okUpper = pt.end === null ? true : ct.index <= pt.end;
+            if (okLower && okUpper) return rec(pi + 1, pti + 1);
+          }
+          return false;
+      }
+    }
+    return rec(0, 0);
+  }
+  const matchesAnyFilter = (path) => filterPatterns.some((p) => matchPath(path, p));
+  const matchesAnyReject = (path) => rejectPatterns.some((p) => matchPath(path, p));
+  const build = (value, path, allowedByFilter, stack2, isRoot, parentIsArray) => {
+    if (Array.isArray(value)) {
+      if (stack2.has(value)) {
+        throw new TypeError("Circular references are not supported");
+      }
+      stack2.add(value);
+      const out = [];
+      const includeAllChildren = allowedByFilter || !hasFilters;
+      for (let index = 0; index < value.length; index += 1) {
+        const childPath = path.concat({ type: "INDEX", index });
+        if (hasRejects && matchesAnyReject(childPath)) continue;
+        const child = value[index];
+        const directInclude = hasFilters ? matchesAnyFilter(childPath) : true;
+        const childAllowed = includeAllChildren || directInclude;
+        if (isPlainObject(child) || Array.isArray(child)) {
+          const builtChild = build(
+            child,
+            childPath,
+            childAllowed,
+            stack2,
+            false,
+            true
+          );
+          if (builtChild !== void 0) {
+            out.push(builtChild);
+          }
+        } else {
+          if (childAllowed) {
+            out.push(child);
+          }
+        }
+      }
+      stack2.delete(value);
+      const filteredOut = rejectEmptyObjectsInArray ? out.filter(
+        (item) => !(isPlainObject(item) && Object.keys(item).length === 0)
+      ) : out;
+      if (filteredOut.length === 0 && !allowedByFilter && !isRoot)
+        return void 0;
+      return filteredOut;
+    }
+    if (isPlainObject(value)) {
+      if (stack2.has(value)) {
+        throw new TypeError("Circular references are not supported");
+      }
+      stack2.add(value);
+      const result = {};
+      const includeAllChildren = allowedByFilter || !hasFilters;
+      for (const key of Object.keys(value)) {
+        const childPath = path.concat({ type: "KEY", name: key });
+        if (hasRejects && matchesAnyReject(childPath)) continue;
+        const val = value[key];
+        const directInclude = hasFilters ? matchesAnyFilter(childPath) : true;
+        const childAllowed = includeAllChildren || directInclude;
+        if (isPlainObject(val) || Array.isArray(val)) {
+          const builtChild = build(
+            val,
+            childPath,
+            childAllowed,
+            stack2,
+            false,
+            false
+          );
+          if (builtChild === void 0) {
+            continue;
+          }
+          if (Array.isArray(builtChild) && builtChild.length === 0 && !childAllowed) {
+            continue;
+          }
+          if (isPlainObject(builtChild) && Object.keys(builtChild).length === 0 && !childAllowed) {
+            continue;
+          }
+          result[key] = builtChild;
+        } else {
+          if (childAllowed) {
+            result[key] = val;
+          }
+        }
+      }
+      stack2.delete(value);
+      if (Object.keys(result).length === 0 && !allowedByFilter && !isRoot) {
+        if (parentIsArray && !rejectEmptyObjectsInArray) {
+          return {};
+        }
+        return void 0;
+      }
+      return result;
+    }
+    return allowedByFilter || !hasFilters ? value : void 0;
+  };
+  const startPath = [];
+  const initialAllowed = !hasFilters;
+  const stack = /* @__PURE__ */ new WeakSet();
+  const built = build(
+    objOrArray,
+    startPath,
+    initialAllowed,
+    stack,
+    true,
+    false
+  );
+  if (built === void 0) return Array.isArray(objOrArray) ? [] : {};
+  return built;
+}
+
+export {
+  filterObjectOrArrayKeys
+};

package/lib/filterObjectOrArrayKeys.cjs

@@ -0,0 +1,275 @@
+"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/filterObjectOrArrayKeys.ts
+var filterObjectOrArrayKeys_exports = {};
+__export(filterObjectOrArrayKeys_exports, {
+  filterObjectOrArrayKeys: () => filterObjectOrArrayKeys
+});
+module.exports = __toCommonJS(filterObjectOrArrayKeys_exports);
+
+// src/typeGuards.ts
+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/filterObjectOrArrayKeys.ts
+function filterObjectOrArrayKeys(objOrArray, {
+  filterKeys,
+  rejectKeys,
+  rejectEmptyObjectsInArray = true
+}) {
+  const toArray = (v) => v === void 0 ? [] : Array.isArray(v) ? v : [v];
+  const filterPatternsRaw = toArray(filterKeys);
+  const rejectPatternsRaw = toArray(rejectKeys);
+  const hasFilters = filterPatternsRaw.length > 0;
+  const hasRejects = rejectPatternsRaw.length > 0;
+  function parsePattern(pattern) {
+    const tokens = [];
+    let i = 0;
+    const n = pattern.length;
+    const pushKey = (name) => {
+      if (name.length === 0) return;
+      tokens.push({ type: "KEY", name });
+    };
+    while (i < n) {
+      const ch = pattern[i];
+      if (ch === ".") {
+        i += 1;
+        continue;
+      }
+      if (ch === "[") {
+        const end = pattern.indexOf("]", i + 1);
+        const inside = end === -1 ? pattern.slice(i + 1) : pattern.slice(i + 1, end);
+        if (inside === "*") {
+          tokens.push({ type: "INDEX_ANY" });
+        } else if (inside.includes("-")) {
+          const parts = inside.split("-");
+          const startStr = parts[0] ?? "";
+          const endStr = parts[1] ?? "";
+          const start = parseInt(startStr, 10);
+          const endNum = endStr === "*" ? null : parseInt(endStr, 10);
+          tokens.push({
+            type: "INDEX_RANGE",
+            start,
+            end: endNum === null || Number.isFinite(endNum) ? endNum : null
+          });
+        } else if (inside.length > 0) {
+          const idx = parseInt(inside, 10);
+          tokens.push({ type: "INDEX", index: idx });
+        }
+        i = end === -1 ? n : end + 1;
+        continue;
+      }
+      if (ch === "*") {
+        if (pattern[i + 1] === "*") {
+          tokens.push({ type: "WILDCARD_ANY" });
+          i += 2;
+          let j2 = i;
+          while (j2 < n) {
+            const c = pattern[j2];
+            if (c === "." || c === "[") break;
+            j2 += 1;
+          }
+          if (j2 > i) {
+            pushKey(pattern.slice(i, j2));
+            i = j2;
+          }
+          continue;
+        } else {
+          tokens.push({ type: "WILDCARD_ONE" });
+          i += 1;
+          continue;
+        }
+      }
+      let j = i;
+      while (j < n) {
+        const c = pattern[j];
+        if (c === "." || c === "[") break;
+        j += 1;
+      }
+      pushKey(pattern.slice(i, j));
+      i = j;
+    }
+    return tokens;
+  }
+  const filterPatterns = filterPatternsRaw.map(parsePattern);
+  const rejectPatterns = rejectPatternsRaw.map(parsePattern);
+  function matchPath(path, pattern) {
+    function rec(pi, pti) {
+      if (pti >= pattern.length) return pi === path.length;
+      const pt = pattern[pti];
+      if (pt.type === "WILDCARD_ANY") {
+        if (rec(pi, pti + 1)) return true;
+        if (pi < path.length) return rec(pi + 1, pti);
+        return false;
+      }
+      if (pt.type === "WILDCARD_ONE") {
+        let j = pi;
+        let sawKey = false;
+        while (j < path.length) {
+          if (path[j].type === "KEY") sawKey = true;
+          if (sawKey && rec(j, pti + 1)) return true;
+          j += 1;
+        }
+        return false;
+      }
+      if (pi >= path.length) return false;
+      const ct = path[pi];
+      switch (pt.type) {
+        case "KEY":
+          if (ct.type === "KEY" && ct.name === pt.name)
+            return rec(pi + 1, pti + 1);
+          if (ct.type === "INDEX") return rec(pi + 1, pti);
+          return false;
+        case "INDEX":
+          if (ct.type === "INDEX" && ct.index === pt.index)
+            return rec(pi + 1, pti + 1);
+          return false;
+        case "INDEX_ANY":
+          if (ct.type === "INDEX") return rec(pi + 1, pti + 1);
+          return false;
+        case "INDEX_RANGE":
+          if (ct.type === "INDEX") {
+            const okLower = ct.index >= pt.start;
+            const okUpper = pt.end === null ? true : ct.index <= pt.end;
+            if (okLower && okUpper) return rec(pi + 1, pti + 1);
+          }
+          return false;
+      }
+    }
+    return rec(0, 0);
+  }
+  const matchesAnyFilter = (path) => filterPatterns.some((p) => matchPath(path, p));
+  const matchesAnyReject = (path) => rejectPatterns.some((p) => matchPath(path, p));
+  const build = (value, path, allowedByFilter, stack2, isRoot, parentIsArray) => {
+    if (Array.isArray(value)) {
+      if (stack2.has(value)) {
+        throw new TypeError("Circular references are not supported");
+      }
+      stack2.add(value);
+      const out = [];
+      const includeAllChildren = allowedByFilter || !hasFilters;
+      for (let index = 0; index < value.length; index += 1) {
+        const childPath = path.concat({ type: "INDEX", index });
+        if (hasRejects && matchesAnyReject(childPath)) continue;
+        const child = value[index];
+        const directInclude = hasFilters ? matchesAnyFilter(childPath) : true;
+        const childAllowed = includeAllChildren || directInclude;
+        if (isPlainObject(child) || Array.isArray(child)) {
+          const builtChild = build(
+            child,
+            childPath,
+            childAllowed,
+            stack2,
+            false,
+            true
+          );
+          if (builtChild !== void 0) {
+            out.push(builtChild);
+          }
+        } else {
+          if (childAllowed) {
+            out.push(child);
+          }
+        }
+      }
+      stack2.delete(value);
+      const filteredOut = rejectEmptyObjectsInArray ? out.filter(
+        (item) => !(isPlainObject(item) && Object.keys(item).length === 0)
+      ) : out;
+      if (filteredOut.length === 0 && !allowedByFilter && !isRoot)
+        return void 0;
+      return filteredOut;
+    }
+    if (isPlainObject(value)) {
+      if (stack2.has(value)) {
+        throw new TypeError("Circular references are not supported");
+      }
+      stack2.add(value);
+      const result = {};
+      const includeAllChildren = allowedByFilter || !hasFilters;
+      for (const key of Object.keys(value)) {
+        const childPath = path.concat({ type: "KEY", name: key });
+        if (hasRejects && matchesAnyReject(childPath)) continue;
+        const val = value[key];
+        const directInclude = hasFilters ? matchesAnyFilter(childPath) : true;
+        const childAllowed = includeAllChildren || directInclude;
+        if (isPlainObject(val) || Array.isArray(val)) {
+          const builtChild = build(
+            val,
+            childPath,
+            childAllowed,
+            stack2,
+            false,
+            false
+          );
+          if (builtChild === void 0) {
+            continue;
+          }
+          if (Array.isArray(builtChild) && builtChild.length === 0 && !childAllowed) {
+            continue;
+          }
+          if (isPlainObject(builtChild) && Object.keys(builtChild).length === 0 && !childAllowed) {
+            continue;
+          }
+          result[key] = builtChild;
+        } else {
+          if (childAllowed) {
+            result[key] = val;
+          }
+        }
+      }
+      stack2.delete(value);
+      if (Object.keys(result).length === 0 && !allowedByFilter && !isRoot) {
+        if (parentIsArray && !rejectEmptyObjectsInArray) {
+          return {};
+        }
+        return void 0;
+      }
+      return result;
+    }
+    return allowedByFilter || !hasFilters ? value : void 0;
+  };
+  const startPath = [];
+  const initialAllowed = !hasFilters;
+  const stack = /* @__PURE__ */ new WeakSet();
+  const built = build(
+    objOrArray,
+    startPath,
+    initialAllowed,
+    stack,
+    true,
+    false
+  );
+  if (built === void 0) return Array.isArray(objOrArray) ? [] : {};
+  return built;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  filterObjectOrArrayKeys
+});

package/lib/filterObjectOrArrayKeys.d.cts

@@ -0,0 +1,42 @@
+/**
+ * Filters the keys of an object based on the provided patterns.
+ *
+ * Filtering patterns in `rejectKeys` and `filterKeys`:
+ * - `'prop'` - Only root-level properties named 'prop'
+ * - `'**prop'` - Any property named exactly 'prop' at any level (root or nested)
+ * - `'*.prop'` - Any nested property named 'prop' at second level (excludes root-level matches)
+ * - `'test.*.prop'` - Any property named 'prop' at second level of 'test'
+ * - `'test.*.test.**prop'` - Any property named 'prop' inside of 'test.*.test'
+ * - `'prop.nested'` - Exact nested property paths like `obj.prop.nested`
+ * - `'prop.**nested'` - All nested properties inside root `prop` with name `nested`
+ * - `'prop[0]'` - The first item of the `prop` array
+ * - `'prop[*]'` - All items of the `prop` array
+ * - `'prop[0].nested'` - `nested` prop of the first item of the `prop` array
+ * - `'prop[*].nested'` - `nested` prop of all items of the `prop` array
+ * - `'prop[*]**nested'` - all `nested` props of all items of the `prop` array
+ * - `'prop[0-2]'` - The first three items of the `prop` array
+ * - `'prop[4-*]'` - All items of the `prop` array from the fourth index to the end
+ * - `'prop[0-2].nested.**prop'` - Combining multiple nested patterns is supported
+ * - Root array:
+ *   - `'[0]'` - The first item of the root array
+ *   - `'[*]'` - All items of the array
+ *   - `'[0].nested'` - `nested` prop of the first item of the array
+ *   - `'[*].nested'` - `nested` prop of all items of the array
+ *   - `'[*]**nested'` - all `nested` props of all items of the array
+ *   - `'[0-2]'` - The first three items of the array
+ *   - `'[4-*]'` - All items of the array from the fourth index to the end
+ *
+ * @param objOrArray - The object or array to filter.
+ * @param options - The options for the filter.
+ * @param options.filterKeys - The keys to filter.
+ * @param options.rejectKeys - The keys to reject.
+ * @param options.rejectEmptyObjectsInArray - Whether to reject empty objects in arrays (default: true).
+ * @returns The filtered object or array.
+ */
+declare function filterObjectOrArrayKeys(objOrArray: Record<string, any> | Record<string, any>[], { filterKeys, rejectKeys, rejectEmptyObjectsInArray, }: {
+    filterKeys?: string[] | string;
+    rejectKeys?: string[] | string;
+    rejectEmptyObjectsInArray?: boolean;
+}): Record<string, any> | Record<string, any>[];
+
+export { filterObjectOrArrayKeys };

package/lib/filterObjectOrArrayKeys.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Filters the keys of an object based on the provided patterns.
+ *
+ * Filtering patterns in `rejectKeys` and `filterKeys`:
+ * - `'prop'` - Only root-level properties named 'prop'
+ * - `'**prop'` - Any property named exactly 'prop' at any level (root or nested)
+ * - `'*.prop'` - Any nested property named 'prop' at second level (excludes root-level matches)
+ * - `'test.*.prop'` - Any property named 'prop' at second level of 'test'
+ * - `'test.*.test.**prop'` - Any property named 'prop' inside of 'test.*.test'
+ * - `'prop.nested'` - Exact nested property paths like `obj.prop.nested`
+ * - `'prop.**nested'` - All nested properties inside root `prop` with name `nested`
+ * - `'prop[0]'` - The first item of the `prop` array
+ * - `'prop[*]'` - All items of the `prop` array
+ * - `'prop[0].nested'` - `nested` prop of the first item of the `prop` array
+ * - `'prop[*].nested'` - `nested` prop of all items of the `prop` array
+ * - `'prop[*]**nested'` - all `nested` props of all items of the `prop` array
+ * - `'prop[0-2]'` - The first three items of the `prop` array
+ * - `'prop[4-*]'` - All items of the `prop` array from the fourth index to the end
+ * - `'prop[0-2].nested.**prop'` - Combining multiple nested patterns is supported
+ * - Root array:
+ *   - `'[0]'` - The first item of the root array
+ *   - `'[*]'` - All items of the array
+ *   - `'[0].nested'` - `nested` prop of the first item of the array
+ *   - `'[*].nested'` - `nested` prop of all items of the array
+ *   - `'[*]**nested'` - all `nested` props of all items of the array
+ *   - `'[0-2]'` - The first three items of the array
+ *   - `'[4-*]'` - All items of the array from the fourth index to the end
+ *
+ * @param objOrArray - The object or array to filter.
+ * @param options - The options for the filter.
+ * @param options.filterKeys - The keys to filter.
+ * @param options.rejectKeys - The keys to reject.
+ * @param options.rejectEmptyObjectsInArray - Whether to reject empty objects in arrays (default: true).
+ * @returns The filtered object or array.
+ */
+declare function filterObjectOrArrayKeys(objOrArray: Record<string, any> | Record<string, any>[], { filterKeys, rejectKeys, rejectEmptyObjectsInArray, }: {
+    filterKeys?: string[] | string;
+    rejectKeys?: string[] | string;
+    rejectEmptyObjectsInArray?: boolean;
+}): Record<string, any> | Record<string, any>[];
+
+export { filterObjectOrArrayKeys };

package/lib/filterObjectOrArrayKeys.js

@@ -0,0 +1,7 @@
+import {
+  filterObjectOrArrayKeys
+} from "./chunk-XXYTMSFH.js";
+import "./chunk-JF2MDHOJ.js";
+export {
+  filterObjectOrArrayKeys
+};

package/lib/objUtils.d.cts

@@ -1,4 +1,7 @@
-/** @deprecated use typedObjectEntries from @ls-stack/utils/typingFnUtils instead */
+/**
+ * @param obj
+ * @deprecated use typedObjectEntries from @ls-stack/utils/typingFnUtils instead
+ */
 declare function objectTypedEntries<T extends Record<string, unknown>>(obj: T): [Extract<keyof T, string>, T[keyof T]][];
 declare function pick<T extends Record<string, unknown>, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;
 declare function mapArrayToObject<T, K extends string, O>(array: T[], mapper: (item: T, index: number) => [K, O]): Record<K, O>;

package/lib/objUtils.d.ts

@@ -1,4 +1,7 @@
-/** @deprecated use typedObjectEntries from @ls-stack/utils/typingFnUtils instead */
+/**
+ * @param obj
+ * @deprecated use typedObjectEntries from @ls-stack/utils/typingFnUtils instead
+ */
 declare function objectTypedEntries<T extends Record<string, unknown>>(obj: T): [Extract<keyof T, string>, T[keyof T]][];
 declare function pick<T extends Record<string, unknown>, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;
 declare function mapArrayToObject<T, K extends string, O>(array: T[], mapper: (item: T, index: number) => [K, O]): Record<K, O>;

package/lib/parallelAsyncCalls.cjs

@@ -55,7 +55,10 @@ var ParallelAsyncResultCalls = class {
     );
     return this;
   }
-  /** adds calls return tuples with inferred results */
+  /**
+   * adds calls return tuples with inferred results
+   * @param calls
+   */
   addTuple(...calls) {
     for (const call of calls) {
       this.pendingCalls.push(

package/lib/parallelAsyncCalls.d.cts

@@ -37,7 +37,10 @@ declare class ParallelAsyncResultCalls<M extends ValidMetadata | undefined = und
         metadata: M;
         fn: () => Promise<Result<R>>;
     }): this;
-    /** adds calls return tuples with inferred results */
+    /**
+     * adds calls return tuples with inferred results
+     * @param calls
+     */
     addTuple<T extends (M extends undefined ? () => Promise<Result<R>> : {
         metadata: M;
         fn: () => Promise<Result<R>>;

package/lib/parallelAsyncCalls.d.ts

@@ -37,7 +37,10 @@ declare class ParallelAsyncResultCalls<M extends ValidMetadata | undefined = und
         metadata: M;
         fn: () => Promise<Result<R>>;
     }): this;
-    /** adds calls return tuples with inferred results */
+    /**
+     * adds calls return tuples with inferred results
+     * @param calls
+     */
     addTuple<T extends (M extends undefined ? () => Promise<Result<R>> : {
         metadata: M;
         fn: () => Promise<Result<R>>;

package/lib/parallelAsyncCalls.js

@@ -20,7 +20,10 @@ var ParallelAsyncResultCalls = class {
     );
     return this;
   }
-  /** adds calls return tuples with inferred results */
+  /**
+   * adds calls return tuples with inferred results
+   * @param calls
+   */
   addTuple(...calls) {
     for (const call of calls) {
       this.pendingCalls.push(

package/lib/retryOnError.d.cts

@@ -18,6 +18,8 @@ type RetryOptions = {
  * @param fn - Function to retry that receives context with retry count
  * @param maxRetries - Maximum number of retries
  * @param options - Configuration options
+ * @param retry
+ * @param originalMaxRetries
  * @returns Promise resolving to the function result or rejecting with the final error
  *
  * @example