saborter 1.2.0 → 1.4.0

package/dist/index.cjs.js

@@ -1,37 +1,182 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const ABORT_ERROR_MESSAGE = "The user aborted a request.";
-const ABORT_ERROR_WITHOUT_REASON_MESSAGE = "signal is aborted without reason";
+const EMIT_METHOD_SYMBOL = /* @__PURE__ */ Symbol("STATE-OBSERVER:EMIT_METHOD");
+const CLEAR_METHOD_SYMBOL$1 = /* @__PURE__ */ Symbol("STATE-OBSERVER:CLEAR_METHOD");
+var _a$1, _b;
+_b = EMIT_METHOD_SYMBOL, _a$1 = CLEAR_METHOD_SYMBOL$1;
+class StateObserver {
+  constructor(options) {
+    this.subscribers = /* @__PURE__ */ new Set();
+    this.subscribe = (callbackfn) => {
+      this.subscribers.add(callbackfn);
+      return () => this.unsubscribe(callbackfn);
+    };
+    this.unsubscribe = (callbackfn) => {
+      this.subscribers.delete(callbackfn);
+    };
+    this[_b] = (state) => {
+      this.value = state;
+      this.subscribers.forEach((subscribe) => {
+        subscribe(state);
+      });
+      this.onstatechange?.(state);
+    };
+    this[_a$1] = () => {
+      this.subscribers = /* @__PURE__ */ new Set();
+      this.onstatechange = void 0;
+      this.value = void 0;
+    };
+    this.onstatechange = options?.onStateChange;
+  }
+}
+const emitRequestState = (instance, requestState) => {
+  instance[EMIT_METHOD_SYMBOL](requestState);
+};
+const clearStateListeners = (instance) => {
+  instance[CLEAR_METHOD_SYMBOL$1]();
+};
 const ABORT_ERROR_NAME = "AbortError";
 const ERROR_CAUSE_PATH_NAME = "cause.name";
 const ERROR_CAUSE_PATH_MESSAGE = "cause.message";
-const ABORT_ERROR_MESSAGES = [
-  ABORT_ERROR_MESSAGE,
-  ABORT_ERROR_WITHOUT_REASON_MESSAGE
-];
-const get = (object, path) => path.split(".").reduce(
-  (acc, key) => acc && acc[key],
-  object
-);
-const isError = (error) => ABORT_ERROR_MESSAGES.includes(
-  error?.message ?? ""
-) || get(error, ERROR_CAUSE_PATH_NAME) === ABORT_ERROR_NAME || ABORT_ERROR_MESSAGES.includes(
-  get(error, ERROR_CAUSE_PATH_MESSAGE)
-);
-const _Aborter = class _Aborter {
+class AbortError extends Error {
+  constructor(message, options) {
+    super(message);
+    this.code = 20;
+    this.timestamp = Date.now();
+    this.name = ABORT_ERROR_NAME;
+    this.type = options?.type || "aborted";
+    this.reason = options?.reason;
+    this.signal = options?.signal;
+    this.cause = options?.cause;
+    this.initiator = options?.initiator || "user";
+  }
+}
+const get = (object, path) => path.split(".").reduce((acc, key) => acc && acc[key], object);
+const isObject = (value) => {
+  return value !== null && !Array.isArray(value) && typeof value === "object";
+};
+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.hasThrow = options?.hasThrow ?? false;
+    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");
+var _a;
+_a = CLEAR_METHOD_SYMBOL;
+class EventListener {
+  constructor(options) {
+    this.listeners = {};
+    this.state = new StateObserver();
+    this.getListenersByType = (type) => {
+      var _a2;
+      (_a2 = this.listeners)[type] ?? (_a2[type] = /* @__PURE__ */ new Set());
+      return this.listeners[type];
+    };
+    this.addEventListener = (type, listener) => {
+      this.getListenersByType(type).add(listener);
+      return () => this.removeEventListener(type, listener);
+    };
+    this.removeEventListener = (type, listener) => {
+      this.getListenersByType(type).delete(listener);
+    };
+    this.dispatchEvent = (type, event) => {
+      if (type === "aborted" || type === "cancelled") {
+        this.onabort?.(event);
+      }
+      this.getListenersByType(type).forEach((listener) => listener(event));
+    };
+    this[_a] = () => {
+      this.listeners = {};
+      this.onabort = void 0;
+      clearStateListeners(this.state);
+    };
+    this.onabort = options?.onAbort;
+    this.state.onstatechange = options?.onStateChange;
+  }
+}
+const clearEventListeners = (instance) => {
+  instance[CLEAR_METHOD_SYMBOL]();
+};
+const getAbortErrorByReason = (reason) => {
+  if (reason === void 0) {
+    return void 0;
+  }
+  if (reason instanceof AbortError) {
+    return reason;
+  }
+  return new AbortError(get(reason, "message") || ErrorMessage.AbortedSignalWithoutMessage, {
+    reason
+  });
+};
+const hasThrowInTimeoutError = (error) => {
+  return error instanceof AbortError && error.cause instanceof TimeoutError && error.cause.hasThrow;
+};
+const _Aborter = class _Aborter {
+  constructor(options) {
     this.abortController = new AbortController();
-    this.try = (request, { isErrorNativeBehavior = false } = {}) => {
+    this.isRequestInProgress = false;
+    this.timeout = new Timeout();
+    this.setRequestState = (state) => {
+      emitRequestState(this.listeners.state, state);
+      if (["fulfilled", "rejected", "aborted"].indexOf(state) !== -1) {
+        this.timeout.clearTimeout();
+        this.isRequestInProgress = false;
+      }
+    };
+    this.try = (request, { isErrorNativeBehavior = false, timeout } = {}) => {
+      if (this.isRequestInProgress) {
+        const cancelledAbortError = new AbortError(ErrorMessage.CancelRequest, {
+          type: "cancelled",
+          signal: this.signal,
+          initiator: "system"
+        });
+        this.setRequestState("cancelled");
+        this.abort(cancelledAbortError);
+      }
       let promise = new Promise((resolve, reject) => {
-        this.abort();
         this.abortController = new AbortController();
-        const { signal } = this.abortController;
-        request(signal).then(resolve).catch((err) => {
-          const error = {
-            ...err,
-            message: err?.message || get(err, ERROR_CAUSE_PATH_MESSAGE) || ""
-          };
-          if (isErrorNativeBehavior || !_Aborter.isError(err)) {
+        this.isRequestInProgress = true;
+        this.timeout.setTimeout(timeout?.ms, () => {
+          const abortError = new AbortError(ErrorMessage.RequestTimedout, {
+            initiator: "timeout",
+            cause: new TimeoutError(ErrorMessage.RequestTimedout, timeout)
+          });
+          this.abort(abortError);
+        });
+        queueMicrotask(() => this.setRequestState("pending"));
+        request(this.abortController.signal).then((response) => {
+          if (!this.isRequestInProgress) return;
+          this.setRequestState("fulfilled");
+          resolve(response);
+        }).catch((error) => {
+          if (isErrorNativeBehavior || !_Aborter.isError(error) || hasThrowInTimeoutError(error)) {
+            this.setRequestState("rejected");
             return reject(error);
           }
           promise = null;
@@ -39,17 +184,41 @@ const _Aborter = class _Aborter {
       });
       return promise;
     };
-    this.abort = (reason) => this.abortController.abort(reason);
+    this.abort = (reason) => {
+      if (!this.isRequestInProgress) return;
+      this.abortController.abort(reason);
+      this.setRequestState("aborted");
+      const error = getAbortErrorByReason(reason);
+      if (error && error.type) {
+        this.listeners.dispatchEvent(error.type, error);
+      } else {
+        this.listeners.dispatchEvent(
+          "aborted",
+          new AbortError(ErrorMessage.AbortedSignalWithoutMessage, { initiator: "user" })
+        );
+      }
+    };
+    this.abortWithRecovery = (reason) => {
+      this.abort(reason);
+      this.abortController = new AbortController();
+      return this.abortController;
+    };
+    this.dispose = () => {
+      this.timeout.clearTimeout();
+      clearEventListeners(this.listeners);
+    };
+    this.listeners = new EventListener(options);
   }
   /**
    * Returns the AbortSignal object associated with this object.
    */
   get signal() {
-    return this.abortController.signal;
+    return this.abortController?.signal;
   }
 };
 _Aborter.errorName = ABORT_ERROR_NAME;
 _Aborter.isError = isError;
 let Aborter = _Aborter;
+exports.AbortError = AbortError;
 exports.Aborter = Aborter;
-//# sourceMappingURL=index.cjs.js.map
+exports.TimeoutError = TimeoutError;

package/dist/index.d.ts

@@ -1,46 +1,281 @@
 export declare class Aborter {
     protected abortController: AbortController;
+    protected isRequestInProgress: boolean;
+    protected timeout: Timeout;
+    /**
+     * Returns an `EventListener` instance to listen for `Aborter` events.
+     */
+    listeners: EventListener_2;
+    constructor(options?: Types_4.AborterOptions);
     /**
      * The name of the error instance thrown by the AbortSignal.
      * @readonly
+     * @deprecated use AbortError.name
      */
     static readonly errorName = "AbortError";
     /**
      * Method of checking whether an error is an error AbortError.
      * @returns boolean
      */
-    static isError: (error: unknown) => error is Error;
+    static isError: (error: any) => error is Error;
     /**
      * Returns the AbortSignal object associated with this object.
      */
     get signal(): AbortSignal;
+    private setRequestState;
     /**
      * Performs an asynchronous request with cancellation of the previous request, preventing the call of the catch block when the request is canceled and the subsequent finally block.
      * @param request callback function
      * @param options an object that receives a set of settings for performing a request attempt
      * @returns Promise
      */
-    try: <R>(request: Types.AbortRequest<R>, { isErrorNativeBehavior }?: Types.FnTryOptions) => Promise<R>;
+    try: <R>(request: Types_4.AbortRequest<R>, { isErrorNativeBehavior, timeout }?: Types_4.FnTryOptions) => Promise<R>;
     /**
      * Calling this method sets the AbortSignal flag of this object and signals all observers that the associated action should be aborted.
      */
     abort: (reason?: any) => void;
+    /**
+     * Calling this method sets the AbortSignal flag of this object and signals all observers that the associated action should be aborted.
+     * After aborting, it restores the AbortSignal, resetting the isAborted property, and interaction with the signal property becomes available again.
+     */
+    abortWithRecovery: (reason?: any) => AbortController;
+    /**
+     * Clears the object's data completely: all subscriptions in all properties, clears overridden methods, state values.
+     */
+    dispose: () => void;
 }
 
+declare interface AborterOptions extends Pick<EventListenerOptions_2, 'onAbort' | 'onStateChange'> {
+}
+
+export declare class AbortError<Options extends Types.AbortErrorOptions = {}> extends Error {
+    /**
+     * Interrupt error code.
+     * @readonly
+     */
+    readonly code: number;
+    /**
+     * Interrupt type 'cancelled' | 'aborted'.
+     * @default `aborted`
+     */
+    type: Types.AbortErrorOptions['type'];
+    /**
+     * The timestamp in milliseconds when the error was created.
+     @readonly
+     @returns Date.now();
+     */
+    readonly timestamp: number;
+    /**
+     * Additional reason or data associated with the interrupt.
+     */
+    reason?: any;
+    /**
+     * AbortSignal that was just interrupted.
+     */
+    signal?: AbortSignal;
+    /**
+     * A field containing additional error information indicating the reason for the current error.
+     */
+    cause?: Options['initiator'] extends 'timeout' ? TimeoutError : Error;
+    /**
+     * field with the name of the error initiator.
+     */
+    initiator?: Types.AbortInitiator;
+    constructor(message: string, options?: Options);
+}
+
+declare interface AbortErrorOptions {
+    type?: AbortType;
+    reason?: any;
+    cause?: any;
+    signal?: AbortSignal;
+    initiator?: AbortInitiator;
+}
+
+export declare type AbortInitiator = 'timeout' | 'user' | 'system' | {};
+
 declare type AbortRequest<T> = (signal: AbortSignal) => Promise<T>;
 
+export declare type AbortType = 'cancelled' | 'aborted';
+
+declare const CLEAR_METHOD_SYMBOL: unique symbol;
+
+declare const CLEAR_METHOD_SYMBOL_2: unique symbol;
+
+declare namespace Constants {
+    export {
+        EMIT_METHOD_SYMBOL,
+        CLEAR_METHOD_SYMBOL
+    }
+}
+
+declare const EMIT_METHOD_SYMBOL: unique symbol;
+
+declare type EventCallback<T extends EventListenerType> = EventMap[T] extends undefined ? () => void : (event: EventMap[T]) => void;
+
+declare class EventListener_2 {
+    private listeners;
+    /**
+     * Method called when an Aborter request is cancelled
+     */
+    onabort?: Types_2.OnAbortCallback;
+    /**
+     * Returns an `StateObserver` object for monitoring the status of requests.
+     */
+    state: StateObserver;
+    constructor(options?: Types_2.EventListenerOptions);
+    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;
+    /**
+     * 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;
+    /**
+     * 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] */
+}
+
+declare interface EventListenerOptions_2 {
+    onAbort?: OnAbortCallback;
+    onStateChange?: OnStateChangeCallback;
+}
+
+declare type EventListenerType = keyof EventMap;
+
+declare interface EventMap {
+    aborted: AbortError;
+    cancelled: AbortError;
+}
+
 declare interface FnTryOptions {
     /**
      * Returns the ability to catch a canceled request error in a catch block.
      * @default false
      */
     isErrorNativeBehavior?: boolean;
+    /**
+     * Automatic request cancellation setting field.
+     */
+    timeout?: TimeoutErrorOptions;
+}
+
+export declare type OnAbortCallback = (error: AbortError) => void;
+
+export declare type OnStateChangeCallback = (state: RequestState) => void;
+
+export declare type RequestState = 'pending' | 'fulfilled' | 'rejected' | 'cancelled' | 'aborted';
+
+declare interface StateListenerOptions {
+    /**
+     * Callback triggered on state change.
+     */
+    onStateChange?: OnStateChangeCallback;
+}
+
+declare class StateObserver {
+    /**
+     * Current state value.
+     */
+    value?: Types_3.RequestState;
+    /**
+     * Callback triggered on state change.
+     */
+    onstatechange?: Types_3.OnStateChangeCallback;
+    private subscribers;
+    constructor(options?: Types_3.StateListenerOptions);
+    /**
+     * Subscribes a callback to state changes.
+     * @param callbackfn - Callback function
+     * @returns {VoidFunction} Unsubscribe function
+     */
+    subscribe: (callbackfn: Types_3.OnStateChangeCallback) => VoidFunction;
+    /**
+     * Unsubscribes a callback from state changes.
+     * @param callbackfn - Callback function to remove
+     * @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] */
+}
+
+declare class Timeout {
+    private timeoutId?;
+    /**
+     * Sets the timeout for the current request.
+     */
+    setTimeout: (timeout: number | undefined, onAbort: VoidFunction) => void;
+    /**
+     * Clears the set timeout.
+     */
+    clearTimeout: () => void;
+}
+
+export declare class TimeoutError extends Error {
+    /**
+     *The timestamp in milliseconds when the error was created.
+     @readonly
+     @returns Date.now();
+     */
+    readonly timestamp: number;
+    /**
+     * A field indicating whether an error was thrown.
+     */
+    hasThrow: boolean;
+    /**
+     * A field displaying the time in milliseconds after which the request was interrupted.
+     */
+    ms?: number;
+    constructor(message: string, options?: TimeoutErrorOptions);
+}
+
+declare interface TimeoutErrorOptions {
+    /**
+     * A flag that determines whether to throw the error further.
+     */
+    hasThrow?: boolean;
+    /**
+     * Time in milliseconds after which interrupts should be started.
+     */
+    ms: number;
 }
 
 declare namespace Types {
+    export {
+        AbortInitiator,
+        AbortType,
+        AbortErrorOptions
+    }
+}
+
+declare namespace Types_2 {
+    export {
+        EventMap,
+        EventListenerType,
+        EventCallback,
+        OnAbortCallback,
+        EventListenerOptions_2 as EventListenerOptions
+    }
+}
+
+declare namespace Types_3 {
+    export {
+        RequestState,
+        OnStateChangeCallback,
+        StateListenerOptions
+    }
+}
+
+declare namespace Types_4 {
     export {
         AbortRequest,
-        FnTryOptions
+        FnTryOptions,
+        AborterOptions
     }
 }