promise-tuple 1.1.2 → 1.1.4

package/README.md

@@ -53,9 +53,9 @@ import promiseTuple from 'promise-tuple';
 const [error, data] = await promiseTuple(fetch('/api/data'));
 
 if (error) {
-  console.error('Error:', error);
+    console.error('Error:', error);
 } else {
-  console.log('Data:', data);
+    console.log('Data:', data);
 }
 ```
 
@@ -67,18 +67,18 @@ You can specify the type of the resolved value and error:
 import promiseTuple from 'promise-tuple';
 
 interface User {
-  id: number;
-  name: string;
+    id: number;
+    name: string;
 }
 
 const [error, user] = await promiseTuple<User>(
-  fetch('/api/user').then(res => res.json())
+    fetch('/api/user').then((res) => res.json()),
 );
 
 if (error) {
-  console.error('Failed to fetch user:', error);
+    console.error('Failed to fetch user:', error);
 } else {
-  console.log('User:', user?.name);
+    console.log('User:', user?.name);
 }
 ```
 
@@ -86,23 +86,19 @@ if (error) {
 
 ```typescript
 async function getUser(userId: string) {
-  const [error, response] = await promiseTuple(
-    fetch(`/api/users/${userId}`)
-  );
+    const [error, response] = await promiseTuple(fetch(`/api/users/${userId}`));
 
-  if (error) {
-    throw new Error(`Failed to fetch user: ${error}`);
-  }
+    if (error) {
+        throw new Error(`Failed to fetch user: ${error}`);
+    }
 
-  const [parseError, user] = await promiseTuple(
-    response.json()
-  );
+    const [parseError, user] = await promiseTuple(response.json());
 
-  if (parseError) {
-    throw new Error(`Failed to parse user data: ${parseError}`);
-  }
+    if (parseError) {
+        throw new Error(`Failed to parse user data: ${parseError}`);
+    }
 
-  return user;
+    return user;
 }
 ```
 
@@ -112,12 +108,12 @@ async function getUser(userId: string) {
 import promiseTuple from 'promise-tuple';
 
 interface CustomError {
-  code: string;
-  message: string;
+    code: string;
+    message: string;
 }
 
 const [error, data] = await promiseTuple<string, CustomError>(
-  someAsyncOperation()
+    someAsyncOperation(),
 );
 ```
 
@@ -129,9 +125,9 @@ You can optionally provide success and failure callbacks:
 import promiseTuple from 'promise-tuple';
 
 const [error, data] = await promiseTuple(
-  fetch('/api/data'),
-  () => console.log('Request succeeded!'),
-  () => console.log('Request failed!')
+    fetch('/api/data'),
+    () => console.log('Request succeeded!'),
+    () => console.log('Request failed!'),
 );
 ```
 
@@ -141,17 +137,17 @@ Only the appropriate callback will be executed:
 import promiseTuple from 'promise-tuple';
 
 const [error, data] = await promiseTuple(
-  someAsyncOperation(),
-  () => {
-    // This runs on success
-    console.log('Operation completed successfully');
-    sendAnalytics('success');
-  },
-  () => {
-    // This runs on failure
-    console.error('Operation failed');
-    sendAnalytics('failure');
-  }
+    someAsyncOperation(),
+    () => {
+        // This runs on success
+        console.log('Operation completed successfully');
+        sendAnalytics('success');
+    },
+    () => {
+        // This runs on failure
+        console.error('Operation failed');
+        sendAnalytics('failure');
+    },
 );
 ```
 
@@ -190,15 +186,13 @@ import promiseTuple from 'promise-tuple';
 import db from './database';
 
 async function getUserById(id: number) {
-  const [error, user] = await promiseTuple(
-    db.users.findById(id)
-  );
+    const [error, user] = await promiseTuple(db.users.findById(id));
 
-  if (error) {
-    return { success: false, message: 'User not found' };
-  }
+    if (error) {
+        return { success: false, message: 'User not found' };
+    }
 
-  return { success: true, user };
+    return { success: true, user };
 }
 ```
 
@@ -209,16 +203,14 @@ import promiseTuple from 'promise-tuple';
 import fs from 'fs/promises';
 
 async function readConfigFile(path: string) {
-  const [error, content] = await promiseTuple(
-    fs.readFile(path, 'utf-8')
-  );
+    const [error, content] = await promiseTuple(fs.readFile(path, 'utf-8'));
 
-  if (error) {
-    console.error('Failed to read config:', error);
-    return null;
-  }
+    if (error) {
+        console.error('Failed to read config:', error);
+        return null;
+    }
 
-  return JSON.parse(content);
+    return JSON.parse(content);
 }
 ```
 
@@ -229,25 +221,25 @@ import promiseTuple from 'promise-tuple';
 import db from './database';
 
 async function getUserById(id: number) {
-  const [error, user] = await promiseTuple(
-    db.users.findById(id),
-    () => {
-      // Track successful database query
-      console.log(`User ${id} retrieved successfully`);
-      metrics.incrementCounter('db.user.success');
-    },
-    () => {
-      // Track failed database query
-      console.error(`Failed to retrieve user ${id}`);
-      metrics.incrementCounter('db.user.failure');
+    const [error, user] = await promiseTuple(
+        db.users.findById(id),
+        () => {
+            // Track successful database query
+            console.log(`User ${id} retrieved successfully`);
+            metrics.incrementCounter('db.user.success');
+        },
+        () => {
+            // Track failed database query
+            console.error(`Failed to retrieve user ${id}`);
+            metrics.incrementCounter('db.user.failure');
+        },
+    );
+
+    if (error) {
+        return { success: false, message: 'User not found' };
     }
-  );
-
-  if (error) {
-    return { success: false, message: 'User not found' };
-  }
 
-  return { success: true, user };
+    return { success: true, user };
 }
 ```
 

package/dist/index.cjs

@@ -25,7 +25,11 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 async function promiseTuple(promise, successCallback, failureCallback) {
-  return promise.then((result) => (successCallback?.(), [void 0, result])).catch((error) => (failureCallback?.(), [error, void 0]));
+  return promise.then(
+    (result) => (successCallback?.(), [void 0, result])
+  ).catch(
+    (error) => (failureCallback?.(), [error, void 0])
+  );
 }
 var index_default = promiseTuple;
 // Annotate the CommonJS export names for ESM import in node:

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../index.ts"],"sourcesContent":["/**\r\n * Handles a promise and returns a tuple with error and result.\r\n *\r\n * This function wraps a promise and returns a tuple containing either an error or a result,\r\n * similar to Go's error handling pattern. If the promise resolves, the tuple will contain\r\n * `[undefined, result]`. If the promise rejects, the tuple will contain `[error, undefined]`.\r\n *\r\n * @template R - The type of the resolved value. Defaults to `unknown`.\r\n * @template E - The type of the error. Defaults to `unknown`.\r\n * @param promise - The promise to handle.\r\n * @param successCallback - Optional callback to execute when the promise resolves successfully.\r\n * @param failureCallback - Optional callback to execute when the promise rejects.\r\n * @returns A promise that resolves to a tuple containing either an error or a result.\r\n *          On success: `[undefined, result]`\r\n *          On failure: `[error, undefined]`\r\n *\r\n * @example\r\n * const [error, data] = await promiseTuple(fetchData());\r\n * if (error) {\r\n *   console.error('Error:', error);\r\n * } else {\r\n *   console.log('Data:', data);\r\n * }\r\n *\r\n * @example\r\n * const [error, data] = await promiseTuple(\r\n *   fetchData(),\r\n *   () => console.log('Success!'),\r\n *   () => console.log('Failed!')\r\n * );\r\n */\r\nexport async function promiseTuple<R = unknown, E = unknown>(\r\n    promise: Promise<R>,\r\n    successCallback?: () => void,\r\n    failureCallback?: () => void\r\n): Promise<[E | undefined, R | undefined]> {\r\n    return promise\r\n        .then((result) => (successCallback?.(), [undefined, result] as [undefined, R]))\r\n        .catch((error) => (failureCallback?.(), [error, undefined] as [E, undefined]))\r\n}\r\n\r\nexport default promiseTuple\r\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA+BA,eAAsB,aAClB,SACA,iBACA,iBACuC;AACvC,SAAO,QACF,KAAK,CAAC,YAAY,kBAAkB,GAAG,CAAC,QAAW,MAAM,EAAoB,EAC7E,MAAM,CAAC,WAAW,kBAAkB,GAAG,CAAC,OAAO,MAAS,EAAoB;AACrF;AAEA,IAAO,gBAAQ;","names":[]}
+{"version":3,"sources":["../index.ts"],"sourcesContent":["/**\n * Handles a promise and returns a tuple with error and result.\n *\n * This function wraps a promise and returns a tuple containing either an error or a result,\n * similar to Go's error handling pattern. If the promise resolves, the tuple will contain\n * `[undefined, result]`. If the promise rejects, the tuple will contain `[error, undefined]`.\n *\n * @template R - The type of the resolved value. Defaults to `unknown`.\n * @template E - The type of the error. Defaults to `unknown`.\n * @param promise - The promise to handle.\n * @param successCallback - Optional callback to execute when the promise resolves successfully.\n * @param failureCallback - Optional callback to execute when the promise rejects.\n * @returns A promise that resolves to a tuple containing either an error or a result.\n *          On success: `[undefined, result]`\n *          On failure: `[error, undefined]`\n *\n * @example\n * const [error, data] = await promiseTuple(fetchData());\n * if (error) {\n *   console.error('Error:', error);\n * } else {\n *   console.log('Data:', data);\n * }\n *\n * @example\n * const [error, data] = await promiseTuple(\n *   fetchData(),\n *   () => console.log('Success!'),\n *   () => console.log('Failed!')\n * );\n */\nexport async function promiseTuple<R = unknown, E = unknown>(\n    promise: Promise<R>,\n    successCallback?: () => void,\n    failureCallback?: () => void,\n): Promise<[E, undefined] | [undefined, R]> {\n    return promise\n        .then(\n            (result) => (\n                successCallback?.(),\n                [undefined, result] as [undefined, R]\n            ),\n        )\n        .catch(\n            (error) => (\n                failureCallback?.(),\n                [error, undefined] as [E, undefined]\n            ),\n        );\n}\n\nexport default promiseTuple;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA+BA,eAAsB,aAClB,SACA,iBACA,iBACwC;AACxC,SAAO,QACF;AAAA,IACG,CAAC,YACG,kBAAkB,GAClB,CAAC,QAAW,MAAM;AAAA,EAE1B,EACC;AAAA,IACG,CAAC,WACG,kBAAkB,GAClB,CAAC,OAAO,MAAS;AAAA,EAEzB;AACR;AAEA,IAAO,gBAAQ;","names":[]}

package/dist/index.d.cts

@@ -29,6 +29,6 @@
  *   () => console.log('Failed!')
  * );
  */
-declare function promiseTuple<R = unknown, E = unknown>(promise: Promise<R>, successCallback?: () => void, failureCallback?: () => void): Promise<[E | undefined, R | undefined]>;
+declare function promiseTuple<R = unknown, E = unknown>(promise: Promise<R>, successCallback?: () => void, failureCallback?: () => void): Promise<[E, undefined] | [undefined, R]>;
 
 export { promiseTuple as default, promiseTuple };

package/dist/index.d.ts

@@ -29,6 +29,6 @@
  *   () => console.log('Failed!')
  * );
  */
-declare function promiseTuple<R = unknown, E = unknown>(promise: Promise<R>, successCallback?: () => void, failureCallback?: () => void): Promise<[E | undefined, R | undefined]>;
+declare function promiseTuple<R = unknown, E = unknown>(promise: Promise<R>, successCallback?: () => void, failureCallback?: () => void): Promise<[E, undefined] | [undefined, R]>;
 
 export { promiseTuple as default, promiseTuple };

package/dist/index.js

@@ -1,6 +1,10 @@
 // index.ts
 async function promiseTuple(promise, successCallback, failureCallback) {
-  return promise.then((result) => (successCallback?.(), [void 0, result])).catch((error) => (failureCallback?.(), [error, void 0]));
+  return promise.then(
+    (result) => (successCallback?.(), [void 0, result])
+  ).catch(
+    (error) => (failureCallback?.(), [error, void 0])
+  );
 }
 var index_default = promiseTuple;
 export {

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../index.ts"],"sourcesContent":["/**\r\n * Handles a promise and returns a tuple with error and result.\r\n *\r\n * This function wraps a promise and returns a tuple containing either an error or a result,\r\n * similar to Go's error handling pattern. If the promise resolves, the tuple will contain\r\n * `[undefined, result]`. If the promise rejects, the tuple will contain `[error, undefined]`.\r\n *\r\n * @template R - The type of the resolved value. Defaults to `unknown`.\r\n * @template E - The type of the error. Defaults to `unknown`.\r\n * @param promise - The promise to handle.\r\n * @param successCallback - Optional callback to execute when the promise resolves successfully.\r\n * @param failureCallback - Optional callback to execute when the promise rejects.\r\n * @returns A promise that resolves to a tuple containing either an error or a result.\r\n *          On success: `[undefined, result]`\r\n *          On failure: `[error, undefined]`\r\n *\r\n * @example\r\n * const [error, data] = await promiseTuple(fetchData());\r\n * if (error) {\r\n *   console.error('Error:', error);\r\n * } else {\r\n *   console.log('Data:', data);\r\n * }\r\n *\r\n * @example\r\n * const [error, data] = await promiseTuple(\r\n *   fetchData(),\r\n *   () => console.log('Success!'),\r\n *   () => console.log('Failed!')\r\n * );\r\n */\r\nexport async function promiseTuple<R = unknown, E = unknown>(\r\n    promise: Promise<R>,\r\n    successCallback?: () => void,\r\n    failureCallback?: () => void\r\n): Promise<[E | undefined, R | undefined]> {\r\n    return promise\r\n        .then((result) => (successCallback?.(), [undefined, result] as [undefined, R]))\r\n        .catch((error) => (failureCallback?.(), [error, undefined] as [E, undefined]))\r\n}\r\n\r\nexport default promiseTuple\r\n"],"mappings":";AA+BA,eAAsB,aAClB,SACA,iBACA,iBACuC;AACvC,SAAO,QACF,KAAK,CAAC,YAAY,kBAAkB,GAAG,CAAC,QAAW,MAAM,EAAoB,EAC7E,MAAM,CAAC,WAAW,kBAAkB,GAAG,CAAC,OAAO,MAAS,EAAoB;AACrF;AAEA,IAAO,gBAAQ;","names":[]}
+{"version":3,"sources":["../index.ts"],"sourcesContent":["/**\n * Handles a promise and returns a tuple with error and result.\n *\n * This function wraps a promise and returns a tuple containing either an error or a result,\n * similar to Go's error handling pattern. If the promise resolves, the tuple will contain\n * `[undefined, result]`. If the promise rejects, the tuple will contain `[error, undefined]`.\n *\n * @template R - The type of the resolved value. Defaults to `unknown`.\n * @template E - The type of the error. Defaults to `unknown`.\n * @param promise - The promise to handle.\n * @param successCallback - Optional callback to execute when the promise resolves successfully.\n * @param failureCallback - Optional callback to execute when the promise rejects.\n * @returns A promise that resolves to a tuple containing either an error or a result.\n *          On success: `[undefined, result]`\n *          On failure: `[error, undefined]`\n *\n * @example\n * const [error, data] = await promiseTuple(fetchData());\n * if (error) {\n *   console.error('Error:', error);\n * } else {\n *   console.log('Data:', data);\n * }\n *\n * @example\n * const [error, data] = await promiseTuple(\n *   fetchData(),\n *   () => console.log('Success!'),\n *   () => console.log('Failed!')\n * );\n */\nexport async function promiseTuple<R = unknown, E = unknown>(\n    promise: Promise<R>,\n    successCallback?: () => void,\n    failureCallback?: () => void,\n): Promise<[E, undefined] | [undefined, R]> {\n    return promise\n        .then(\n            (result) => (\n                successCallback?.(),\n                [undefined, result] as [undefined, R]\n            ),\n        )\n        .catch(\n            (error) => (\n                failureCallback?.(),\n                [error, undefined] as [E, undefined]\n            ),\n        );\n}\n\nexport default promiseTuple;\n"],"mappings":";AA+BA,eAAsB,aAClB,SACA,iBACA,iBACwC;AACxC,SAAO,QACF;AAAA,IACG,CAAC,YACG,kBAAkB,GAClB,CAAC,QAAW,MAAM;AAAA,EAE1B,EACC;AAAA,IACG,CAAC,WACG,kBAAkB,GAClB,CAAC,OAAO,MAAS;AAAA,EAEzB;AACR;AAEA,IAAO,gBAAQ;","names":[]}

package/package.json

@@ -1,64 +1,74 @@
 {
-  "name": "promise-tuple",
-  "version": "1.1.2",
-  "description": "A utility function for handling promises with Go-like error handling pattern",
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "type": "module",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "require": {
-        "types": "./dist/index.d.cts",
-        "default": "./dist/index.cjs"
-      },
-      "import": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
-      }
+    "name": "promise-tuple",
+    "version": "1.1.4",
+    "description": "A utility function for handling promises with Go-like error handling pattern",
+    "main": "./dist/index.cjs",
+    "module": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "type": "module",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "require": {
+                "types": "./dist/index.d.cts",
+                "default": "./dist/index.cjs"
+            },
+            "import": {
+                "types": "./dist/index.d.ts",
+                "default": "./dist/index.js"
+            }
+        }
+    },
+    "sideEffects": false,
+    "scripts": {
+        "clean": "node -e \"require('fs').rmSync('dist', { recursive: true, force: true })\"",
+        "build": "tsup index.ts",
+        "lint": "eslint .",
+        "lint:fix": "eslint . --fix",
+        "format": "prettier . --write",
+        "format:check": "prettier . --check",
+        "test": "vitest run",
+        "prepublishOnly": "npm run clean && npm run build && npm run lint && npm run format:check && npm test"
+    },
+    "keywords": [
+        "promise",
+        "error-handling",
+        "async",
+        "utility",
+        "go-style",
+        "tuple",
+        "await",
+        "typescript"
+    ],
+    "author": "Eduardo DONATO <eduardo.donato@gmail.com>",
+    "license": "ISC",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/ebdonato/promise-tuple.git"
+    },
+    "bugs": {
+        "url": "https://github.com/ebdonato/promise-tuple/issues"
+    },
+    "homepage": "https://github.com/ebdonato/promise-tuple#readme",
+    "engines": {
+        "node": ">=16"
+    },
+    "files": [
+        "dist",
+        "README.md",
+        "LICENSE"
+    ],
+    "devDependencies": {
+        "@eslint/js": "^10.0.1",
+        "@types/node": "^20.0.0",
+        "eslint": "^10.0.3",
+        "eslint-config-prettier": "^10.1.8",
+        "globals": "^17.4.0",
+        "prettier": "^3.8.1",
+        "tsup": "^8.5.1",
+        "tsx": "^4.21.0",
+        "typescript": "^5.9.3",
+        "typescript-eslint": "^8.57.1",
+        "vitest": "^4.0.18"
     }
-  },
-  "sideEffects": false,
-  "scripts": {
-    "clean": "node -e \"require('fs').rmSync('dist', { recursive: true, force: true })\"",
-    "build": "tsup index.ts",
-    "test": "vitest run",
-    "prepublishOnly": "npm run clean && npm run build && npm test"
-  },
-  "keywords": [
-    "promise",
-    "error-handling",
-    "async",
-    "utility",
-    "go-style",
-    "tuple",
-    "await",
-    "typescript"
-  ],
-  "author": "Eduardo DONATO <eduardo.donato@gmail.com>",
-  "license": "ISC",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/ebdonato/promise-tuple.git"
-  },
-  "bugs": {
-    "url": "https://github.com/ebdonato/promise-tuple/issues"
-  },
-  "homepage": "https://github.com/ebdonato/promise-tuple#readme",
-  "engines": {
-    "node": ">=16"
-  },
-  "files": [
-    "dist",
-    "README.md",
-    "LICENSE"
-  ],
-  "devDependencies": {
-    "@types/node": "^20.0.0",
-    "tsup": "^8.5.1",
-    "tsx": "^4.21.0",
-    "typescript": "^5.9.3",
-    "vitest": "^4.0.18"
-  }
 }