@jcoreio/abortable 1.0.0

package/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 JCore Systems
+
+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,25 @@
+# @jcoreio/abortable
+
+memory-leak-proof function to wrap a promise to reject when a signal is aborted
+
+[![CircleCI](https://circleci.com/gh/jcoreio/abortable.svg?style=svg)](https://circleci.com/gh/jcoreio/abortable)
+[![Coverage Status](https://codecov.io/gh/jcoreio/abortable/branch/master/graph/badge.svg)](https://codecov.io/gh/jcoreio/abortable)
+[![semantic-release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg)](https://github.com/semantic-release/semantic-release)
+[![npm version](https://badge.fury.io/js/%40jcoreio%2Fabortable.svg)](https://badge.fury.io/js/%40jcoreio%2Fabortable)
+
+## `abortable(promise, signal)`
+
+Creates a promise that fulfills when the given `promise` fulfills, or rejects when the given `signal` is aborted,
+whichever comes first. If the signal is aborted, rejects with a `DOMException` with `name: 'AbortError'`.
+
+Once the returned promise resolves or rejects, references to all promise and signal handlers will have been removed,
+so that it doesn't unexpectedly retain any memory.
+
+```ts
+import { abortable } from '@jcoreio/abortable'
+
+const abortController = new AbortContorller()
+const { signal } = abortController
+
+const promise = abortable(new Promise((r) => setTimeout(r, 10000)), signal)
+```

package/index.d.ts

@@ -0,0 +1,3 @@
+export declare const newAbortError: () => DOMException;
+export declare function abortable<T>(promise: Promise<T>, signal: AbortSignal | undefined): Promise<T>;
+//# sourceMappingURL=index.d.ts.map

package/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["src/index.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa,oBACoC,CAAA;AAI9D,wBAAgB,SAAS,CAAC,CAAC,EACzB,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,MAAM,EAAE,WAAW,GAAG,SAAS,GAC9B,OAAO,CAAC,CAAC,CAAC,CA4BZ"}

package/index.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.abortable = abortable;
+exports.newAbortError = void 0;
+var newAbortError = exports.newAbortError = function newAbortError() {
+  return new DOMException('This operation was aborted', 'AbortError');
+};
+var noop = function noop() {};
+function abortable(promise, signal) {
+  if (!signal) return promise;
+  return new Promise(function (resolve, reject) {
+    if (signal.aborted) {
+      reject(newAbortError());
+      return;
+    }
+    var cleanup = function cleanup() {
+      var callbacks = {
+        resolve: resolve,
+        reject: reject
+      };
+      // Prevent memory leaks.  If the input promise never resolves, then the handlers
+      // below would retain this enclosing Promise's resolve and reject callbacks,
+      // which would retain the enclosing Promise and anything waiting on it.
+      // By replacing references to these callbacks, we enable the enclosing Promise to
+      // be garbage collected
+      resolve = noop;
+      reject = noop;
+      // Memory could also leak if the signal never aborts, unless we remove the abort
+      // handler
+      signal.removeEventListener('abort', onAbort);
+      return callbacks;
+    };
+    var onAbort = function onAbort() {
+      return cleanup().reject(newAbortError());
+    };
+    signal.addEventListener('abort', onAbort);
+    promise.then(function (value) {
+      return cleanup().resolve(value);
+    }, function (error) {
+      return cleanup().reject(error);
+    });
+  });
+}
+//# sourceMappingURL=index.js.map

package/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["newAbortError","exports","DOMException","noop","abortable","promise","signal","Promise","resolve","reject","aborted","cleanup","callbacks","removeEventListener","onAbort","addEventListener","then","value","error"],"sources":["src/index.ts"],"sourcesContent":["export const newAbortError = () =>\n  new DOMException('This operation was aborted', 'AbortError')\n\nconst noop = () => {}\n\nexport function abortable<T>(\n  promise: Promise<T>,\n  signal: AbortSignal | undefined\n): Promise<T> {\n  if (!signal) return promise\n  return new Promise<T>((resolve, reject) => {\n    if (signal.aborted) {\n      reject(newAbortError())\n      return\n    }\n    const cleanup = () => {\n      const callbacks = { resolve, reject }\n      // Prevent memory leaks.  If the input promise never resolves, then the handlers\n      // below would retain this enclosing Promise's resolve and reject callbacks,\n      // which would retain the enclosing Promise and anything waiting on it.\n      // By replacing references to these callbacks, we enable the enclosing Promise to\n      // be garbage collected\n      resolve = noop\n      reject = noop\n      // Memory could also leak if the signal never aborts, unless we remove the abort\n      // handler\n      signal.removeEventListener('abort', onAbort)\n      return callbacks\n    }\n    const onAbort = () => cleanup().reject(newAbortError())\n    signal.addEventListener('abort', onAbort)\n    promise.then(\n      (value) => cleanup().resolve(value),\n      (error) => cleanup().reject(error)\n    )\n  })\n}\n"],"mappings":";;;;;;;AAAO,IAAMA,aAAa,GAAAC,OAAA,CAAAD,aAAA,GAAG,SAAhBA,aAAaA,CAAA;EAAA,OACxB,IAAIE,YAAY,CAAC,4BAA4B,EAAE,YAAY,CAAC;AAAA;AAE9D,IAAMC,IAAI,GAAG,SAAPA,IAAIA,CAAA,EAAS,CAAC,CAAC;AAEd,SAASC,SAASA,CACvBC,OAAmB,EACnBC,MAA+B,EACnB;EACZ,IAAI,CAACA,MAAM,EAAE,OAAOD,OAAO;EAC3B,OAAO,IAAIE,OAAO,CAAI,UAACC,OAAO,EAAEC,MAAM,EAAK;IACzC,IAAIH,MAAM,CAACI,OAAO,EAAE;MAClBD,MAAM,CAACT,aAAa,CAAC,CAAC,CAAC;MACvB;IACF;IACA,IAAMW,OAAO,GAAG,SAAVA,OAAOA,CAAA,EAAS;MACpB,IAAMC,SAAS,GAAG;QAAEJ,OAAO,EAAPA,OAAO;QAAEC,MAAM,EAANA;MAAO,CAAC;MACrC;MACA;MACA;MACA;MACA;MACAD,OAAO,GAAGL,IAAI;MACdM,MAAM,GAAGN,IAAI;MACb;MACA;MACAG,MAAM,CAACO,mBAAmB,CAAC,OAAO,EAAEC,OAAO,CAAC;MAC5C,OAAOF,SAAS;IAClB,CAAC;IACD,IAAME,OAAO,GAAG,SAAVA,OAAOA,CAAA;MAAA,OAASH,OAAO,CAAC,CAAC,CAACF,MAAM,CAACT,aAAa,CAAC,CAAC,CAAC;IAAA;IACvDM,MAAM,CAACS,gBAAgB,CAAC,OAAO,EAAED,OAAO,CAAC;IACzCT,OAAO,CAACW,IAAI,CACV,UAACC,KAAK;MAAA,OAAKN,OAAO,CAAC,CAAC,CAACH,OAAO,CAACS,KAAK,CAAC;IAAA,GACnC,UAACC,KAAK;MAAA,OAAKP,OAAO,CAAC,CAAC,CAACF,MAAM,CAACS,KAAK,CAAC;IAAA,CACpC,CAAC;EACH,CAAC,CAAC;AACJ","ignoreList":[]}

package/index.mjs

@@ -0,0 +1,32 @@
+export const newAbortError = () => new DOMException('This operation was aborted', 'AbortError');
+const noop = () => {};
+export function abortable(promise, signal) {
+  if (!signal) return promise;
+  return new Promise((resolve, reject) => {
+    if (signal.aborted) {
+      reject(newAbortError());
+      return;
+    }
+    const cleanup = () => {
+      const callbacks = {
+        resolve,
+        reject
+      };
+      // Prevent memory leaks.  If the input promise never resolves, then the handlers
+      // below would retain this enclosing Promise's resolve and reject callbacks,
+      // which would retain the enclosing Promise and anything waiting on it.
+      // By replacing references to these callbacks, we enable the enclosing Promise to
+      // be garbage collected
+      resolve = noop;
+      reject = noop;
+      // Memory could also leak if the signal never aborts, unless we remove the abort
+      // handler
+      signal.removeEventListener('abort', onAbort);
+      return callbacks;
+    };
+    const onAbort = () => cleanup().reject(newAbortError());
+    signal.addEventListener('abort', onAbort);
+    promise.then(value => cleanup().resolve(value), error => cleanup().reject(error));
+  });
+}
+//# sourceMappingURL=index.mjs.map

package/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["newAbortError","DOMException","noop","abortable","promise","signal","Promise","resolve","reject","aborted","cleanup","callbacks","removeEventListener","onAbort","addEventListener","then","value","error"],"sources":["src/index.ts"],"sourcesContent":["export const newAbortError = () =>\n  new DOMException('This operation was aborted', 'AbortError')\n\nconst noop = () => {}\n\nexport function abortable<T>(\n  promise: Promise<T>,\n  signal: AbortSignal | undefined\n): Promise<T> {\n  if (!signal) return promise\n  return new Promise<T>((resolve, reject) => {\n    if (signal.aborted) {\n      reject(newAbortError())\n      return\n    }\n    const cleanup = () => {\n      const callbacks = { resolve, reject }\n      // Prevent memory leaks.  If the input promise never resolves, then the handlers\n      // below would retain this enclosing Promise's resolve and reject callbacks,\n      // which would retain the enclosing Promise and anything waiting on it.\n      // By replacing references to these callbacks, we enable the enclosing Promise to\n      // be garbage collected\n      resolve = noop\n      reject = noop\n      // Memory could also leak if the signal never aborts, unless we remove the abort\n      // handler\n      signal.removeEventListener('abort', onAbort)\n      return callbacks\n    }\n    const onAbort = () => cleanup().reject(newAbortError())\n    signal.addEventListener('abort', onAbort)\n    promise.then(\n      (value) => cleanup().resolve(value),\n      (error) => cleanup().reject(error)\n    )\n  })\n}\n"],"mappings":"AAAA,OAAO,MAAMA,aAAa,GAAGA,CAAA,KAC3B,IAAIC,YAAY,CAAC,4BAA4B,EAAE,YAAY,CAAC;AAE9D,MAAMC,IAAI,GAAGA,CAAA,KAAM,CAAC,CAAC;AAErB,OAAO,SAASC,SAASA,CACvBC,OAAmB,EACnBC,MAA+B,EACnB;EACZ,IAAI,CAACA,MAAM,EAAE,OAAOD,OAAO;EAC3B,OAAO,IAAIE,OAAO,CAAI,CAACC,OAAO,EAAEC,MAAM,KAAK;IACzC,IAAIH,MAAM,CAACI,OAAO,EAAE;MAClBD,MAAM,CAACR,aAAa,CAAC,CAAC,CAAC;MACvB;IACF;IACA,MAAMU,OAAO,GAAGA,CAAA,KAAM;MACpB,MAAMC,SAAS,GAAG;QAAEJ,OAAO;QAAEC;MAAO,CAAC;MACrC;MACA;MACA;MACA;MACA;MACAD,OAAO,GAAGL,IAAI;MACdM,MAAM,GAAGN,IAAI;MACb;MACA;MACAG,MAAM,CAACO,mBAAmB,CAAC,OAAO,EAAEC,OAAO,CAAC;MAC5C,OAAOF,SAAS;IAClB,CAAC;IACD,MAAME,OAAO,GAAGA,CAAA,KAAMH,OAAO,CAAC,CAAC,CAACF,MAAM,CAACR,aAAa,CAAC,CAAC,CAAC;IACvDK,MAAM,CAACS,gBAAgB,CAAC,OAAO,EAAED,OAAO,CAAC;IACzCT,OAAO,CAACW,IAAI,CACTC,KAAK,IAAKN,OAAO,CAAC,CAAC,CAACH,OAAO,CAACS,KAAK,CAAC,EAClCC,KAAK,IAAKP,OAAO,CAAC,CAAC,CAACF,MAAM,CAACS,KAAK,CACnC,CAAC;EACH,CAAC,CAAC;AACJ","ignoreList":[]}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@jcoreio/abortable",
+  "description": "memory-leak-proof function to wrap a promise to reject when a signal is aborted",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jcoreio/abortable.git"
+  },
+  "homepage": "https://github.com/jcoreio/abortable",
+  "bugs": {
+    "url": "https://github.com/jcoreio/abortable/issues"
+  },
+  "author": "Andy Edwards",
+  "license": "MIT",
+  "keywords": [
+    "signal",
+    "abortsignal",
+    "abort",
+    "promise"
+  ],
+  "version": "1.0.0",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=16"
+  },
+  "main": "./index.js",
+  "module": "./index.mjs",
+  "types": "./index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.mjs",
+      "default": "./index.js"
+    }
+  },
+  "packageManager": "pnpm@8.11.0",
+  "dependencies": {},
+  "@jcoreio/toolchain": {
+    "migratedVersion": "4.12.3"
+  }
+}

package/src/index.ts

@@ -0,0 +1,37 @@
+export const newAbortError = () =>
+  new DOMException('This operation was aborted', 'AbortError')
+
+const noop = () => {}
+
+export function abortable<T>(
+  promise: Promise<T>,
+  signal: AbortSignal | undefined
+): Promise<T> {
+  if (!signal) return promise
+  return new Promise<T>((resolve, reject) => {
+    if (signal.aborted) {
+      reject(newAbortError())
+      return
+    }
+    const cleanup = () => {
+      const callbacks = { resolve, reject }
+      // Prevent memory leaks.  If the input promise never resolves, then the handlers
+      // below would retain this enclosing Promise's resolve and reject callbacks,
+      // which would retain the enclosing Promise and anything waiting on it.
+      // By replacing references to these callbacks, we enable the enclosing Promise to
+      // be garbage collected
+      resolve = noop
+      reject = noop
+      // Memory could also leak if the signal never aborts, unless we remove the abort
+      // handler
+      signal.removeEventListener('abort', onAbort)
+      return callbacks
+    }
+    const onAbort = () => cleanup().reject(newAbortError())
+    signal.addEventListener('abort', onAbort)
+    promise.then(
+      (value) => cleanup().resolve(value),
+      (error) => cleanup().reject(error)
+    )
+  })
+}