@ls-stack/utils 3.63.0 → 3.66.0

package/dist/mutationUtils.d.ts

@@ -1,15 +0,0 @@
-/**
- * Updates an object with a new set of values. undefined values are ignored in
- * the updates object and deep equal values are not updated.
- *
- * @param object - The object to update.
- * @param updates - The new values to update the object with.
- */
-declare function updateObject<T extends Record<string, unknown>>(object: T | undefined | null, updates: Partial<T>): void;
-declare function getArrayMethodsFromProduce<T extends Record<string, unknown>>(produceFn: (cb: (newVal: T[]) => void | T[]) => T[] | void, getItemId: (item: T) => string): {
-    add: (item: T) => void | T[];
-    remove: (id: string) => void | T[];
-    update: (id: string, updateItem: ((draftItem: T) => T | void) | Partial<T>) => void | T[];
-};
-
-export { getArrayMethodsFromProduce, updateObject };

package/dist/mutationUtils.js

@@ -1,55 +0,0 @@
-import {
-  keepPrevIfUnchanged
-} from "./chunk-QQS7I7ZL.js";
-import "./chunk-JQFUKJU5.js";
-import {
-  isFunction
-} from "./chunk-JF2MDHOJ.js";
-
-// src/mutationUtils.ts
-function updateObject(object, updates) {
-  if (!object || typeof object !== "object") {
-    return;
-  }
-  for (const key of Object.keys(updates)) {
-    const value = updates[key];
-    if (value !== void 0) {
-      object[key] = keepPrevIfUnchanged({
-        prev: object[key],
-        newValue: value
-      });
-    }
-  }
-}
-function getArrayMethodsFromProduce(produceFn, getItemId) {
-  return {
-    add: (item) => produceFn((draft) => {
-      draft.push(item);
-    }),
-    remove: (id) => produceFn((draft) => {
-      const index = draft.findIndex((item) => getItemId(item) === id);
-      if (index !== -1) {
-        draft.splice(index, 1);
-      }
-    }),
-    update: (id, updateItem) => produceFn((draft) => {
-      const index = draft.findIndex((item2) => getItemId(item2) === id);
-      const item = draft[index];
-      if (!item) {
-        throw new Error(`Item with id ${id} not found`);
-      }
-      if (isFunction(updateItem)) {
-        const updatedItem = updateItem(item);
-        if (updatedItem) {
-          draft[index] = updatedItem;
-        }
-      } else {
-        updateObject(item, updateItem);
-      }
-    })
-  };
-}
-export {
-  getArrayMethodsFromProduce,
-  updateObject
-};

package/dist/objUtils.cjs

@@ -1,242 +0,0 @@
-"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/objUtils.ts
-var objUtils_exports = {};
-__export(objUtils_exports, {
-  addPrefixToObjKeys: () => addPrefixToObjKeys,
-  addSuffixToObjKeys: () => addSuffixToObjKeys,
-  filterObjectKeys: () => filterObjectKeys,
-  getObjPropertyOrInsert: () => getObjPropertyOrInsert,
-  getValueFromPath: () => getValueFromPath,
-  looseGetObjectProperty: () => looseGetObjectProperty,
-  mapArrToObj: () => mapArrToObj,
-  mapArrayToObject: () => mapArrayToObject,
-  mapObjToObj: () => mapObjToObj,
-  mapObjectToObject: () => mapObjectToObject,
-  objectTypedEntries: () => objectTypedEntries,
-  omit: () => omit,
-  pick: () => pick,
-  rejectObjUndefinedValues: () => rejectObjUndefinedValues,
-  sortObjectKeys: () => sortObjectKeys
-});
-module.exports = __toCommonJS(objUtils_exports);
-var import_t_result = require("t-result");
-
-// src/arrayUtils.ts
-function sortBy(arr, sortByValue, props = "asc") {
-  const order = Array.isArray(props) || typeof props === "string" ? props : props.order ?? "asc";
-  return [...arr].sort((a, b) => {
-    const _aPriority = sortByValue(a);
-    const _bPriority = sortByValue(b);
-    const aPriority = Array.isArray(_aPriority) ? _aPriority : [_aPriority];
-    const bPriority = Array.isArray(_bPriority) ? _bPriority : [_bPriority];
-    for (let i = 0; i < aPriority.length; i++) {
-      const levelOrder = typeof order === "string" ? order : order[i] ?? "asc";
-      const aP = aPriority[i] ?? 0;
-      const bP = bPriority[i] ?? 0;
-      if (aP === bP) {
-        continue;
-      }
-      if (bP === Infinity || aP === -Infinity || aP < bP) {
-        return levelOrder === "asc" ? -1 : 1;
-      }
-      if (aP === Infinity || bP === -Infinity || aP > bP) {
-        return levelOrder === "asc" ? 1 : -1;
-      }
-    }
-    return 0;
-  });
-}
-
-// src/typingFnUtils.ts
-function typedObjectEntries(obj) {
-  return Object.entries(obj);
-}
-
-// src/objUtils.ts
-function objectTypedEntries(obj) {
-  return Object.entries(obj);
-}
-function pick(obj, keys) {
-  const result = {};
-  for (const key of keys) {
-    result[key] = obj[key];
-  }
-  return result;
-}
-function mapArrToObj(array, mapper) {
-  return Object.fromEntries(array.map(mapper));
-}
-var mapArrayToObject = mapArrToObj;
-function mapObjToObj(obj, mapper) {
-  return Object.fromEntries(
-    objectTypedEntries(obj).map(([key, value]) => mapper(key, value))
-  );
-}
-var mapObjectToObject = mapObjToObj;
-function omit(obj, keys) {
-  const result = {};
-  for (const key of Object.keys(obj)) {
-    if (!keys.includes(key)) {
-      result[key] = obj[key];
-    }
-  }
-  return result;
-}
-function looseGetObjectProperty(obj, key) {
-  return obj[key];
-}
-function rejectObjUndefinedValues(obj) {
-  const result = {};
-  for (const key in obj) {
-    if (obj[key] !== void 0) {
-      result[key] = obj[key];
-    }
-  }
-  return result;
-}
-function filterObjectKeys(obj, predicate) {
-  return Object.fromEntries(
-    Object.entries(obj).filter(
-      ([key, value]) => predicate(key, value)
-    )
-  );
-}
-function sortObjectKeys(obj, sortByFn, options) {
-  return Object.fromEntries(
-    sortBy(typedObjectEntries(obj), sortByFn, options)
-  );
-}
-function getValueFromPath(obj, path) {
-  if (!path.trim()) {
-    return import_t_result.Result.err(new Error("Path cannot be empty"));
-  }
-  const segments = parsePath(path);
-  let current = obj;
-  for (let i = 0; i < segments.length; i++) {
-    const segment = segments[i];
-    if (!segment) {
-      return import_t_result.Result.err(new Error("Invalid empty segment in path"));
-    }
-    if (current == null) {
-      return import_t_result.Result.err(
-        new Error(`Cannot access property '${segment}' on null or undefined`)
-      );
-    }
-    if (isNumericString(segment)) {
-      if (!Array.isArray(current)) {
-        return import_t_result.Result.err(
-          new Error(
-            `Cannot access array index '${segment}' on non-array value`
-          )
-        );
-      }
-      const index = parseInt(segment, 10);
-      if (index < 0 || index >= current.length) {
-        return import_t_result.Result.err(new Error(`Array index '${index}' out of bounds`));
-      }
-      current = current[index];
-    } else {
-      if (typeof current !== "object" || current === null) {
-        return import_t_result.Result.err(
-          new Error(`Cannot access property '${segment}' on non-object value`)
-        );
-      }
-      if (!(segment in current)) {
-        return import_t_result.Result.err(new Error(`Property '${segment}' not found`));
-      }
-      current = current[segment];
-    }
-  }
-  return import_t_result.Result.ok(current);
-}
-function parsePath(path) {
-  const segments = [];
-  let current = "";
-  let inBrackets = false;
-  for (let i = 0; i < path.length; i++) {
-    const char = path[i];
-    if (char === "[") {
-      if (current) {
-        segments.push(current);
-        current = "";
-      }
-      inBrackets = true;
-    } else if (char === "]") {
-      if (inBrackets && current) {
-        segments.push(current);
-        current = "";
-      }
-      inBrackets = false;
-    } else if (char === "." && !inBrackets) {
-      if (current) {
-        segments.push(current);
-        current = "";
-      }
-    } else {
-      current += char;
-    }
-  }
-  if (current) {
-    segments.push(current);
-  }
-  return segments;
-}
-function isNumericString(str) {
-  return /^\d+$/.test(str);
-}
-function getObjPropertyOrInsert(obj, prop, insertValue) {
-  if (obj[prop] === void 0) {
-    obj[prop] = insertValue();
-  }
-  return obj[prop];
-}
-function addPrefixToObjKeys(obj, prefix) {
-  const newObj = {};
-  for (const [key, value] of Object.entries(obj)) {
-    newObj[`${prefix}${key}`] = value;
-  }
-  return newObj;
-}
-function addSuffixToObjKeys(obj, suffix) {
-  const newObj = {};
-  for (const [key, value] of Object.entries(obj)) {
-    newObj[`${key}${suffix}`] = value;
-  }
-  return newObj;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  addPrefixToObjKeys,
-  addSuffixToObjKeys,
-  filterObjectKeys,
-  getObjPropertyOrInsert,
-  getValueFromPath,
-  looseGetObjectProperty,
-  mapArrToObj,
-  mapArrayToObject,
-  mapObjToObj,
-  mapObjectToObject,
-  objectTypedEntries,
-  omit,
-  pick,
-  rejectObjUndefinedValues,
-  sortObjectKeys
-});

package/dist/objUtils.d.cts

@@ -1,28 +0,0 @@
-import { Result } from 't-result';
-import { SortByValueFn, SortByProps } from './arrayUtils.cjs';
-import { MakeUndefinedKeysOptional } from './typeUtils.cjs';
-import { AddPrefixToObjKeys, AddSuffixToObjKeys } from './typingUtils.cjs';
-
-/**
- * @deprecated Use typedObjectEntries from @ls-stack/utils/typingFnUtils instead
- * @param obj
- */
-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 mapArrToObj<T, K extends string, O>(array: T[], mapper: (item: T, index: number) => [K, O]): Record<K, O>;
-/** @deprecated Use mapArrToObj instead */
-declare const mapArrayToObject: typeof mapArrToObj;
-declare function mapObjToObj<I extends Record<string | number | symbol, unknown>, K extends string | number | symbol, O>(obj: I, mapper: (key: keyof I, value: I[keyof I]) => [K, O]): Record<K, O>;
-/** @deprecated Use mapObjToObj instead */
-declare const mapObjectToObject: typeof mapObjToObj;
-declare function omit<T extends Record<string, unknown>, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;
-declare function looseGetObjectProperty<T extends Record<string, unknown>>(obj: T, key: string): T[keyof T] | undefined;
-declare function rejectObjUndefinedValues<T extends Record<string, unknown>>(obj: T): MakeUndefinedKeysOptional<T>;
-declare function filterObjectKeys<T extends Record<string, unknown>>(obj: T, predicate: (key: keyof T, value: T[keyof T]) => boolean): Partial<T>;
-declare function sortObjectKeys<T extends Record<string, unknown>>(obj: T, sortByFn: SortByValueFn<[key: keyof T, value: T[keyof T]]>, options?: SortByProps): T;
-declare function getValueFromPath(obj: Record<string, unknown>, path: string): Result<unknown, Error>;
-declare function getObjPropertyOrInsert<T extends Record<string, any>, K extends keyof T>(obj: T, prop: K, insertValue: () => Exclude<T[K], undefined>): Exclude<T[K], undefined>;
-declare function addPrefixToObjKeys<T extends Record<string, unknown>, P extends string>(obj: T, prefix: P): AddPrefixToObjKeys<T, P>;
-declare function addSuffixToObjKeys<T extends Record<string, unknown>, S extends string>(obj: T, suffix: S): AddSuffixToObjKeys<T, S>;
-
-export { addPrefixToObjKeys, addSuffixToObjKeys, filterObjectKeys, getObjPropertyOrInsert, getValueFromPath, looseGetObjectProperty, mapArrToObj, mapArrayToObject, mapObjToObj, mapObjectToObject, objectTypedEntries, omit, pick, rejectObjUndefinedValues, sortObjectKeys };

package/dist/objUtils.js

@@ -1,38 +0,0 @@
-import {
-  addPrefixToObjKeys,
-  addSuffixToObjKeys,
-  filterObjectKeys,
-  getObjPropertyOrInsert,
-  getValueFromPath,
-  looseGetObjectProperty,
-  mapArrToObj,
-  mapArrayToObject,
-  mapObjToObj,
-  mapObjectToObject,
-  objectTypedEntries,
-  omit,
-  pick,
-  rejectObjUndefinedValues,
-  sortObjectKeys
-} from "./chunk-ZXIKIA5B.js";
-import "./chunk-GMJTLFM6.js";
-import "./chunk-WFQJUJTC.js";
-import "./chunk-C2SVCIWE.js";
-import "./chunk-JF2MDHOJ.js";
-export {
-  addPrefixToObjKeys,
-  addSuffixToObjKeys,
-  filterObjectKeys,
-  getObjPropertyOrInsert,
-  getValueFromPath,
-  looseGetObjectProperty,
-  mapArrToObj,
-  mapArrayToObject,
-  mapObjToObj,
-  mapObjectToObject,
-  objectTypedEntries,
-  omit,
-  pick,
-  rejectObjUndefinedValues,
-  sortObjectKeys
-};

package/dist/parallelAsyncCalls.cjs

@@ -1,162 +0,0 @@
-"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/parallelAsyncCalls.ts
-var parallelAsyncCalls_exports = {};
-__export(parallelAsyncCalls_exports, {
-  parallelAsyncCalls: () => parallelAsyncCalls
-});
-module.exports = __toCommonJS(parallelAsyncCalls_exports);
-var import_t_result = require("t-result");
-
-// src/typeGuards.ts
-function isObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-// src/assertions.ts
-function invariant(condition, error = "Invariant violation") {
-  if (!condition) {
-    throw typeof error === "function" ? error() : new Error(`Invariant violation: ${error}`);
-  }
-}
-var isObject2 = isObject;
-
-// src/sleep.ts
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-// src/parallelAsyncCalls.ts
-var ParallelAsyncResultCalls = class {
-  pendingCalls = [];
-  alreadyRun = false;
-  constructor() {
-  }
-  add(call) {
-    this.pendingCalls.push(
-      isObject2(call) ? call : { metadata: void 0, fn: call }
-    );
-    return this;
-  }
-  /**
-   * Adds calls return tuples with inferred results
-   *
-   * @param calls
-   */
-  addTuple(...calls) {
-    for (const call of calls) {
-      this.pendingCalls.push(
-        isObject2(call) ? call : { metadata: void 0, fn: call }
-      );
-    }
-    return {
-      runAll: this.runAll.bind(this),
-      runAllSettled: this.runAllSettled.bind(this)
-    };
-  }
-  async runAllSettled({ delayStart } = {}) {
-    invariant(!this.alreadyRun, "Already run");
-    const asyncResults = await Promise.allSettled(
-      this.pendingCalls.map(async (call, i) => {
-        try {
-          if (delayStart) {
-            await sleep(delayStart(i));
-          }
-          const result = await call.fn();
-          return { result, callMetadata: call.metadata };
-        } catch (exception) {
-          return {
-            result: import_t_result.Result.unknownToError(exception),
-            callMetadata: call.metadata
-          };
-        }
-      })
-    );
-    const failed = [];
-    const succeeded = [];
-    const results = [];
-    for (const asyncResult of asyncResults) {
-      invariant(asyncResult.status === "fulfilled");
-      const { result, callMetadata } = asyncResult.value;
-      if (result.ok) {
-        const success = { value: result.value, metadata: callMetadata };
-        results.push(success);
-        succeeded.push(success);
-      } else {
-        const fail = { metadata: callMetadata, error: result.error };
-        results.push(fail);
-        failed.push(fail);
-      }
-    }
-    const allFailed = failed.length === this.pendingCalls.length;
-    this.alreadyRun = true;
-    this.pendingCalls = [];
-    return {
-      failed,
-      succeeded,
-      allFailed,
-      results
-    };
-  }
-  async runAll({
-    delayStart
-  } = {}) {
-    invariant(!this.alreadyRun, "Already run");
-    try {
-      const asyncResults = await Promise.all(
-        this.pendingCalls.map(async (call, i) => {
-          try {
-            if (delayStart) {
-              await sleep(delayStart(i));
-            }
-            const result = await call.fn();
-            if (!result.ok) {
-              throw result.error;
-            }
-            return {
-              value: result.value,
-              metadata: call.metadata
-            };
-          } catch (exception) {
-            throw {
-              metadata: call.metadata,
-              error: (0, import_t_result.unknownToError)(exception)
-            };
-          }
-        })
-      );
-      return import_t_result.Result.ok(asyncResults);
-    } catch (exception) {
-      return import_t_result.Result.err(
-        exception
-      );
-    } finally {
-      this.alreadyRun = true;
-      this.pendingCalls = [];
-    }
-  }
-};
-function parallelAsyncCalls() {
-  return new ParallelAsyncResultCalls();
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  parallelAsyncCalls
-});

package/dist/parallelAsyncCalls.d.cts

@@ -1,82 +0,0 @@
-import { Result } from 't-result';
-
-type ValidMetadata = string | number | boolean | Record<string, unknown>;
-type TupleRunAllSuccess<T> = T extends () => Promise<Result<infer V>> ? Succeeded<V, undefined> : T extends {
-    metadata: infer M;
-    fn: () => Promise<Result<infer V>>;
-} ? Succeeded<V, M> : never;
-type TupleRunAllFailed<T> = T extends () => Promise<Result<any>> ? {
-    metadata: undefined;
-    error: Error;
-} : T extends {
-    metadata: infer M extends ValidMetadata;
-} ? {
-    metadata: M;
-    error: Error;
-} : never;
-type TupleRunAllSettled<T> = T extends () => Promise<Result<infer V>> ? Succeeded<V, undefined> | Failed<undefined> : T extends {
-    metadata: infer M;
-    fn: () => Promise<Result<infer V>>;
-} ? Succeeded<V, M> | Failed<M> : never;
-type RunProps = {
-    delayStart?: (index: number) => number;
-};
-type Failed<M> = {
-    metadata: M;
-    error: Error;
-};
-type Succeeded<R, M> = {
-    value: R;
-    metadata: M;
-};
-declare class ParallelAsyncResultCalls<M extends ValidMetadata | undefined = undefined, R = unknown> {
-    private pendingCalls;
-    alreadyRun: boolean;
-    constructor();
-    add(call: M extends undefined ? () => Promise<Result<R>> : {
-        metadata: M;
-        fn: () => Promise<Result<R>>;
-    }): this;
-    /**
-     * Adds calls return tuples with inferred results
-     *
-     * @param calls
-     */
-    addTuple<T extends (M extends undefined ? () => Promise<Result<R>> : {
-        metadata: M;
-        fn: () => Promise<Result<R>>;
-    })[]>(...calls: T): {
-        runAllSettled: (props?: RunProps) => Promise<{
-            results: {
-                [I in keyof T]: TupleRunAllSettled<T[I]>;
-            };
-            allFailed: boolean;
-        }>;
-        runAll: (props?: RunProps) => Promise<Result<{
-            [I in keyof T]: TupleRunAllSuccess<T[I]>;
-        }, TupleRunAllFailed<T[number]>>>;
-    };
-    runAllSettled({ delayStart }?: RunProps): Promise<{
-        failed: Failed<M>[];
-        succeeded: Succeeded<R, M>[];
-        allFailed: boolean;
-        results: (Failed<M> | Succeeded<R, M>)[];
-    }>;
-    runAll({ delayStart, }?: {
-        delayStart?: (index: number) => number;
-    }): Promise<Result<Succeeded<R, M>[], {
-        metadata: M;
-        error: Error;
-    }>>;
-}
-/**
- * Executes multiple asynchronous calls in parallel and collects the results in
- * a easier to use format.
- *
- * @deprecated Use concurrentAsyncCalls instead.
- * @template R - The type of the result value.
- * @template M - The type of the call metadata.
- */
-declare function parallelAsyncCalls<M extends ValidMetadata | undefined = undefined, R = unknown>(): ParallelAsyncResultCalls<M, R>;
-
-export { parallelAsyncCalls };