@homer0/extend-promise 1.0.1

package/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Leonardo Apiwan (@homer0)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -0,0 +1,96 @@
+# 💫 Extend promise
+
+Extend a `Promise` by injecting custom properties using a `Proxy`. The custom properties will be available on the promise chain no matter how many `then`s, `catch`s or `finally`s are added.
+
+## 🍿 Usage
+
+> If you are wondering why I built this, go to the [Motivation](#motivation) section.
+
+- ⚙️ [Examples](#%EF%B8%8F-examples)
+- 🤘 [Development](#-development)
+
+### ⚙️ Examples
+
+> This function can be used with any kind of promises, but the example focuses on requests because, nowadays, they are the most common context for promises.
+
+Let's say you have a function that makes a request and you want to be able to return a way to abort it at any point. You can use [`fetch`](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API) and
+an [`AbortController`](https://developer.mozilla.org/en-US/docs/Web/API/AbortController) to do it, but you can't return just the promise, you need to return the controller, or at least its `abort` method:
+
+```js
+const makeTheRequest = () => {
+  const controller = new AbortController();
+  const req = fetch('https://...', {
+    signal: controller.signal,
+  });
+
+  return { req, controller };
+};
+```
+
+It looks good, but if the function is called from a service or somewhere that is not the actual implementation, you'll need to keep track of both the `Promise` and the `controller`.
+
+You could _monkey patch_ the `abort` method to the `Promise`:
+
+```js
+const makeTheRequest = () => {
+  const controller = new AbortController();
+  const req = fetch('https://...', {
+    signal: controller.signal,
+  });
+  req.abort = controller.abort.bind(this);
+  return req;
+};
+```
+
+But there's a problem: the moment a `.then`/`.catch`/`.finally` is added to that `Promise`, a new one is generated, and the patch goes away.
+
+This is where `extend-promise` can help you: Either the `controller` or the `abort` method can be added to the chain and the customization will be available no matter how many `.then`s are added:
+
+```js
+import { extendPromise } from '@homer0/extend-promise';
+
+const makeTheRequest = () => {
+  const controller = new AbortController();
+  const req = fetch('https://...', {
+    signal: controller.signal,
+  });
+
+  return extendPromise(req, {
+    abort: controller.abort.bind(this),
+  });
+};
+```
+
+And there you go! You can now receive the request `Promise` and abort it if needed:
+
+```js
+// Make the request
+const req = makeTheRequest()
+.then((response) => response.json())
+.catch((error) => {
+  if (error.name === 'AbortError') {
+    console.log('to late...');
+  }
+  ...
+});
+
+// Abort it if takes more than one second.
+setTimeout(() => req.abort(), 1000);
+```
+
+### 🤘 Development
+
+As this project is part of the `packages` monorepo, it requires Yarn, and some of the tooling, like ESLint and Husky, are installed on the root's `package.json`.
+
+#### Yarn tasks
+
+| Task    | Description          |
+| ------- | -------------------- |
+| `test`  | Runs the unit tests. |
+| `build` | Bundles the project. |
+
+## Motivation
+
+This used to be part of the [`wootils`](https://www.npmjs.com/package/wootils) package, my personal lib of utilities, but I decided to extract them into individual packages, as part of the `packages` monorepo, and take the oportunity to migrate them to TypeScript.
+
+Now, the example in this same `README` is the reason I built it: I wanted the `AbortController` to be available on the `Promise` chain.

package/dist/esm/index.js

@@ -0,0 +1,46 @@
+// src/index.ts
+var PromiseExtender = class {
+  promise;
+  constructor(promise, properties) {
+    this.promise = this.extend(promise, properties);
+  }
+  extend(promise, properties) {
+    if (!(promise instanceof Promise)) {
+      throw new Error("'promise' must be a valid Promise instance");
+    }
+    if (!properties || !Object.keys(properties).length) {
+      throw new Error("'properties' must be an object with at least one key");
+    }
+    const extended = new Proxy(promise, {
+      get: (target, name) => {
+        const targetKey = name;
+        if (typeof name === "string" && ["then", "catch", "finally"].includes(name) && name in target) {
+          const fn = target[targetKey];
+          return this.extendFunction(fn.bind(target), properties);
+        }
+        if (name in target) {
+          const possibleFn = target[targetKey];
+          if (typeof possibleFn["bind"] === "function") {
+            return possibleFn["bind"](target);
+          }
+        }
+        const key = name;
+        return properties[key];
+      }
+    });
+    return extended;
+  }
+  extendFunction(fn, properties) {
+    return new Proxy(fn, {
+      apply: (target, thisArg, args) => {
+        const value = target.bind(thisArg)(...args);
+        return this.extend(value, properties);
+      }
+    });
+  }
+};
+var extendPromise = (promise, properties) => new PromiseExtender(promise, properties).promise;
+export {
+  extendPromise
+};
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/index.ts"],"sourcesContent":["type ExtractGeneric<Type> = Type extends Promise<infer X> ? X : never;\n\ntype ExtendedPromise<T extends Promise<unknown>, P, V = ExtractGeneric<T>> = Omit<\n  T,\n  'then' | 'catch' | 'finally'\n> &\n  P & {\n    then: (...args: Parameters<T['then']>) => ExtendedPromise<Promise<V>, P>;\n    catch: (...args: Parameters<T['catch']>) => ExtendedPromise<Promise<V>, P>;\n    finally: (...args: Parameters<T['finally']>) => ExtendedPromise<Promise<V>, P>;\n  };\ntype GenericFn = (...args: unknown[]) => unknown;\ntype ExtendedFn<F extends GenericFn, P> = F & P;\n\n/**\n * Helper class that creates a proxy for a {@link Promise} in order to add custom\n * properties.\n *\n * The only reason this class exists is so it can \"scope\" the necessary methods to extend\n * {@link Promise} and avoid workarounds in order to declare them, as they need to call\n * themselves recursively.\n */\nclass PromiseExtender<T extends Promise<unknown>, P extends Record<string, unknown>> {\n  /**\n   * The proxied promise.\n   */\n  readonly promise: ExtendedPromise<T, P>;\n  /**\n   * @param promise     The promise to extend.\n   * @param properties  A dictionary of custom properties to _inject_ in the promise\n   *                    chain.\n   */\n  constructor(promise: T, properties: P) {\n    this.promise = this.extend(promise, properties);\n  }\n  /**\n   * The method that actually extends a promise: it creates a proxy of the promise in\n   * order to intercept the getters so it can return the custom properties if requested,\n   * and return new proxies when `then`, `catch` and `finally` are called; the reason new\n   * proxies are created is because those methods return new promises, and without being\n   * proxied, the custom properties would be lost.\n   *\n   * @param promise     The promise to proxy.\n   * @param properties  A dictionary of custom properties to _inject_ in the promise\n   *                    chain.\n   * @throws {Error} If `promise` is not a valid instance of {@link Promise}.\n   * @throws {Error} If `properties` is not an object or if it doesn't have any\n   *                 properties.\n   */\n  extend(promise: T, properties: P): ExtendedPromise<T, P> {\n    if (!(promise instanceof Promise)) {\n      throw new Error(\"'promise' must be a valid Promise instance\");\n    }\n\n    if (!properties || !Object.keys(properties).length) {\n      throw new Error(\"'properties' must be an object with at least one key\");\n    }\n\n    const extended = new Proxy(promise, {\n      /**\n       * This is a trap for when something is trying to read/access a property for the\n       * promise.\n       * The function first validates if it's one of the functions\n       * (`then`/`catch`/`finally`) in order to return a proxied function; then, if it's\n       * another function (one that doesn't return another promise), it just calls the\n       * original; finally, before doing a fallback to the original promise, it checks if\n       * it's one of the custom properties that exented the promise.\n       *\n       * @param target  The original promise.\n       * @param name    The name of the property.\n       */\n      get: (target, name) => {\n        const targetKey = name as keyof typeof target;\n        if (\n          typeof name === 'string' &&\n          ['then', 'catch', 'finally'].includes(name) &&\n          name in target\n        ) {\n          const fn = target[targetKey] as unknown as GenericFn;\n          return this.extendFunction(fn.bind(target), properties);\n        }\n\n        if (name in target) {\n          const possibleFn = target[targetKey] as unknown as Record<string, unknown>;\n          // eslint-disable-next-line dot-notation\n          if (typeof possibleFn['bind'] === 'function') {\n            // eslint-disable-next-line dot-notation\n            return possibleFn['bind'](target);\n          }\n        }\n\n        const key = name as keyof P;\n        return properties[key];\n      },\n    });\n\n    return extended as ExtendedPromise<T, P>;\n  }\n  /**\n   * Creates a proxy for a promise function (`then`/`catch`/`finally`) so the returned\n   * promise can also be extended.\n   *\n   * @param fn          The promise function to proxy.\n   * @param properties  A dictionary of custom properties to _inject_ in the promise\n   *                    chain.\n   */\n  protected extendFunction<F extends GenericFn>(fn: F, properties: P): ExtendedFn<F, P> {\n    return new Proxy(fn, {\n      /**\n       * This is a trap for when a function gets called (remember this gets used for\n       * `then`/\n       * `catch`/`finally`); it processes the result using the oringinal function and\n       * since promise methods return a promise, instead of returning the original result,\n       * it returns an _extended_ version of it.\n       *\n       * @param target   The original function.\n       * @param thisArg  The promise the function belongs to.\n       * @param args     The list of arguments sent to the trap.\n       */\n      apply: (target, thisArg, args) => {\n        const value = target.bind(thisArg)(...args);\n        return this.extend(value as T, properties);\n      },\n    }) as ExtendedFn<F, P>;\n  }\n}\n\n/**\n * Extends a {@link Promise} by injecting custom properties using a {@link Proxy}. The\n * custom properties will be available on the promise chain no matter how many `then`s,\n * `catch`s or `finally`s are added.\n *\n * @param promise     The promise to extend.\n * @param properties  A dictionary of custom properties to _inject_ in the promise\n *                    chain.\n * @throws {Error} If `promise` is not a valid instance of {@link Promise}.\n * @throws {Error} If `properties` is not an object or if it doesn't have any\n *                 properties.\n */\nexport const extendPromise = <\n  T extends Promise<unknown>,\n  P extends Record<string, unknown>,\n>(\n  promise: T,\n  properties: P,\n): ExtendedPromise<T, P> => new PromiseExtender(promise, properties).promise;\n"],"mappings":";AAsBA,IAAM,kBAAN,MAAqF;AAAA,EAInF,AAAS;AAAA,EAMT,YAAY,SAAY,YAAe;AACrC,SAAK,UAAU,KAAK,OAAO,SAAS,UAAU;AAAA,EAChD;AAAA,EAeA,OAAO,SAAY,YAAsC;AACvD,QAAI,CAAE,oBAAmB,UAAU;AACjC,YAAM,IAAI,MAAM,4CAA4C;AAAA,IAC9D;AAEA,QAAI,CAAC,cAAc,CAAC,OAAO,KAAK,UAAU,EAAE,QAAQ;AAClD,YAAM,IAAI,MAAM,sDAAsD;AAAA,IACxE;AAEA,UAAM,WAAW,IAAI,MAAM,SAAS;AAAA,MAalC,KAAK,CAAC,QAAQ,SAAS;AACrB,cAAM,YAAY;AAClB,YACE,OAAO,SAAS,YAChB,CAAC,QAAQ,SAAS,SAAS,EAAE,SAAS,IAAI,KAC1C,QAAQ,QACR;AACA,gBAAM,KAAK,OAAO;AAClB,iBAAO,KAAK,eAAe,GAAG,KAAK,MAAM,GAAG,UAAU;AAAA,QACxD;AAEA,YAAI,QAAQ,QAAQ;AAClB,gBAAM,aAAa,OAAO;AAE1B,cAAI,OAAO,WAAW,YAAY,YAAY;AAE5C,mBAAO,WAAW,QAAQ,MAAM;AAAA,UAClC;AAAA,QACF;AAEA,cAAM,MAAM;AACZ,eAAO,WAAW;AAAA,MACpB;AAAA,IACF,CAAC;AAED,WAAO;AAAA,EACT;AAAA,EASA,AAAU,eAAoC,IAAO,YAAiC;AACpF,WAAO,IAAI,MAAM,IAAI;AAAA,MAYnB,OAAO,CAAC,QAAQ,SAAS,SAAS;AAChC,cAAM,QAAQ,OAAO,KAAK,OAAO,EAAE,GAAG,IAAI;AAC1C,eAAO,KAAK,OAAO,OAAY,UAAU;AAAA,MAC3C;AAAA,IACF,CAAC;AAAA,EACH;AACF;AAcO,IAAM,gBAAgB,CAI3B,SACA,eAC0B,IAAI,gBAAgB,SAAS,UAAU,EAAE;","names":[]}

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+declare type ExtractGeneric<Type> = Type extends Promise<infer X> ? X : never;
+declare type ExtendedPromise<T extends Promise<unknown>, P, V = ExtractGeneric<T>> = Omit<T, 'then' | 'catch' | 'finally'> & P & {
+    then: (...args: Parameters<T['then']>) => ExtendedPromise<Promise<V>, P>;
+    catch: (...args: Parameters<T['catch']>) => ExtendedPromise<Promise<V>, P>;
+    finally: (...args: Parameters<T['finally']>) => ExtendedPromise<Promise<V>, P>;
+};
+/**
+ * Extends a {@link Promise} by injecting custom properties using a {@link Proxy}. The
+ * custom properties will be available on the promise chain no matter how many `then`s,
+ * `catch`s or `finally`s are added.
+ *
+ * @param promise     The promise to extend.
+ * @param properties  A dictionary of custom properties to _inject_ in the promise
+ *                    chain.
+ * @throws {Error} If `promise` is not a valid instance of {@link Promise}.
+ * @throws {Error} If `properties` is not an object or if it doesn't have any
+ *                 properties.
+ */
+declare const extendPromise: <T extends Promise<unknown>, P extends Record<string, unknown>>(promise: T, properties: P) => ExtendedPromise<T, P, ExtractGeneric<T>>;
+
+export { extendPromise };

package/dist/index.js

@@ -0,0 +1,71 @@
+"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/index.ts
+var src_exports = {};
+__export(src_exports, {
+  extendPromise: () => extendPromise
+});
+module.exports = __toCommonJS(src_exports);
+var PromiseExtender = class {
+  promise;
+  constructor(promise, properties) {
+    this.promise = this.extend(promise, properties);
+  }
+  extend(promise, properties) {
+    if (!(promise instanceof Promise)) {
+      throw new Error("'promise' must be a valid Promise instance");
+    }
+    if (!properties || !Object.keys(properties).length) {
+      throw new Error("'properties' must be an object with at least one key");
+    }
+    const extended = new Proxy(promise, {
+      get: (target, name) => {
+        const targetKey = name;
+        if (typeof name === "string" && ["then", "catch", "finally"].includes(name) && name in target) {
+          const fn = target[targetKey];
+          return this.extendFunction(fn.bind(target), properties);
+        }
+        if (name in target) {
+          const possibleFn = target[targetKey];
+          if (typeof possibleFn["bind"] === "function") {
+            return possibleFn["bind"](target);
+          }
+        }
+        const key = name;
+        return properties[key];
+      }
+    });
+    return extended;
+  }
+  extendFunction(fn, properties) {
+    return new Proxy(fn, {
+      apply: (target, thisArg, args) => {
+        const value = target.bind(thisArg)(...args);
+        return this.extend(value, properties);
+      }
+    });
+  }
+};
+var extendPromise = (promise, properties) => new PromiseExtender(promise, properties).promise;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  extendPromise
+});
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["type ExtractGeneric<Type> = Type extends Promise<infer X> ? X : never;\n\ntype ExtendedPromise<T extends Promise<unknown>, P, V = ExtractGeneric<T>> = Omit<\n  T,\n  'then' | 'catch' | 'finally'\n> &\n  P & {\n    then: (...args: Parameters<T['then']>) => ExtendedPromise<Promise<V>, P>;\n    catch: (...args: Parameters<T['catch']>) => ExtendedPromise<Promise<V>, P>;\n    finally: (...args: Parameters<T['finally']>) => ExtendedPromise<Promise<V>, P>;\n  };\ntype GenericFn = (...args: unknown[]) => unknown;\ntype ExtendedFn<F extends GenericFn, P> = F & P;\n\n/**\n * Helper class that creates a proxy for a {@link Promise} in order to add custom\n * properties.\n *\n * The only reason this class exists is so it can \"scope\" the necessary methods to extend\n * {@link Promise} and avoid workarounds in order to declare them, as they need to call\n * themselves recursively.\n */\nclass PromiseExtender<T extends Promise<unknown>, P extends Record<string, unknown>> {\n  /**\n   * The proxied promise.\n   */\n  readonly promise: ExtendedPromise<T, P>;\n  /**\n   * @param promise     The promise to extend.\n   * @param properties  A dictionary of custom properties to _inject_ in the promise\n   *                    chain.\n   */\n  constructor(promise: T, properties: P) {\n    this.promise = this.extend(promise, properties);\n  }\n  /**\n   * The method that actually extends a promise: it creates a proxy of the promise in\n   * order to intercept the getters so it can return the custom properties if requested,\n   * and return new proxies when `then`, `catch` and `finally` are called; the reason new\n   * proxies are created is because those methods return new promises, and without being\n   * proxied, the custom properties would be lost.\n   *\n   * @param promise     The promise to proxy.\n   * @param properties  A dictionary of custom properties to _inject_ in the promise\n   *                    chain.\n   * @throws {Error} If `promise` is not a valid instance of {@link Promise}.\n   * @throws {Error} If `properties` is not an object or if it doesn't have any\n   *                 properties.\n   */\n  extend(promise: T, properties: P): ExtendedPromise<T, P> {\n    if (!(promise instanceof Promise)) {\n      throw new Error(\"'promise' must be a valid Promise instance\");\n    }\n\n    if (!properties || !Object.keys(properties).length) {\n      throw new Error(\"'properties' must be an object with at least one key\");\n    }\n\n    const extended = new Proxy(promise, {\n      /**\n       * This is a trap for when something is trying to read/access a property for the\n       * promise.\n       * The function first validates if it's one of the functions\n       * (`then`/`catch`/`finally`) in order to return a proxied function; then, if it's\n       * another function (one that doesn't return another promise), it just calls the\n       * original; finally, before doing a fallback to the original promise, it checks if\n       * it's one of the custom properties that exented the promise.\n       *\n       * @param target  The original promise.\n       * @param name    The name of the property.\n       */\n      get: (target, name) => {\n        const targetKey = name as keyof typeof target;\n        if (\n          typeof name === 'string' &&\n          ['then', 'catch', 'finally'].includes(name) &&\n          name in target\n        ) {\n          const fn = target[targetKey] as unknown as GenericFn;\n          return this.extendFunction(fn.bind(target), properties);\n        }\n\n        if (name in target) {\n          const possibleFn = target[targetKey] as unknown as Record<string, unknown>;\n          // eslint-disable-next-line dot-notation\n          if (typeof possibleFn['bind'] === 'function') {\n            // eslint-disable-next-line dot-notation\n            return possibleFn['bind'](target);\n          }\n        }\n\n        const key = name as keyof P;\n        return properties[key];\n      },\n    });\n\n    return extended as ExtendedPromise<T, P>;\n  }\n  /**\n   * Creates a proxy for a promise function (`then`/`catch`/`finally`) so the returned\n   * promise can also be extended.\n   *\n   * @param fn          The promise function to proxy.\n   * @param properties  A dictionary of custom properties to _inject_ in the promise\n   *                    chain.\n   */\n  protected extendFunction<F extends GenericFn>(fn: F, properties: P): ExtendedFn<F, P> {\n    return new Proxy(fn, {\n      /**\n       * This is a trap for when a function gets called (remember this gets used for\n       * `then`/\n       * `catch`/`finally`); it processes the result using the oringinal function and\n       * since promise methods return a promise, instead of returning the original result,\n       * it returns an _extended_ version of it.\n       *\n       * @param target   The original function.\n       * @param thisArg  The promise the function belongs to.\n       * @param args     The list of arguments sent to the trap.\n       */\n      apply: (target, thisArg, args) => {\n        const value = target.bind(thisArg)(...args);\n        return this.extend(value as T, properties);\n      },\n    }) as ExtendedFn<F, P>;\n  }\n}\n\n/**\n * Extends a {@link Promise} by injecting custom properties using a {@link Proxy}. The\n * custom properties will be available on the promise chain no matter how many `then`s,\n * `catch`s or `finally`s are added.\n *\n * @param promise     The promise to extend.\n * @param properties  A dictionary of custom properties to _inject_ in the promise\n *                    chain.\n * @throws {Error} If `promise` is not a valid instance of {@link Promise}.\n * @throws {Error} If `properties` is not an object or if it doesn't have any\n *                 properties.\n */\nexport const extendPromise = <\n  T extends Promise<unknown>,\n  P extends Record<string, unknown>,\n>(\n  promise: T,\n  properties: P,\n): ExtendedPromise<T, P> => new PromiseExtender(promise, properties).promise;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAsBA,IAAM,kBAAN,MAAqF;AAAA,EAInF,AAAS;AAAA,EAMT,YAAY,SAAY,YAAe;AACrC,SAAK,UAAU,KAAK,OAAO,SAAS,UAAU;AAAA,EAChD;AAAA,EAeA,OAAO,SAAY,YAAsC;AACvD,QAAI,CAAE,oBAAmB,UAAU;AACjC,YAAM,IAAI,MAAM,4CAA4C;AAAA,IAC9D;AAEA,QAAI,CAAC,cAAc,CAAC,OAAO,KAAK,UAAU,EAAE,QAAQ;AAClD,YAAM,IAAI,MAAM,sDAAsD;AAAA,IACxE;AAEA,UAAM,WAAW,IAAI,MAAM,SAAS;AAAA,MAalC,KAAK,CAAC,QAAQ,SAAS;AACrB,cAAM,YAAY;AAClB,YACE,OAAO,SAAS,YAChB,CAAC,QAAQ,SAAS,SAAS,EAAE,SAAS,IAAI,KAC1C,QAAQ,QACR;AACA,gBAAM,KAAK,OAAO;AAClB,iBAAO,KAAK,eAAe,GAAG,KAAK,MAAM,GAAG,UAAU;AAAA,QACxD;AAEA,YAAI,QAAQ,QAAQ;AAClB,gBAAM,aAAa,OAAO;AAE1B,cAAI,OAAO,WAAW,YAAY,YAAY;AAE5C,mBAAO,WAAW,QAAQ,MAAM;AAAA,UAClC;AAAA,QACF;AAEA,cAAM,MAAM;AACZ,eAAO,WAAW;AAAA,MACpB;AAAA,IACF,CAAC;AAED,WAAO;AAAA,EACT;AAAA,EASA,AAAU,eAAoC,IAAO,YAAiC;AACpF,WAAO,IAAI,MAAM,IAAI;AAAA,MAYnB,OAAO,CAAC,QAAQ,SAAS,SAAS;AAChC,cAAM,QAAQ,OAAO,KAAK,OAAO,EAAE,GAAG,IAAI;AAC1C,eAAO,KAAK,OAAO,OAAY,UAAU;AAAA,MAC3C;AAAA,IACF,CAAC;AAAA,EACH;AACF;AAcO,IAAM,gBAAgB,CAI3B,SACA,eAC0B,IAAI,gBAAgB,SAAS,UAAU,EAAE;","names":[]}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@homer0/extend-promise",
+  "description": "Extends a promise with custom properties",
+  "version": "1.0.1",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/homer0/packages.git",
+    "directory": "packages/public/extend-promise"
+  },
+  "author": "Leonardo Apiwan (@homer0) <me@homer0.com>",
+  "license": "MIT",
+  "keywords": [
+    "promise",
+    "custom",
+    "utility",
+    "wootils",
+    "javascript"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist/"
+  ],
+  "devDependencies": {
+    "@types/jest": "^28.1.4",
+    "jest": "^28.1.2",
+    "ts-jest": "^28.0.5",
+    "tsup": "^6.1.3",
+    "typescript": "^4.7.4"
+  },
+  "engine-strict": true,
+  "engines": {
+    "node": ">=14"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "test": "jest -c ./.jestrc.js",
+    "types:check": "tsc --noEmit && tsc --noEmit --project ./tests/tsconfig.json",
+    "build": "tsup src/index.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "gitHead": "835d84ced485240f90c9c9173b5fcb53346bf264"
+}