@ls-stack/utils 1.13.2 → 2.0.0

package/dist/objUtils.cjs

@@ -0,0 +1,67 @@
+"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, {
+  mapArrayToObject: () => mapArrayToObject,
+  mapObjectToObject: () => mapObjectToObject,
+  objectTypedEntries: () => objectTypedEntries,
+  omit: () => omit,
+  pick: () => pick
+});
+module.exports = __toCommonJS(objUtils_exports);
+function objectTypedEntries(obj) {
+  return Object.entries(obj);
+}
+function pick(obj, keys, rename) {
+  const result = {};
+  if (!obj) {
+    return result;
+  }
+  for (const key of keys) {
+    result[rename?.[key] || key] = obj[key];
+  }
+  return result;
+}
+function mapArrayToObject(array, mapper) {
+  return Object.fromEntries(array.map(mapper));
+}
+function mapObjectToObject(obj, mapper) {
+  return Object.fromEntries(
+    objectTypedEntries(obj).map(([key, value]) => mapper(key, value))
+  );
+}
+function omit(obj, keys) {
+  const result = {};
+  for (const key of Object.keys(obj)) {
+    if (!keys.includes(key)) {
+      result[key] = obj[key];
+    }
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  mapArrayToObject,
+  mapObjectToObject,
+  objectTypedEntries,
+  omit,
+  pick
+});

package/dist/objUtils.d.cts

@@ -0,0 +1,7 @@
+declare function objectTypedEntries<T extends Record<string, unknown>>(obj: T): [Extract<keyof T, string>, T[keyof T]][];
+declare function pick<T, K extends keyof T>(obj: T | undefined, keys: K[], rename?: Partial<Record<K, string>>): Record<string, unknown>;
+declare function mapArrayToObject<T, K extends string, O>(array: T[], mapper: (item: T, index: number) => [K, O]): Record<K, O>;
+declare function mapObjectToObject<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>;
+declare function omit<T extends Record<string, unknown>, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;
+
+export { mapArrayToObject, mapObjectToObject, objectTypedEntries, omit, pick };

package/dist/objUtils.js

@@ -4,7 +4,7 @@ import {
   objectTypedEntries,
   omit,
   pick
-} from "./chunk-SNAAKCTH.js";
+} from "./chunk-RVVH3MDA.js";
 export {
   mapArrayToObject,
   mapObjectToObject,
@@ -12,4 +12,3 @@ export {
   omit,
   pick
 };
-//# sourceMappingURL=objUtils.js.map

package/dist/parallelAsyncCalls.cjs

@@ -0,0 +1,265 @@
+"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);
+
+// src/assertions.ts
+function invariant(condition, errorMsg = "Invariant violation") {
+  if (!condition) {
+    throw new Error(`Invariant violation: ${errorMsg}`);
+  }
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/rsResult.ts
+function okUnwrapOr() {
+  return this.value;
+}
+function ok(value = void 0) {
+  return {
+    ok: true,
+    error: false,
+    value,
+    unwrapOrNull: okUnwrapOr,
+    unwrapOr: okUnwrapOr,
+    unwrap: okUnwrapOr
+  };
+}
+function err(error) {
+  return {
+    ok: false,
+    error,
+    unwrapOrNull: () => null,
+    unwrapOr: (defaultValue) => defaultValue,
+    errorResult() {
+      return err(error);
+    },
+    unwrap: () => {
+      if (error instanceof Error) {
+        throw error;
+      }
+      if (Array.isArray(error)) {
+        throw new Error(error.join("\n"), { cause: error });
+      }
+      throw new Error(
+        isObject(error) && "message" in error && error.message ? String(error.message) : "Unwrap failed",
+        { cause: error }
+      );
+    }
+  };
+}
+function unknownToError(error) {
+  return err(normalizeError(error));
+}
+async function unwrap(result) {
+  const unwrapped = await result;
+  if (unwrapped.ok) {
+    return unwrapped.value;
+  }
+  throw unwrapped.error;
+}
+function asyncMap(resultPromise) {
+  return {
+    err: async (mapFn) => {
+      const result = await resultPromise;
+      return result.ok ? ok(result.value) : err(mapFn(result.error));
+    },
+    ok: async (mapFn) => {
+      const result = await resultPromise;
+      return result.ok ? ok(mapFn(result.value)) : err(result.error);
+    },
+    okAndErr: async ({
+      ok: mapFn,
+      err: mapErrFn
+    }) => {
+      const result = await resultPromise;
+      return result.ok ? ok(mapFn(result.value)) : err(mapErrFn(result.error));
+    }
+  };
+}
+function syncMap(result) {
+  return {
+    err: (mapFn) => {
+      return result.ok ? ok(result.value) : err(mapFn(result.error));
+    },
+    ok: (mapFn) => {
+      return result.ok ? ok(mapFn(result.value)) : err(result.error);
+    },
+    okAndErr: ({
+      ok: mapFn,
+      err: mapErrFn
+    }) => {
+      return result.ok ? ok(mapFn(result.value)) : err(mapErrFn(result.error));
+    }
+  };
+}
+var Result = {
+  ok,
+  err,
+  unknownToError,
+  unwrap,
+  asyncMap,
+  map: syncMap
+};
+function normalizeError(error) {
+  if (error instanceof Error) return error;
+  if (typeof error === "string") {
+    return new Error(error);
+  }
+  if (isObject(error)) {
+    return new Error(
+      "message" in error && error.message ? String(error.message) : safeJsonStringify(error) ?? "unknown",
+      { cause: error }
+    );
+  }
+  return new Error(safeJsonStringify(error) ?? "unknown", { cause: error });
+}
+function safeJsonStringify(value) {
+  try {
+    return JSON.stringify(value);
+  } catch (_) {
+    return null;
+  }
+}
+
+// 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(
+      isObject(call) ? call : { metadata: void 0, fn: call }
+    );
+    return this;
+  }
+  /** adds calls return tuples with inferred results */
+  addTuple(...calls) {
+    for (const call of calls) {
+      this.pendingCalls.push(
+        isObject(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: 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: normalizeError(exception)
+            };
+          }
+        })
+      );
+      return Result.ok(asyncResults);
+    } catch (exception) {
+      return 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/{parallelAsyncResultCalls.d.ts → parallelAsyncCalls.d.cts}

@@ -1,4 +1,4 @@
-import { Result, NormalizedError } from './rsResult.js';
+import { Result } from './rsResult.cjs';
 
 type ValidMetadata = string | number | boolean | Record<string, unknown>;
 type TupleRunAllSuccess<T> = T extends () => Promise<Result<infer V>> ? Succeeded<V, undefined> : T extends {
@@ -7,12 +7,12 @@ type TupleRunAllSuccess<T> = T extends () => Promise<Result<infer V>> ? Succeede
 } ? Succeeded<V, M> : never;
 type TupleRunAllFailed<T> = T extends () => Promise<Result<any>> ? {
     metadata: undefined;
-    error: NormalizedError;
+    error: Error;
 } : T extends {
     metadata: infer M extends ValidMetadata;
 } ? {
     metadata: M;
-    error: NormalizedError;
+    error: Error;
 } : never;
 type TupleRunAllSettled<T> = T extends () => Promise<Result<infer V>> ? Succeeded<V, undefined> | Failed<undefined> : T extends {
     metadata: infer M;
@@ -23,7 +23,7 @@ type RunProps = {
 };
 type Failed<M> = {
     metadata: M;
-    error: NormalizedError;
+    error: Error;
 };
 type Succeeded<R, M> = {
     value: R;
@@ -62,7 +62,7 @@ declare class ParallelAsyncResultCalls<M extends ValidMetadata | undefined = und
         delayStart?: (index: number) => number;
     }): Promise<Result<Succeeded<R, M>[], {
         metadata: M;
-        error: NormalizedError;
+        error: Error;
     }>>;
 }
 /**
@@ -71,6 +71,6 @@ declare class ParallelAsyncResultCalls<M extends ValidMetadata | undefined = und
  * @template R - The type of the result value.
  * @template M - The type of the call metadata.
  */
-declare function parallelAsyncResultCalls<M extends ValidMetadata | undefined = undefined, R = unknown>(): ParallelAsyncResultCalls<M, R>;
+declare function parallelAsyncCalls<M extends ValidMetadata | undefined = undefined, R = unknown>(): ParallelAsyncResultCalls<M, R>;
 
-export { parallelAsyncResultCalls };
+export { parallelAsyncCalls };

package/dist/parallelAsyncCalls.d.ts

@@ -0,0 +1,76 @@
+import { Result } from './rsResult.js';
+
+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 */
+    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.
+ *
+ * @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 };

package/dist/{parallelAsyncResultCalls.js → parallelAsyncCalls.js}

@@ -1,17 +1,16 @@
 import {
   Result,
   normalizeError
-} from "./chunk-I7ZDKDUM.js";
+} from "./chunk-JOBPQAI3.js";
 import {
   sleep
-} from "./chunk-HLFWWIDK.js";
-import "./chunk-GLZ5MZC5.js";
+} from "./chunk-5DZT3Z5Z.js";
 import {
   invariant,
   isObject
-} from "./chunk-FYMTZQ42.js";
+} from "./chunk-4UGSP3L3.js";
 
-// src/parallelAsyncResultCalls.ts
+// src/parallelAsyncCalls.ts
 var ParallelAsyncResultCalls = class {
   pendingCalls = [];
   alreadyRun = false;
@@ -47,7 +46,7 @@ var ParallelAsyncResultCalls = class {
           return { result, callMetadata: call.metadata };
         } catch (exception) {
           return {
-            result: Result.normalizedUnknownErr(exception),
+            result: Result.unknownToError(exception),
             callMetadata: call.metadata
           };
         }
@@ -117,10 +116,9 @@ var ParallelAsyncResultCalls = class {
     }
   }
 };
-function parallelAsyncResultCalls() {
+function parallelAsyncCalls() {
   return new ParallelAsyncResultCalls();
 }
 export {
-  parallelAsyncResultCalls
+  parallelAsyncCalls
 };
-//# sourceMappingURL=parallelAsyncResultCalls.js.map

package/dist/promiseUtils.cjs

@@ -0,0 +1,38 @@
+"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/promiseUtils.ts
+var promiseUtils_exports = {};
+__export(promiseUtils_exports, {
+  defer: () => defer
+});
+module.exports = __toCommonJS(promiseUtils_exports);
+function defer() {
+  let resolve;
+  let reject;
+  const promise = new Promise((_resolve, _reject) => {
+    resolve = _resolve;
+    reject = _reject;
+  });
+  return { resolve, reject, promise };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defer
+});

package/dist/promiseUtils.d.cts

@@ -0,0 +1,8 @@
+type Deferred<T> = {
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason: unknown) => void;
+    promise: Promise<T>;
+};
+declare function defer<T = void>(): Deferred<T>;
+
+export { defer };

package/dist/promiseUtils.js

@@ -11,4 +11,3 @@ function defer() {
 export {
   defer
 };
-//# sourceMappingURL=promiseUtils.js.map