saborter 1.4.2 → 1.5.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 Vladislav Laptev
+Copyright (c) 2026 Vladislav Laptev
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/dist/index.cjs.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const EMIT_METHOD_SYMBOL = /* @__PURE__ */ Symbol("STATE-OBSERVER:EMIT_METHOD");
-const CLEAR_METHOD_SYMBOL$1 = /* @__PURE__ */ Symbol("STATE-OBSERVER:CLEAR_METHOD");
+const emitMethodSymbol = /* @__PURE__ */ Symbol("state-observer::emit()");
+const clearMethodSymbol$1 = /* @__PURE__ */ Symbol("state-observer::clear()");
 var _a$1, _b;
-_b = EMIT_METHOD_SYMBOL, _a$1 = CLEAR_METHOD_SYMBOL$1;
+_b = emitMethodSymbol, _a$1 = clearMethodSymbol$1;
 class StateObserver {
   constructor(options) {
     this.subscribers = /* @__PURE__ */ new Set();
@@ -22,7 +22,7 @@ class StateObserver {
       this.onstatechange?.(state);
     };
     this[_a$1] = () => {
-      this.subscribers = /* @__PURE__ */ new Set();
+      this.subscribers.clear();
       this.onstatechange = void 0;
       this.value = void 0;
     };
@@ -30,15 +30,31 @@ class StateObserver {
   }
 }
 const emitRequestState = (instance, requestState) => {
-  instance[EMIT_METHOD_SYMBOL](requestState);
+  instance[emitMethodSymbol](requestState);
 };
 const clearStateListeners = (instance) => {
-  instance[CLEAR_METHOD_SYMBOL$1]();
+  instance[clearMethodSymbol$1]();
 };
+const EXTENDED_STACK_ADDITIONAL_INFO_TEXT = "Debug Info";
+const getDebugStackInfo = (info) => {
+  return ` 
+
+${EXTENDED_STACK_ADDITIONAL_INFO_TEXT}: ${JSON.stringify(info, null, 2)}
+
+`;
+};
+class ExtendedStackError extends Error {
+  constructor() {
+    super(...arguments);
+    this.expandStack = () => {
+      this.stack += getDebugStackInfo(this.debugStackInfo);
+    };
+  }
+}
 const ABORT_ERROR_NAME = "AbortError";
 const ERROR_CAUSE_PATH_NAME = "cause.name";
 const ERROR_CAUSE_PATH_MESSAGE = "cause.message";
-class AbortError extends Error {
+class AbortError extends ExtendedStackError {
   constructor(message, options) {
     super(message);
     this.code = 20;
@@ -49,6 +65,15 @@ class AbortError extends Error {
     this.signal = options?.signal;
     this.cause = options?.cause;
     this.initiator = options?.initiator || "user";
+    this.expandStack();
+  }
+  get debugStackInfo() {
+    return {
+      createdAt: new Date(this.timestamp).toISOString(),
+      reason: this.reason,
+      type: this.type,
+      initiator: this.initiator
+    };
   }
 }
 const get = (object, path) => path.split(".").reduce((acc, key) => acc && acc[key], object);
@@ -57,37 +82,9 @@ const isObject = (value) => {
 };
 const checkErrorCause = (error) => get(error, ERROR_CAUSE_PATH_NAME) === ABORT_ERROR_NAME || "abort".includes(get(error, ERROR_CAUSE_PATH_MESSAGE));
 const isError = (error) => error instanceof AbortError || isObject(error) && "name" in error && error.name === ABORT_ERROR_NAME || "abort".includes(error?.message ?? "") || checkErrorCause(error);
-class Timeout {
-  constructor() {
-    this.setTimeout = (timeout, onAbort) => {
-      this.clearTimeout();
-      if (!timeout || timeout <= 0) return;
-      this.timeoutId = setTimeout(onAbort, timeout);
-    };
-    this.clearTimeout = () => {
-      if (this.timeoutId) {
-        clearTimeout(this.timeoutId);
-        this.timeoutId = void 0;
-      }
-    };
-  }
-}
-class TimeoutError extends Error {
-  constructor(message, options) {
-    super(message);
-    this.timestamp = Date.now();
-    this.ms = options?.ms;
-  }
-}
-var ErrorMessage = /* @__PURE__ */ ((ErrorMessage2) => {
-  ErrorMessage2["AbortedSignalWithoutMessage"] = "signal is aborted without message";
-  ErrorMessage2["RequestTimedout"] = "the request timed out and an automatic abort occurred";
-  ErrorMessage2["CancelRequest"] = "cancellation of the previous AbortController";
-  return ErrorMessage2;
-})(ErrorMessage || {});
-const CLEAR_METHOD_SYMBOL = /* @__PURE__ */ Symbol("EVENT_LISTENER:CLEAR_METHOD");
+const clearMethodSymbol = /* @__PURE__ */ Symbol("event-listener::clear()");
 var _a;
-_a = CLEAR_METHOD_SYMBOL;
+_a = clearMethodSymbol;
 class EventListener {
   constructor(options) {
     this.listeners = {};
@@ -97,21 +94,41 @@ class EventListener {
       (_a2 = this.listeners)[type] ?? (_a2[type] = /* @__PURE__ */ new Set());
       return this.listeners[type];
     };
-    this.addEventListener = (type, listener) => {
-      this.getListenersByType(type).add(listener);
+    this.addEventListener = (type, listener, options2) => {
+      const wrapper = {
+        originalListener: listener
+      };
+      if (options2?.once) {
+        const onceWrapper = (event) => {
+          listener(event);
+          this.getListenersByType(type).delete(wrapper);
+        };
+        wrapper.wrappedListener = onceWrapper;
+      }
+      this.getListenersByType(type).add(wrapper);
       return () => this.removeEventListener(type, listener);
     };
     this.removeEventListener = (type, listener) => {
-      this.getListenersByType(type).delete(listener);
+      const listeners = this.getListenersByType(type);
+      for (const wrapper of listeners) {
+        if (wrapper.originalListener === listener) {
+          this.getListenersByType(type).delete(wrapper);
+          break;
+        }
+      }
     };
     this.dispatchEvent = (type, event) => {
       if (type === "aborted" || type === "cancelled") {
         this.onabort?.(event);
       }
-      this.getListenersByType(type).forEach((listener) => listener(event));
+      const listeners = [...this.getListenersByType(type)];
+      listeners.forEach((wrapper) => {
+        const listener = wrapper.wrappedListener || wrapper.originalListener;
+        listener(event);
+      });
     };
     this[_a] = () => {
-      this.listeners = {};
+      Object.values(this.listeners).forEach((listeners) => listeners.clear());
       this.onabort = void 0;
       clearStateListeners(this.state);
     };
@@ -120,8 +137,45 @@ class EventListener {
   }
 }
 const clearEventListeners = (instance) => {
-  instance[CLEAR_METHOD_SYMBOL]();
+  instance[clearMethodSymbol]();
 };
+class Timeout {
+  constructor() {
+    this.setTimeout = (timeout, onAbort) => {
+      this.clearTimeout();
+      if (!timeout || timeout <= 0) return;
+      this.timeoutId = setTimeout(onAbort, timeout);
+    };
+    this.clearTimeout = () => {
+      if (this.timeoutId) {
+        clearTimeout(this.timeoutId);
+        this.timeoutId = void 0;
+      }
+    };
+  }
+}
+class TimeoutError extends ExtendedStackError {
+  constructor(message, options) {
+    super(message);
+    this.timestamp = Date.now();
+    this.ms = options?.ms;
+    this.reason = options?.reason;
+    this.expandStack();
+  }
+  get debugStackInfo() {
+    return {
+      createdAt: new Date(this.timestamp).toISOString(),
+      ms: this.ms,
+      reason: this.reason
+    };
+  }
+}
+var ErrorMessage = /* @__PURE__ */ ((ErrorMessage2) => {
+  ErrorMessage2["AbortedSignalWithoutMessage"] = "signal is aborted without message";
+  ErrorMessage2["RequestTimedout"] = "the request timed out and an automatic abort occurred";
+  ErrorMessage2["CancelRequest"] = "cancellation of the previous AbortController";
+  return ErrorMessage2;
+})(ErrorMessage || {});
 const getAbortErrorByReason = (reason) => {
   if (reason instanceof AbortError) {
     return reason;
@@ -151,7 +205,6 @@ const _Aborter = class _Aborter {
           signal: this.signal,
           initiator: "system"
         });
-        this.setRequestState("cancelled");
         this.abort(cancelledAbortError);
       }
       let promise = new Promise((resolve, reject) => {
@@ -184,10 +237,10 @@ const _Aborter = class _Aborter {
     };
     this.abort = (reason) => {
       if (!this.isRequestInProgress) return;
-      this.setRequestState("aborted");
       const error = getAbortErrorByReason(reason);
       this.listeners.dispatchEvent(error.type, error);
       this.abortController.abort(error);
+      this.setRequestState(error.type);
     };
     this.abortWithRecovery = (reason) => {
       this.abort(reason);
@@ -200,8 +253,15 @@ const _Aborter = class _Aborter {
     };
     this.listeners = new EventListener(options);
   }
+  /**
+   * Returns true if Aborter has signaled to abort, and false otherwise.
+   */
+  get isAborted() {
+    return this.signal.aborted && this.listeners.state.value === "aborted";
+  }
   /**
    * Returns the AbortSignal object associated with this object.
+   * @deprecated
    */
   get signal() {
     return this.abortController?.signal;

package/dist/index.d.ts

@@ -18,8 +18,13 @@ export declare class Aborter {
      * @returns boolean
      */
     static isError: (error: any) => error is Error;
+    /**
+     * Returns true if Aborter has signaled to abort, and false otherwise.
+     */
+    get isAborted(): boolean;
     /**
      * Returns the AbortSignal object associated with this object.
+     * @deprecated
      */
     get signal(): AbortSignal;
     private setRequestState;
@@ -45,10 +50,10 @@ export declare class Aborter {
     dispose: () => void;
 }
 
-declare interface AborterOptions extends Pick<EventListenerOptions_2, 'onAbort' | 'onStateChange'> {
+declare interface AborterOptions extends Pick<EventListenerConstructorOptions, 'onAbort' | 'onStateChange'> {
 }
 
-export declare class AbortError extends Error {
+export declare class AbortError extends ExtendedStackError {
     /**
      * Interrupt error code.
      * @readonly
@@ -79,15 +84,17 @@ export declare class AbortError extends Error {
     cause?: Error;
     /**
      * field with the name of the error initiator.
+     * @default `user`
      */
     initiator?: Types.AbortInitiator;
     constructor(message: string, options?: Types.AbortErrorOptions);
+    protected get debugStackInfo(): Record<string, any>;
 }
 
 declare interface AbortErrorOptions {
     type?: AbortType;
     reason?: any;
-    cause?: any;
+    cause?: Error;
     signal?: AbortSignal;
     initiator?: AbortInitiator;
 }
@@ -98,18 +105,18 @@ declare type AbortRequest<T> = (signal: AbortSignal) => Promise<T>;
 
 export declare type AbortType = 'cancelled' | 'aborted';
 
-declare const CLEAR_METHOD_SYMBOL: unique symbol;
+declare const clearMethodSymbol: unique symbol;
 
-declare const CLEAR_METHOD_SYMBOL_2: unique symbol;
+declare const clearMethodSymbol_2: unique symbol;
 
 declare namespace Constants {
     export {
-        EMIT_METHOD_SYMBOL,
-        CLEAR_METHOD_SYMBOL
+        emitMethodSymbol,
+        clearMethodSymbol
     }
 }
 
-declare const EMIT_METHOD_SYMBOL: unique symbol;
+declare const emitMethodSymbol: unique symbol;
 
 declare type EventCallback<T extends EventListenerType> = EventMap[T] extends undefined ? () => void : (event: EventMap[T]) => void;
 
@@ -123,28 +130,32 @@ declare class EventListener_2 {
      * Returns an `StateObserver` object for monitoring the status of requests.
      */
     state: StateObserver;
-    constructor(options?: Types_2.EventListenerOptions);
+    constructor(options?: Types_2.EventListenerConstructorOptions);
     private getListenersByType;
     /**
      * Appends an event listener for events whose type attribute value is type. The callback argument sets the callback that will be invoked when the event is dispatched.
      */
-    addEventListener: <T extends Types_2.EventListenerType, L extends Types_2.EventCallback<T>>(type: T, listener: L) => VoidFunction;
+    addEventListener: <T extends Types_2.EventListenerType>(type: T, listener: Types_2.EventCallback<T>, options?: Types_2.EventListenerOptions) => VoidFunction;
     /**
      * Removes the event listener in target's event listener list with the same type and callback.
      */
-    removeEventListener: <T extends Types_2.EventListenerType, L extends Types_2.EventCallback<T>>(type: T, listener: L) => void;
+    removeEventListener: <T extends Types_2.EventListenerType>(type: T, listener: Types_2.EventCallback<T>) => void;
     /**
      * Dispatches a synthetic event event to target
      */
-    dispatchEvent: <T extends Types_2.EventListenerType, E extends Types_2.EventMap[T]>(type: T, event: E) => void;
-    /* Excluded from this release type: [CLEAR_METHOD_SYMBOL] */
+    dispatchEvent: <T extends Types_2.EventListenerType>(type: T, event: Types_2.EventMap[T]) => void;
+    /* Excluded from this release type: [clearMethodSymbol] */
 }
 
-declare interface EventListenerOptions_2 {
+declare interface EventListenerConstructorOptions {
     onAbort?: OnAbortCallback;
     onStateChange?: OnStateChangeCallback;
 }
 
+declare interface EventListenerOptions_2 {
+    once?: boolean;
+}
+
 declare type EventListenerType = keyof EventMap;
 
 declare interface EventMap {
@@ -152,6 +163,14 @@ declare interface EventMap {
     cancelled: AbortError;
 }
 
+declare abstract class ExtendedStackError extends Error {
+    protected abstract get debugStackInfo(): Record<string, any>;
+    /**
+     * Expands the stack with additional error information.
+     */
+    protected expandStack: () => void;
+}
+
 declare interface FnTryOptions {
     /**
      * Returns the ability to catch a canceled request error in a catch block.
@@ -164,6 +183,11 @@ declare interface FnTryOptions {
     timeout?: TimeoutErrorOptions;
 }
 
+declare interface ListenerWrapper<K extends EventListenerType> {
+    originalListener: (event: EventMap[K]) => any;
+    wrappedListener?: (event: EventMap[K]) => any;
+}
+
 export declare type OnAbortCallback = (error: AbortError) => void;
 
 export declare type OnStateChangeCallback = (state: RequestState) => void;
@@ -200,8 +224,8 @@ declare class StateObserver {
      * @returns {void}
      */
     unsubscribe: (callbackfn: Types_3.OnStateChangeCallback) => void;
-    /* Excluded from this release type: [Constants.EMIT_METHOD_SYMBOL] */
-    /* Excluded from this release type: [Constants.CLEAR_METHOD_SYMBOL] */
+    /* Excluded from this release type: [Constants.emitMethodSymbol] */
+    /* Excluded from this release type: [Constants.clearMethodSymbol] */
 }
 
 declare class Timeout {
@@ -216,7 +240,7 @@ declare class Timeout {
     clearTimeout: () => void;
 }
 
-export declare class TimeoutError extends Error {
+export declare class TimeoutError extends ExtendedStackError {
     /**
      *The timestamp in milliseconds when the error was created.
      @readonly
@@ -227,7 +251,12 @@ export declare class TimeoutError extends Error {
      * A field displaying the time in milliseconds after which the request was interrupted.
      */
     ms?: number;
+    /**
+     * A field storing the error reason. Can contain any metadata.
+     */
+    reason?: any;
     constructor(message: string, options?: TimeoutErrorOptions);
+    protected get debugStackInfo(): Record<string, any>;
 }
 
 declare interface TimeoutErrorOptions {
@@ -235,6 +264,10 @@ declare interface TimeoutErrorOptions {
      * Time in milliseconds after which interrupts should be started.
      */
     ms: number;
+    /**
+     * A field that stores any metadata passed into the error.
+     */
+    reason?: any;
 }
 
 declare namespace Types {
@@ -250,8 +283,10 @@ declare namespace Types_2 {
         EventMap,
         EventListenerType,
         EventCallback,
+        EventListenerOptions_2 as EventListenerOptions,
         OnAbortCallback,
-        EventListenerOptions_2 as EventListenerOptions
+        EventListenerConstructorOptions,
+        ListenerWrapper
     }
 }
 

package/dist/index.es.js

@@ -1,7 +1,7 @@
-const EMIT_METHOD_SYMBOL = /* @__PURE__ */ Symbol("STATE-OBSERVER:EMIT_METHOD");
-const CLEAR_METHOD_SYMBOL$1 = /* @__PURE__ */ Symbol("STATE-OBSERVER:CLEAR_METHOD");
+const emitMethodSymbol = /* @__PURE__ */ Symbol("state-observer::emit()");
+const clearMethodSymbol$1 = /* @__PURE__ */ Symbol("state-observer::clear()");
 var _a$1, _b;
-_b = EMIT_METHOD_SYMBOL, _a$1 = CLEAR_METHOD_SYMBOL$1;
+_b = emitMethodSymbol, _a$1 = clearMethodSymbol$1;
 class StateObserver {
   constructor(options) {
     this.subscribers = /* @__PURE__ */ new Set();
@@ -20,7 +20,7 @@ class StateObserver {
       this.onstatechange?.(state);
     };
     this[_a$1] = () => {
-      this.subscribers = /* @__PURE__ */ new Set();
+      this.subscribers.clear();
       this.onstatechange = void 0;
       this.value = void 0;
     };
@@ -28,15 +28,31 @@ class StateObserver {
   }
 }
 const emitRequestState = (instance, requestState) => {
-  instance[EMIT_METHOD_SYMBOL](requestState);
+  instance[emitMethodSymbol](requestState);
 };
 const clearStateListeners = (instance) => {
-  instance[CLEAR_METHOD_SYMBOL$1]();
+  instance[clearMethodSymbol$1]();
 };
+const EXTENDED_STACK_ADDITIONAL_INFO_TEXT = "Debug Info";
+const getDebugStackInfo = (info) => {
+  return ` 
+
+${EXTENDED_STACK_ADDITIONAL_INFO_TEXT}: ${JSON.stringify(info, null, 2)}
+
+`;
+};
+class ExtendedStackError extends Error {
+  constructor() {
+    super(...arguments);
+    this.expandStack = () => {
+      this.stack += getDebugStackInfo(this.debugStackInfo);
+    };
+  }
+}
 const ABORT_ERROR_NAME = "AbortError";
 const ERROR_CAUSE_PATH_NAME = "cause.name";
 const ERROR_CAUSE_PATH_MESSAGE = "cause.message";
-class AbortError extends Error {
+class AbortError extends ExtendedStackError {
   constructor(message, options) {
     super(message);
     this.code = 20;
@@ -47,6 +63,15 @@ class AbortError extends Error {
     this.signal = options?.signal;
     this.cause = options?.cause;
     this.initiator = options?.initiator || "user";
+    this.expandStack();
+  }
+  get debugStackInfo() {
+    return {
+      createdAt: new Date(this.timestamp).toISOString(),
+      reason: this.reason,
+      type: this.type,
+      initiator: this.initiator
+    };
   }
 }
 const get = (object, path) => path.split(".").reduce((acc, key) => acc && acc[key], object);
@@ -55,37 +80,9 @@ const isObject = (value) => {
 };
 const checkErrorCause = (error) => get(error, ERROR_CAUSE_PATH_NAME) === ABORT_ERROR_NAME || "abort".includes(get(error, ERROR_CAUSE_PATH_MESSAGE));
 const isError = (error) => error instanceof AbortError || isObject(error) && "name" in error && error.name === ABORT_ERROR_NAME || "abort".includes(error?.message ?? "") || checkErrorCause(error);
-class Timeout {
-  constructor() {
-    this.setTimeout = (timeout, onAbort) => {
-      this.clearTimeout();
-      if (!timeout || timeout <= 0) return;
-      this.timeoutId = setTimeout(onAbort, timeout);
-    };
-    this.clearTimeout = () => {
-      if (this.timeoutId) {
-        clearTimeout(this.timeoutId);
-        this.timeoutId = void 0;
-      }
-    };
-  }
-}
-class TimeoutError extends Error {
-  constructor(message, options) {
-    super(message);
-    this.timestamp = Date.now();
-    this.ms = options?.ms;
-  }
-}
-var ErrorMessage = /* @__PURE__ */ ((ErrorMessage2) => {
-  ErrorMessage2["AbortedSignalWithoutMessage"] = "signal is aborted without message";
-  ErrorMessage2["RequestTimedout"] = "the request timed out and an automatic abort occurred";
-  ErrorMessage2["CancelRequest"] = "cancellation of the previous AbortController";
-  return ErrorMessage2;
-})(ErrorMessage || {});
-const CLEAR_METHOD_SYMBOL = /* @__PURE__ */ Symbol("EVENT_LISTENER:CLEAR_METHOD");
+const clearMethodSymbol = /* @__PURE__ */ Symbol("event-listener::clear()");
 var _a;
-_a = CLEAR_METHOD_SYMBOL;
+_a = clearMethodSymbol;
 class EventListener {
   constructor(options) {
     this.listeners = {};
@@ -95,21 +92,41 @@ class EventListener {
       (_a2 = this.listeners)[type] ?? (_a2[type] = /* @__PURE__ */ new Set());
       return this.listeners[type];
     };
-    this.addEventListener = (type, listener) => {
-      this.getListenersByType(type).add(listener);
+    this.addEventListener = (type, listener, options2) => {
+      const wrapper = {
+        originalListener: listener
+      };
+      if (options2?.once) {
+        const onceWrapper = (event) => {
+          listener(event);
+          this.getListenersByType(type).delete(wrapper);
+        };
+        wrapper.wrappedListener = onceWrapper;
+      }
+      this.getListenersByType(type).add(wrapper);
       return () => this.removeEventListener(type, listener);
     };
     this.removeEventListener = (type, listener) => {
-      this.getListenersByType(type).delete(listener);
+      const listeners = this.getListenersByType(type);
+      for (const wrapper of listeners) {
+        if (wrapper.originalListener === listener) {
+          this.getListenersByType(type).delete(wrapper);
+          break;
+        }
+      }
     };
     this.dispatchEvent = (type, event) => {
       if (type === "aborted" || type === "cancelled") {
         this.onabort?.(event);
       }
-      this.getListenersByType(type).forEach((listener) => listener(event));
+      const listeners = [...this.getListenersByType(type)];
+      listeners.forEach((wrapper) => {
+        const listener = wrapper.wrappedListener || wrapper.originalListener;
+        listener(event);
+      });
     };
     this[_a] = () => {
-      this.listeners = {};
+      Object.values(this.listeners).forEach((listeners) => listeners.clear());
       this.onabort = void 0;
       clearStateListeners(this.state);
     };
@@ -118,8 +135,45 @@ class EventListener {
   }
 }
 const clearEventListeners = (instance) => {
-  instance[CLEAR_METHOD_SYMBOL]();
+  instance[clearMethodSymbol]();
 };
+class Timeout {
+  constructor() {
+    this.setTimeout = (timeout, onAbort) => {
+      this.clearTimeout();
+      if (!timeout || timeout <= 0) return;
+      this.timeoutId = setTimeout(onAbort, timeout);
+    };
+    this.clearTimeout = () => {
+      if (this.timeoutId) {
+        clearTimeout(this.timeoutId);
+        this.timeoutId = void 0;
+      }
+    };
+  }
+}
+class TimeoutError extends ExtendedStackError {
+  constructor(message, options) {
+    super(message);
+    this.timestamp = Date.now();
+    this.ms = options?.ms;
+    this.reason = options?.reason;
+    this.expandStack();
+  }
+  get debugStackInfo() {
+    return {
+      createdAt: new Date(this.timestamp).toISOString(),
+      ms: this.ms,
+      reason: this.reason
+    };
+  }
+}
+var ErrorMessage = /* @__PURE__ */ ((ErrorMessage2) => {
+  ErrorMessage2["AbortedSignalWithoutMessage"] = "signal is aborted without message";
+  ErrorMessage2["RequestTimedout"] = "the request timed out and an automatic abort occurred";
+  ErrorMessage2["CancelRequest"] = "cancellation of the previous AbortController";
+  return ErrorMessage2;
+})(ErrorMessage || {});
 const getAbortErrorByReason = (reason) => {
   if (reason instanceof AbortError) {
     return reason;
@@ -149,7 +203,6 @@ const _Aborter = class _Aborter {
           signal: this.signal,
           initiator: "system"
         });
-        this.setRequestState("cancelled");
         this.abort(cancelledAbortError);
       }
       let promise = new Promise((resolve, reject) => {
@@ -182,10 +235,10 @@ const _Aborter = class _Aborter {
     };
     this.abort = (reason) => {
       if (!this.isRequestInProgress) return;
-      this.setRequestState("aborted");
       const error = getAbortErrorByReason(reason);
       this.listeners.dispatchEvent(error.type, error);
       this.abortController.abort(error);
+      this.setRequestState(error.type);
     };
     this.abortWithRecovery = (reason) => {
       this.abort(reason);
@@ -198,8 +251,15 @@ const _Aborter = class _Aborter {
     };
     this.listeners = new EventListener(options);
   }
+  /**
+   * Returns true if Aborter has signaled to abort, and false otherwise.
+   */
+  get isAborted() {
+    return this.signal.aborted && this.listeners.state.value === "aborted";
+  }
   /**
    * Returns the AbortSignal object associated with this object.
+   * @deprecated
    */
   get signal() {
     return this.abortController?.signal;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "saborter",
-  "version": "1.4.2",
+  "version": "1.5.0",
   "description": "A simple and efficient library for canceling asynchronous requests using AbortController",
   "main": "dist/index.cjs.js",
   "module": "dist/index.es.js",
@@ -42,11 +42,12 @@
     "typecheck": "tsc --pretty --noEmit --skipLibCheck",
     "verify:prettier": "npx prettier . --check",
     "verify:eslint": "npx eslint \"./**/*.{js,jsx,ts,tsx}\" --max-warnings=0",
-    "verify": "npm run typecheck && npm run verify:prettier && npm run verify:eslint",
+    "verify": "npm run typecheck && npm run verify:prettier && npm run verify:eslint && npm run spellcheck",
     "fix:eslint": "npx eslint \"./**/*.{js,jsx,ts,tsx}\" --fix",
     "fix:prettier": "npx prettier --write .",
     "fix": "npm run fix:eslint && npm run fix:prettier",
     "test": "jest --colors --coverage test --passWithNoTests",
+    "spellcheck": "cspell \"**/*.{js,ts,jsx,tsx,md,json}\"",
     "prepare": "husky"
   },
   "devDependencies": {
@@ -54,6 +55,7 @@
     "@types/node": "^25.0.3",
     "@typescript-eslint/eslint-plugin": "^8.50.1",
     "@typescript-eslint/parser": "^8.50.1",
+    "cspell": "^9.6.2",
     "eslint": "^8.11.0",
     "eslint-config-airbnb": "^19.0.4",
     "eslint-config-prettier": "^10.1.8",

package/readme.md

@@ -1,6 +1,6 @@
 ![Logo](./assets/logo.png)
 
-[![Npm package](https://img.shields.io/badge/npm%20package-1.4.2-red)](https://www.npmjs.com/package/saborter)
+[![Npm package](https://img.shields.io/npm/v/saborter?color=red&label=npm%20package)](https://www.npmjs.com/package/saborter)
 ![Static Badge](https://img.shields.io/badge/coverage-90%25-orange)
 ![Static Badge](https://img.shields.io/badge/license-MIT-blue)
 [![Github](https://img.shields.io/badge/repository-github-color)](https://github.com/TENSIILE/saborter)
@@ -12,6 +12,7 @@ A simple and effective library for canceling asynchronous requests using AbortCo
 The documentation is divided into several sections:
 
 - [Installation](#📦-installation)
+- [Why Saborter?](#📈-why-saborter)
 - [Quick Start](#🚀-quick-start)
 - [Key Features](#📖-key-features)
 - [API](#🔧-api)
@@ -20,6 +21,7 @@ The documentation is divided into several sections:
 - [Troubleshooting](#🐜-troubleshooting)
 - [Usage Examples](#🎯-usage-examples)
 - [Compatibility](#💻-compatibility)
+- [License](#📋-license)
 
 ## 📦 Installation
 
@@ -29,6 +31,20 @@ npm install saborter
 yarn add saborter
 ```
 
+### Related libraries
+
+- [React](https://github.com/TENSIILE/saborter-react) - a standalone library with `Saborter` and `React` integration.
+
+## 📈 Why Saborter ?
+
+| Function/Characteristic                                                                                                               | Saborter | AbortController |
+| ------------------------------------------------------------------------------------------------------------------------------------- | -------- | --------------- |
+| Eliminated race condition when speed typing.                                                                                          | ✔️       | ✖️              |
+| The signal is created anew, there is no need to recreate it yourself. After `abort()` you can "reset" and use it again.               | ✔️       | ✖️              |
+| Legible error handling across all browsers.                                                                                           | ✔️       | ✖️              |
+| There is extended information about request interruptions: who cancelled, when, and the reason.                                       | ✔️       | ✖️              |
+| The signal will always be new. It's no coincidence that a previously disabled signal can appear from outside, which breaks all logic. | ✔️       | ✖️              |
+
 ## 🚀 Quick Start
 
 ### Basic Usage
@@ -40,14 +56,14 @@ import { Aborter } from 'saborter';
 const aborter = new Aborter();
 
 // Use for the request
-async function fetchData() {
+const fetchData = async () => {
   try {
     const result = await aborter.try((signal) => fetch('/api/data', { signal }));
     console.log('Data received:', result);
   } catch (error) {
     console.error('Request error:', error);
   }
-}
+};
 ```
 
 ## 📖 Key Features
@@ -58,11 +74,11 @@ Each time `try()` is called, the previous request is automatically canceled:
 
 ```javascript
 // When searching with autocomplete
-async function handleSearch(query) {
+const handleSearch = async (query) => {
   // The previous request is automatically canceled
   const results = await aborter.try((signal) => fetch(`/api/search?q=${query}`, { signal }));
   return results;
-}
+};
 
 // When the user quickly types:
 handleSearch('a'); // Starts
@@ -93,19 +109,19 @@ const userAborter = new Aborter();
 const dataAborter = new Aborter();
 
 // Manage user requests separately
-async function fetchUser(id) {
+const fetchUser = async (id) => {
   return userAborter.try((signal) => fetch(`/api/users/${id}`, { signal }));
-}
+};
 
 // And manage data separately
-async function fetchData(params) {
+const fetchData = async (params) => {
   return dataAborter.try((signal) => fetch('/api/data', { signal, ...params }));
-}
+};
 
 // Cancel only user requests
-function cancelUserRequests() {
+const cancelUserRequests = () => {
   userAborter.abort();
-}
+};
 ```
 
 ## 🔧 API
@@ -144,10 +160,14 @@ const aborter = new Aborter(options?: AborterOptions);
 
 ### Properties
 
-`signal`
+⚠️ `[DEPRECATED] signal`
 
 Returns the `AbortSignal` associated with the current controller.
 
+> [!WARNING]
+> It's best not to use a signal to subscribe to interrupts or check whether a request has been interrupted.
+> The signal is updated on every attempt, and your subscriptions will be lost, causing a memory leak.
+
 ```javascript
 const aborter = new Aborter();
 
@@ -157,6 +177,10 @@ fetch('/api/data', {
 });
 ```
 
+`isAborted`
+
+Returns a `boolean` value indicating whether the request was aborted or not.
+
 `listeners`
 
 Returns an `EventListener` object to listen for `Aborter` events.
@@ -192,6 +216,7 @@ Executes an asynchronous request with the ability to cancel.
   - `isErrorNativeBehavior?: boolean` - a flag for controlling error handling. Default is `false`
   - `timeout?: Object`
     - `ms: number` - Time in milliseconds after which interrupts should be started
+    - `reason?: any` - A field storing the error reason. Can contain any metadata
 
 **Returns:** `Promise<T>`
 
@@ -262,15 +287,15 @@ Immediately cancels the currently executing request.
 // Start the request
 const requestPromise = aborter.try((signal) => fetch('/api/data', { signal }), { isErrorNativeBehavior: true });
 
-// Cancel
-aborter.abort();
-
 // Handle cancellation
 requestPromise.catch((error) => {
   if (error.name === 'AbortError') {
     console.log('Request canceled');
   }
 });
+
+// Cancel
+aborter.abort();
 ```
 
 You can specify any data as the `reason`.
@@ -280,9 +305,6 @@ If we want to pass an `object`, we can put the error message in the `message` fi
 // Start the request
 const requestPromise = aborter.try((signal) => fetch('/api/data', { signal }));
 
-// Cancel
-aborter.abort({ message: 'Hello', data: [] });
-
 // Handle cancellation
 requestPromise.catch((error) => {
   if (error instanceof AbortError) {
@@ -290,6 +312,9 @@ requestPromise.catch((error) => {
     console.log(error.reason); // { message: 'Hello', data: [] }
   }
 });
+
+// Cancel
+aborter.abort({ message: 'Hello', data: [] });
 ```
 
 You can also submit your own `AbortError` with your own settings.
@@ -301,16 +326,16 @@ You can also submit your own `AbortError` with your own settings.
 // Start the request
 const requestPromise = aborter.try((signal) => fetch('/api/data', { signal }));
 
-// Cancel
-aborter.abort(new AbortError('Custom AbortError message', { reason: 1 }));
-
 // Handle cancellation
 requestPromise.catch((error) => {
   if (error instanceof AbortError) {
-    console.log(error.message); // Custom AbortError message
+    console.log(error.message); // 'Custom AbortError message'
     console.log(error.reason); // 1
   }
 });
+
+// Cancel
+aborter.abort(new AbortError('Custom AbortError message', { reason: 1 }));
 ```
 
 `abortWithRecovery(reason?)`
@@ -331,14 +356,14 @@ After aborting, it restores the `AbortSignal`, resetting the `isAborted` propert
 const aborter = new Aborter();
 
 // Data retrieval function
-async function fetchData() {
+const fetchData = async () => {
   try {
     const data = await fetch('/api/data', { signal: aborter.signal });
   } catch (error) {
     // ALL errors, including cancellations, will go here
     console.log(error);
   }
-}
+};
 
 // Calling a function with a request
 fetchData();
@@ -468,12 +493,14 @@ try {
 
 ## 🐜 Troubleshooting
 
+### Finally block
+
 Many people have probably encountered the problem with the `finally` block and the classic `AbortController`. When a request is canceled, the `catch` block is called. Why would `finally` block be called? This behavior only gets in the way and causes problems.
 
 **Example:**
 
 ```javascript
-const abortController = useRef(new AbortController());
+const abortController = new AbortController();
 
 const handleLoad = async () => {
   try {
@@ -488,35 +515,60 @@ const handleLoad = async () => {
     }
     console.log(error);
   } finally {
-    if (abortController.current.signal.aborted) {
+    if (abortController.signal.aborted) {
       setLoading(false);
     }
   }
 };
 
-const abortLoad = () => abortController.current.abort();
+const abortLoad = () => abortController.abort();
 ```
 
 The problem is obvious: checking the error by name, checking the condition to see if the `AbortController` was actually terminated in the `finally` block—it's all rather inconvenient.
 
 How `Aborter` solves these problems:
 
+```javascript
+const aborter = new Aborter();
+
+const handleLoad = async () => {
+  try {
+    setLoading(true);
+
+    const users = await aborter.try(getUsers);
+
+    setUsers(users);
+  } catch (error) {
+    if (error instanceof AbortError) return;
+
+    console.log(error);
+  } finally {
+    setLoading(false);
+  }
+};
+
+const abortLoad = () => aborter.abort();
+```
+
 The name check is gone, replaced by an instance check. It's easy to make a typo in the error name and not be able to fix it. With `instanceof` this problem disappears.
 With the `finally` block, everything has become even simpler. The condition that checked for termination is completely gone.
 
+> [!NOTE]
+> If you do not use the `abort()` method to terminate a request, then the check for `AbortError` in the `catch` block can be excluded.
+
+**Example:**
+
 ```javascript
-const aborterRef = useRef(new Aborter());
+const aborter = new Aborter();
 
 const handleLoad = async () => {
   try {
     setLoading(true);
 
-    const users = await aborterRef.current.try(getUsers);
+    const users = await aborter.try(getUsers);
 
     setUsers(users);
   } catch (error) {
-    if (error instanceof AbortError) return;
-
     console.log(error);
   } finally {
     setLoading(false);
@@ -524,15 +576,57 @@ const handleLoad = async () => {
 };
 ```
 
+### Subsequent calls to the `try` method
+
+If you want to cancel a group of requests combined in `Promise.all` or `Promise.allSettled` from a single `Aborter` instance, do not use multiple sequentially called `try` methods:
+
+```javascript
+// ✖️ Bad solution
+const fetchData = async () => {
+  const [users, posts] = await Promise.all([
+    aborter.try((signal) => axios.get('/api/users', { signal })),
+    aborter.try((signal) => axios.get('/api/posts', { signal }))
+  ]);
+};
+```
+
+```javascript
+// ✔️ Good solution
+const fetchData = async () => {
+  const [users, posts] = await aborter.try((signal) => {
+    return Promise.all([axios.get('/api/users', { signal }), axios.get('/api/posts', { signal })]);
+  });
+};
+```
+
+In the case of the first solution, the second call to the `try` method will cancel the request of the first call, which will break your logic.
+
 ## 🎯 Usage Examples
 
-### Example 1: Autocomplete
+### Example 1: Canceling multiple simultaneous requests
+
+```javascript
+const aborter = new Aborter();
+
+const getCategoriesByUserId = async (userId) => {
+  const data = await aborter.try(async (signal) => {
+    const user = await fetch(`/api/users/${userId}`, { signal });
+    const categories = await fetch(`/api/categories/${user.categoryId}`, { signal });
+
+    return [await user.json(), await categories.json()];
+  });
+
+  return data;
+};
+```
+
+### Example 2: Autocomplete
 
 ```javascript
 class SearchAutocomplete {
   aborter = new Aborter();
 
-  async search(query) {
+  search = async (query) => {
     if (!query.trim()) return [];
 
     try {
@@ -547,15 +641,15 @@ class SearchAutocomplete {
       // Get any error except AbortError
       console.error('Search error:', error);
     }
-  }
+  };
 
-  displayResults(results) {
+  displayResults = (results) => {
     // Display the results
-  }
+  };
 }
 ```
 
-### Example 2: File Upload with Cancellation
+### Example 3: File Upload with Cancellation
 
 ```javascript
 class FileUploader {
@@ -564,34 +658,31 @@ class FileUploader {
     this.progress = 0;
   }
 
-  async uploadFile(file) {
+  uploadFile = async (file) => {
     const formData = new FormData();
     formData.append('file', file);
 
     try {
-      await this.aborter.try(
-        async (signal) => {
-          const response = await fetch('/api/upload', {
-            method: 'POST',
-            body: formData,
-            signal
-          });
-
-          // Track progress
-          const reader = response.body.getReader();
-          let receivedLength = 0;
-          const contentLength = +response.headers.get('Content-Length');
-
-          while (true) {
-            const { done, value } = await reader.read();
-            if (done) break;
-
-            receivedLength += value.length;
-            this.progress = Math.round((receivedLength / contentLength) * 100);
-          }
-        },
-        { isErrorNativeBehavior: true }
-      );
+      await this.aborter.try(async (signal) => {
+        const response = await fetch('/api/upload', {
+          method: 'POST',
+          body: formData,
+          signal
+        });
+
+        // Track progress
+        const reader = response.body.getReader();
+        let receivedLength = 0;
+        const contentLength = +response.headers.get('Content-Length');
+
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+
+          receivedLength += value.length;
+          this.progress = Math.round((receivedLength / contentLength) * 100);
+        }
+      });
 
       console.log('File uploaded successfully');
     } catch (error) {
@@ -601,15 +692,15 @@ class FileUploader {
         console.error('Upload error:', error);
       }
     }
-  }
+  };
 
-  cancelUpload() {
+  cancelUpload = () => {
     this.aborter.abort();
-  }
+  };
 }
 ```
 
-### Example 3: Integration with UI Frameworks
+### Example 4: Integration with UI Frameworks
 
 **React**
 
@@ -617,7 +708,7 @@ class FileUploader {
 import React, { useState, useEffect, useRef } from 'react';
 import { Aborter } from 'saborter';
 
-function DataFetcher({ url }) {
+const DataFetcher = ({ url }) => {
   const [data, setData] = useState(null);
   const [loading, setLoading] = useState(false);
   const aborterRef = useRef(new Aborter());
@@ -644,9 +735,7 @@ function DataFetcher({ url }) {
   };
 
   const cancelRequest = () => {
-    if (aborterRef.current) {
-      aborterRef.current.abort();
-    }
+    aborterRef.current?.abort();
   };
 
   return (
@@ -660,7 +749,7 @@ function DataFetcher({ url }) {
       {data && <pre>{JSON.stringify(data, null, 2)}</pre>}
     </div>
   );
-}
+};
 ```
 
 **Vue.js**
@@ -708,3 +797,7 @@ export default {
 - **Browsers:** All modern browsers that support AbortController
 - **Node.js:** Requires a polyfill for AbortController (version 16+ has built-in support)
 - **TypeScript:** Full type support
+
+## 📋 License
+
+MIT License - see [LICENSE](./LICENSE) for details.