@fatcherjs/middleware-aborter/dist/aborter.esm.js

import { defineMiddleware } from 'fatcher';

const roadMap = {};
function aborter(options = {}) {
  const { timeout = 0, onAbort = null, concurrency, groupBy } = options;
  let _timeout = timeout;
  if (isNaN(_timeout) || ~~_timeout < 0) {
    console.warn("[fatcher-middleware-aborter] Timeout is not a valid number.");
    _timeout = 0;
  }
  const baseAborter = defineMiddleware(async (context, next) => {
    const abortController = new AbortController();
    if (onAbort) {
      abortController.signal.addEventListener("abort", () => onAbort());
    }
    return next({
      signal: abortController.signal,
      abort: abortController.abort.bind(abortController)
    });
  }, "fatcher-middleware-aborter");
  const timeoutAborter = defineMiddleware(async (context, next) => {
    const { signal, abort } = context;
    let timer = setTimeout(abort, _timeout);
    const release = () => {
      if (timer) {
        clearTimeout(timer);
      }
      timer = null;
    };
    signal.addEventListener("abort", release);
    const result = await next();
    release();
    return result;
  }, "fatcher-middleware-timeout-aborter");
  const concurrencyAborter = defineMiddleware(async (context, next) => {
    const { signal, abort } = context;
    const group = groupBy ? groupBy(context) : `${context.url}_${context.method}_${new URLSearchParams(context.params)}`;
    if (roadMap[group] && roadMap[group].length) {
      roadMap[group].forEach((item) => item.abort());
    }
    if (!roadMap[group]) {
      roadMap[group] = [];
    }
    roadMap[group].push({ abort, signal });
    const release = () => {
      roadMap[group] = roadMap[group].filter((item) => {
        return item.signal !== signal;
      });
      if (!roadMap[group].length) {
        delete roadMap[group];
      }
    };
    signal.addEventListener("abort", release);
    const result = await next();
    release();
    return result;
  }, "fatcher-middleware-concurrency-aborter");
  const middlewares = [baseAborter];
  if (_timeout) {
    middlewares.push(timeoutAborter);
  }
  if (concurrency) {
    middlewares.push(concurrencyAborter);
  }
  return middlewares;
}

function isAbortError(error) {
  return error instanceof DOMException && error.name === "AbortError";
}

export { aborter, isAbortError };