@phothinmaung/resolves 1.0.0

package/LICENSE

@@ -0,0 +1,19 @@
+ISC License
+
+Copyright 2025 Pho Thin Maung<phothinmg@disroot.org>
+
+Permission to use, copy, modify, and/or distribute 
+this software for any purpose with or without fee is 
+hereby granted, provided that the above copyright 
+notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR 
+DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE 
+INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY 
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE 
+FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL 
+DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS 
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF 
+CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING 
+OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF 
+THIS SOFTWARE.

package/README.md

@@ -0,0 +1,94 @@
+<div align="center">
+	<img src="https://github.com/phothinmg/ptmbox/blob/main/kadown.svg" width="160" height="160" alt="susee" />
+	<h1>@phothinmaung/resolves</h1>
+</div>
+
+The package lets you run a list of functions in series, concurrently, or using an allSettled pattern, returning an array of Promise-resolved results. It is useful for managing multiple asynchronous or synchronous tasks with different strategies.
+
+## Features
+
+- **Run functions in series (one after another)**
+- **Run functions concurrently (all at once)**
+- **Run functions with allSettled (wait for all to finish, regardless of success/failure)**
+
+## Installation
+
+```bash
+npm i @phothinmaung/resolves
+```
+
+## Usage
+
+### commonjs
+
+```js
+const resolves = require("@phothinmaung/resolves");
+
+const asyncFunction = async (str) => {
+  return await new Promise((resolve) => resolve(str));
+};
+const syncFunction = (str) => str;
+const syncFunctionNum = (num) => num;
+
+const rit = resolves([
+  [asyncFunction, "Result 1"],
+  [syncFunction, "Result 2"],
+  [syncFunctionNum, 3],
+]);
+
+rit.series().then((res) => {
+  console.log(`result-1 : ${res[0]}`); // result-1 : Result 1
+  console.log(`result-2 : ${res[1]}`); // result-2 : Result 2
+  console.log(`result-3 : ${res[2]}`); // result-3 : 3
+});
+```
+
+### typescript
+
+```ts
+import resolves from "@phothinmaung/resolves";
+
+const asyncFunction = async (str: string): Promise<string> => {
+  return await new Promise((resolve) => resolve(str));
+};
+const syncFunction = (str: string): string => str;
+const syncFunctionNum = (num: number): number => num;
+
+const rit = resolves<[Promise<string>, string, number]>([
+  [asyncFunction, "Result 1"],
+  [syncFunction, "Result 2"],
+  [syncFunctionNum, 3],
+]);
+
+const [a1, b1, c1] = await rit.series();
+const [a2, b2, c2] = await rit.concurrent();
+const [a3, b3, c3] = await rit.allSettled();
+// Result 1 - Result 2  - 3
+console.log(`${a1} - ${b1}  - ${c1}`);
+console.log(`${a2} - ${b2}  - ${c2}`);
+console.log(`${a3} - ${b3}  - ${c3}`);
+```
+
+## API
+
+`resolves<R extends any[]>(params: { [K in keyof R]: Param<R[K]> },time?: number)`
+
+parameters :
+
+- An array of tuples : `[[(...args:any[])=>any,...args:any[]]]`
+  The first place of tuple is function and rest are parameters of that function.
+
+- Number of milliseconds(optional) : `time?:number` The amount of time to wait before resolving the promise. Defaults to 500ms.
+
+returns :
+
+An object with `series`, `concurrent`, and `allSettled` properties. Each property is a function that takes no arguments and returns a promise. The promise resolves with the results of running the functions in the specified manner.
+
+## License
+
+[ISC][file-license] © [Pho Thin Mg][ptm]
+
+<!-- markdownlint-disable MD053 -->
+
+[file-license]: LICENSE
+[ptm]: https://github.com/phothinmg

package/lib/index.cjs

@@ -0,0 +1,107 @@
+const isPromiseFun = (fun) =>
+  Object.prototype.toString.call(fun) === "[object AsyncFunction]" ||
+  fun.constructor.name === "AsyncFunction";
+
+function walkPromise(param, time = 500) {
+  const fn = param[0];
+  const args = param.slice(1);
+  if (isPromiseFun(fn)) {
+    return () => fn(...args);
+  } else {
+    return () =>
+      new Promise((res, rej) => {
+        try {
+          const r = fn(...args);
+          setTimeout(() => res(r), time);
+        } catch (error) {
+          rej(error);
+        }
+      });
+  }
+}
+
+/**
+ * Run a list of functions in series, concurrently, or allSettled.
+ *
+ * @param {Array} params - A list of functions to run. Each function should be
+ *   the first element of an array, and the remainder of the array should be
+ *   the arguments to pass to the function.
+ * @param {Number} time - The amount of time to wait before resolving the
+ *   promise. Defaults to 500ms.
+ * @return {Object} An object with `series`, `concurrent`, and `allSettled`
+ *   properties. Each property is a function that takes no arguments and
+ *   returns a promise. The promise resolves with the results of running the
+ *   functions in the specified manner.
+ */
+function resolves(params, time = 500) {
+  const funs = params.map((w) => walkPromise(w, time));
+  const _funs = funs.map((f) => f());
+  const results = [];
+  const series = async () => {
+    for (const fn of _funs) {
+      const idx = _funs.indexOf(fn);
+      try {
+        const result = await new Promise((resolve) =>
+          setTimeout(resolve(fn), time),
+        );
+        results.push(result);
+      } catch (error) {
+        console.error(`Error in ${funs[idx].name}`);
+        throw error;
+      }
+    }
+    return results;
+  };
+
+  /**
+   * Run the functions concurrently, meaning that all of the functions will be
+   * run simultaneously. If any of the functions reject, the promise returned
+   * by this function will reject with the same error.
+   *
+   * @return {Promise} A promise that resolves with an array of results from
+   *   each of the functions, in the same order as the input `params`.
+   */
+  const concurrent = async () => {
+    try {
+      const res = await Promise.all(_funs);
+      results.push(...res);
+      return results;
+    } catch (error) {
+      console.error("One of the functions rejected:", error);
+      throw error;
+    }
+  };
+
+  /**
+   * Run the functions concurrently and return a promise that resolves when all
+   * of the functions have either resolved or rejected. If any of the functions
+   * reject, the promise returned by this function will not reject; instead, the
+   * error will be logged to the console and the process will exit with status 1.
+   *
+   * @return {Promise} A promise that resolves with an array of results from
+   *   each of the functions, in the same order as the input `params`.
+   */
+  const allSettled = async () => {
+    try {
+      const res = await Promise.allSettled(_funs);
+      results.push(
+        ...res.filter((re) => re.status === "fulfilled").map((re) => re.value),
+      );
+      const errors = res
+        .filter((re) => re.status === "rejected")
+        .map((re) => re.reason);
+      if (errors.length) {
+        console.warn("One of the functions rejected:", errors[0]);
+        process.exit(1);
+      }
+      return results;
+    } catch (error) {
+      console.error("One of the functions rejected:", error);
+      throw error;
+    }
+  };
+
+  return { series, concurrent, allSettled };
+}
+
+module.exports = resolves;

package/lib/index.d.cts

@@ -0,0 +1,28 @@
+// biome-ignore lint/suspicious/noExplicitAny: unknown
+type Fun<T> = (...arg: any) => T;
+// biome-ignore lint/suspicious/noExplicitAny: unknown
+type Param<T> = [Fun<T>, ...any[]];
+/**
+ * Run a list of functions in series, concurrently, or allSettled.
+ *
+ * @param {Array} params - A list of functions to run. Each function should be
+ *   the first element of an array, and the remainder of the array should be
+ *   the arguments to pass to the function.
+ * @param {Number} time - The amount of time to wait before resolving the
+ *   promise. Defaults to 500ms.
+ * @return {Object} An object with `series`, `concurrent`, and `allSettled`
+ *   properties. Each property is a function that takes no arguments and
+ *   returns a promise. The promise resolves with the results of running the
+ *   functions in the specified manner.
+ */
+// biome-ignore lint/suspicious/noExplicitAny: unknown
+declare function resolves<R extends any[]>(
+  params: { [K in keyof R]: Param<R[K]> },
+  time?: number,
+): {
+  series: () => Promise<R>;
+  concurrent: () => Promise<R>;
+  allSettled: () => Promise<R>;
+};
+
+export = resolves;

package/lib/index.d.mts

@@ -0,0 +1,28 @@
+// biome-ignore lint/suspicious/noExplicitAny: unknown
+type Fun<T> = (...arg: any) => T;
+// biome-ignore lint/suspicious/noExplicitAny: unknown
+type Param<T> = [Fun<T>, ...any[]];
+/**
+ * Run a list of functions in series, concurrently, or allSettled.
+ *
+ * @param {Array} params - A list of functions to run. Each function should be
+ *   the first element of an array, and the remainder of the array should be
+ *   the arguments to pass to the function.
+ * @param {Number} time - The amount of time to wait before resolving the
+ *   promise. Defaults to 500ms.
+ * @return {Object} An object with `series`, `concurrent`, and `allSettled`
+ *   properties. Each property is a function that takes no arguments and
+ *   returns a promise. The promise resolves with the results of running the
+ *   functions in the specified manner.
+ */
+// biome-ignore lint/suspicious/noExplicitAny: unknown
+declare function resolves<R extends any[]>(
+  params: { [K in keyof R]: Param<R[K]> },
+  time?: number,
+): {
+  series: () => Promise<R>;
+  concurrent: () => Promise<R>;
+  allSettled: () => Promise<R>;
+};
+
+export default resolves;

package/lib/index.mjs

@@ -0,0 +1,107 @@
+const isPromiseFun = (fun) =>
+  Object.prototype.toString.call(fun) === "[object AsyncFunction]" ||
+  fun.constructor.name === "AsyncFunction";
+
+function walkPromise(param, time = 500) {
+  const fn = param[0];
+  const args = param.slice(1);
+  if (isPromiseFun(fn)) {
+    return () => fn(...args);
+  } else {
+    return () =>
+      new Promise((res, rej) => {
+        try {
+          const r = fn(...args);
+          setTimeout(() => res(r), time);
+        } catch (error) {
+          rej(error);
+        }
+      });
+  }
+}
+
+/**
+ * Run a list of functions in series, concurrently, or allSettled.
+ *
+ * @param {Array} params - A list of functions to run. Each function should be
+ *   the first element of an array, and the remainder of the array should be
+ *   the arguments to pass to the function.
+ * @param {Number} time - The amount of time to wait before resolving the
+ *   promise. Defaults to 500ms.
+ * @return {Object} An object with `series`, `concurrent`, and `allSettled`
+ *   properties. Each property is a function that takes no arguments and
+ *   returns a promise. The promise resolves with the results of running the
+ *   functions in the specified manner.
+ */
+function resolves(params, time = 500) {
+  const funs = params.map((w) => walkPromise(w, time));
+  const _funs = funs.map((f) => f());
+  const results = [];
+  const series = async () => {
+    for (const fn of _funs) {
+      const idx = _funs.indexOf(fn);
+      try {
+        const result = await new Promise((resolve) =>
+          setTimeout(resolve(fn), time),
+        );
+        results.push(result);
+      } catch (error) {
+        console.error(`Error in ${funs[idx].name}`);
+        throw error;
+      }
+    }
+    return results;
+  };
+
+  /**
+   * Run the functions concurrently, meaning that all of the functions will be
+   * run simultaneously. If any of the functions reject, the promise returned
+   * by this function will reject with the same error.
+   *
+   * @return {Promise} A promise that resolves with an array of results from
+   *   each of the functions, in the same order as the input `params`.
+   */
+  const concurrent = async () => {
+    try {
+      const res = await Promise.all(_funs);
+      results.push(...res);
+      return results;
+    } catch (error) {
+      console.error("One of the functions rejected:", error);
+      throw error;
+    }
+  };
+
+  /**
+   * Run the functions concurrently and return a promise that resolves when all
+   * of the functions have either resolved or rejected. If any of the functions
+   * reject, the promise returned by this function will not reject; instead, the
+   * error will be logged to the console and the process will exit with status 1.
+   *
+   * @return {Promise} A promise that resolves with an array of results from
+   *   each of the functions, in the same order as the input `params`.
+   */
+  const allSettled = async () => {
+    try {
+      const res = await Promise.allSettled(_funs);
+      results.push(
+        ...res.filter((re) => re.status === "fulfilled").map((re) => re.value),
+      );
+      const errors = res
+        .filter((re) => re.status === "rejected")
+        .map((re) => re.reason);
+      if (errors.length) {
+        console.warn("One of the functions rejected:", errors[0]);
+        process.exit(1);
+      }
+      return results;
+    } catch (error) {
+      console.error("One of the functions rejected:", error);
+      throw error;
+    }
+  };
+
+  return { series, concurrent, allSettled };
+}
+
+export default resolves;

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@phothinmaung/resolves",
+  "version": "1.0.0",
+  "description": "Run a list of functions in series, concurrently, or allSettled.",
+  "type": "module",
+  "main": "lib/index.cjs",
+  "module": "lib/index.mjs",
+  "types": "lib/index.d.cts",
+  "exports": {
+    ".": {
+      "require": {
+        "types": "./lib/index.d.cts",
+        "default": "./lib/index.cjs"
+      },
+      "import": {
+        "types": "./lib/index.d.mts",
+        "default": "./lib/index.mjs"
+      }
+    }
+  },
+  "keywords": [
+    "Promise",
+    "resolved"
+  ],
+  "author": {
+    "name": "Pho Thin Mg",
+    "email": "phothinmg@disroot.org",
+    "url": "https://phothinmg.github.io/"
+  },
+  "license": "ISC",
+  "files": [
+    "lib",
+    "LICENSE",
+    "README.md",
+    "package.json"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "url": "git+https://github.com/phothinmg/resolves.git",
+    "type": "git"
+  },
+  "bugs": {
+    "url": "https://github.com/phothinmg/resolves/issues"
+  }
+}