@reactgjs/react-gtk/polyfills/esm/abort-controller.mjs

## Getting Started

// src/polyfills/abort-controller.ts
import { registerPolyfills } from "./shared/polyfill-global.mjs";
registerPolyfills(
  "AbortController",
  "AbortSignal",
  "AbortError",
  "TimeoutError"
)(() => {
  let Events;
  ((Events2) => {
    Events2["Abort"] = "abort";
  })(Events || (Events = {}));
  class Event {
    constructor(type) {
      this.type = type;
    }
    target;
    currentTarget;
    timeStamp = 0;
    bubbles = false;
    cancelable = false;
    cancelBubble = false;
    composed = false;
    defaultPrevented = false;
    eventPhase = 0;
    isTrusted = true;
    returnValue = true;
  }
  class EventController {
    listeners = /* @__PURE__ */ new Map();
    constructor() {
    }
    add(event, listener) {
      if (!this.listeners.has(event)) {
        this.listeners.set(event, []);
      }
      this.listeners.get(event).push(listener);
    }
    remove(event, listener) {
      if (!this.listeners.has(event)) {
        return;
      }
      const listeners = this.listeners.get(event);
      const index = listeners.indexOf(listener);
      if (index !== -1) {
        listeners.splice(index, 1);
      }
    }
    emit(event, ev) {
      if (!this.listeners.has(event)) {
        return;
      }
      this.listeners.get(event).forEach(async (listener) => {
        try {
          await listener.call(ev.target, ev);
        } catch (e) {
          console.error(e);
        }
      });
    }
    clear() {
      this.listeners.clear();
    }
  }
  class AbortError extends Error {
    code = 20;
    constructor(msg) {
      super(msg ?? "signal is aborted without reason");
      this.name = "AbortError";
    }
  }
  class TimeoutError extends Error {
    code = 23;
    constructor() {
      super("signal timed out");
      this.name = "TimeoutError";
    }
  }
  class AbortSignal {
    static abort(reason) {
      const signal = new AbortSignal();
      signal._isAborted = true;
      signal._reason = reason ?? new AbortError();
      return signal;
    }
    static timeout(time) {
      const signal = new AbortSignal();
      setTimeout(() => {
        if (!signal.aborted) signal._abort(new TimeoutError());
      }, time);
      return signal;
    }
    static any(signals) {
      const signal = new AbortSignal();
      for (const s of signals) {
        s.addEventListener("abort" /* Abort */, function() {
          if (!signal.aborted) signal._abort(this.reason);
        });
      }
      return signal;
    }
    _events = new EventController();
    _isAborted = false;
    _reason = null;
    _startTime = Date.now();
    onabort = null;
    get aborted() {
      return this._isAborted;
    }
    get reason() {
      return this._reason;
    }
    constructor() {
      this._events.add("abort" /* Abort */, (ev) => this.onabort && this.onabort(ev));
    }
    _abortEvent() {
      const e = new Event("abort" /* Abort */);
      e.currentTarget = this;
      e.target = this;
      e.timeStamp = Math.round(Date.now() - this._startTime);
      return e;
    }
    _abort(reason) {
      if (this._isAborted) {
        return;
      }
      this._isAborted = true;
      this._reason = reason ?? new AbortError();
      this._events.emit("abort" /* Abort */, this._abortEvent());
      this._events.clear();
    }
    throwIfAborted() {
      if (this._isAborted) {
        throw this._reason;
      }
    }
    addEventListener(event, listener) {
      this._events.add(event, listener);
    }
    removeEventListener(event, listener) {
      this._events.remove(event, listener);
    }
  }
  class AbortController {
    _signal = new AbortSignal();
    get signal() {
      return this._signal;
    }
    abort(reason) {
      this._signal["_abort"](reason);
    }
  }
  return {
    AbortController,
    AbortSignal,
    AbortError,
    TimeoutError
  };
});