@mswjs/interceptors 0.20.0 → 0.21.0

package/lib/browser/chunk-BQYA7ER5.mjs

@@ -0,0 +1,258 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// src/glossary.ts
+var IS_PATCHED_MODULE = Symbol("isPatchedModule");
+
+// src/Interceptor.ts
+import { debug as debug2 } from "debug";
+
+// src/utils/AsyncEventEmitter.ts
+import { debug } from "debug";
+import { Emitter } from "strict-event-emitter";
+
+// src/utils/nextTick.ts
+function nextTick(callback) {
+  setTimeout(callback, 0);
+}
+
+// src/utils/AsyncEventEmitter.ts
+var AsyncEventEmitter = class extends Emitter {
+  constructor() {
+    super();
+    this.log = debug("async-event-emitter");
+    this.queue = /* @__PURE__ */ new Map();
+    this.readyState = "ACTIVE" /* ACTIVE */;
+  }
+  on(eventName, listener) {
+    const log = this.log.extend("on");
+    log('adding "%s" listener...', eventName);
+    if (this.readyState === "DEACTIVATED" /* DEACTIVATED */) {
+      log("the emitter is destroyed, skipping!");
+      return this;
+    }
+    return super.on(eventName, async (...args) => {
+      const queue = this.openListenerQueue(eventName);
+      log('awaiting the "%s" listener...', eventName);
+      queue.push({
+        args,
+        done: new Promise(async (resolve, reject) => {
+          try {
+            await listener(...args);
+            resolve();
+            log('"%s" listener has resolved!', eventName);
+          } catch (error) {
+            log('"%s" listener has rejected!', error);
+            reject(error);
+          }
+        })
+      });
+    });
+  }
+  emit(eventName, ...data) {
+    const log = this.log.extend("emit");
+    log('emitting "%s" event...', eventName);
+    if (this.readyState === "DEACTIVATED" /* DEACTIVATED */) {
+      log("the emitter is destroyed, skipping!");
+      return false;
+    }
+    if (this.isInternalEventName(eventName)) {
+      return super.emit(eventName, ...data);
+    }
+    this.openListenerQueue(eventName);
+    log('appending a one-time cleanup "%s" listener...', eventName);
+    this.once(eventName, () => {
+      nextTick(() => {
+        this.queue.delete(eventName);
+        log('cleaned up "%s" listeners queue!', eventName);
+      });
+    });
+    return super.emit(eventName, ...data);
+  }
+  async untilIdle(eventName, filter = () => true) {
+    const listenersQueue = this.queue.get(eventName) || [];
+    await Promise.all(
+      listenersQueue.filter(filter).map(({ done }) => done)
+    ).finally(() => {
+      this.queue.delete(eventName);
+    });
+  }
+  openListenerQueue(eventName) {
+    const log = this.log.extend("openListenerQueue");
+    log('opening "%s" listeners queue...', eventName);
+    const queue = this.queue.get(eventName);
+    if (!queue) {
+      log("no queue found, creating one...");
+      this.queue.set(eventName, []);
+      return [];
+    }
+    log("returning an exising queue:", queue);
+    return queue;
+  }
+  removeAllListeners(eventName) {
+    const log = this.log.extend("removeAllListeners");
+    log("event:", eventName);
+    if (eventName) {
+      this.queue.delete(eventName);
+      log(
+        'cleared the "%s" listeners queue!',
+        eventName,
+        this.queue.get(eventName)
+      );
+    } else {
+      this.queue.clear();
+      log("cleared the listeners queue!", this.queue);
+    }
+    return super.removeAllListeners(eventName);
+  }
+  activate() {
+    const log = this.log.extend("activate");
+    this.readyState = "ACTIVE" /* ACTIVE */;
+    log("set state to:", this.readyState);
+  }
+  deactivate() {
+    const log = this.log.extend("deactivate");
+    log("removing all listeners...");
+    this.removeAllListeners();
+    this.readyState = "DEACTIVATED" /* DEACTIVATED */;
+    log("set state to:", this.readyState);
+  }
+  isInternalEventName(eventName) {
+    return eventName === "newListener" || eventName === "removeListener";
+  }
+};
+
+// src/Interceptor.ts
+function getGlobalSymbol(symbol) {
+  return globalThis[symbol] || void 0;
+}
+function setGlobalSymbol(symbol, value) {
+  globalThis[symbol] = value;
+}
+function deleteGlobalSymbol(symbol) {
+  delete globalThis[symbol];
+}
+var InterceptorReadyState = /* @__PURE__ */ ((InterceptorReadyState2) => {
+  InterceptorReadyState2["INACTIVE"] = "INACTIVE";
+  InterceptorReadyState2["APPLYING"] = "APPLYING";
+  InterceptorReadyState2["APPLIED"] = "APPLIED";
+  InterceptorReadyState2["DISPOSING"] = "DISPOSING";
+  InterceptorReadyState2["DISPOSED"] = "DISPOSED";
+  return InterceptorReadyState2;
+})(InterceptorReadyState || {});
+var Interceptor = class {
+  constructor(symbol) {
+    this.symbol = symbol;
+    this.readyState = "INACTIVE" /* INACTIVE */;
+    this.emitter = new AsyncEventEmitter();
+    this.subscriptions = [];
+    this.log = debug2(symbol.description);
+    this.emitter.setMaxListeners(0);
+    this.log("constructing the interceptor...");
+  }
+  checkEnvironment() {
+    return true;
+  }
+  apply() {
+    const log = this.log.extend("apply");
+    log("applying the interceptor...");
+    if (this.readyState === "APPLIED" /* APPLIED */) {
+      log("intercepted already applied!");
+      return;
+    }
+    const shouldApply = this.checkEnvironment();
+    if (!shouldApply) {
+      log("the interceptor cannot be applied in this environment!");
+      return;
+    }
+    this.readyState = "APPLYING" /* APPLYING */;
+    this.emitter.activate();
+    log("activated the emiter!", this.emitter.readyState);
+    const runningInstance = this.getInstance();
+    if (runningInstance) {
+      log("found a running instance, reusing...");
+      this.on = (event, listener) => {
+        log('proxying the "%s" listener', event);
+        runningInstance.emitter.addListener(event, listener);
+        this.subscriptions.push(() => {
+          runningInstance.emitter.removeListener(event, listener);
+          log('removed proxied "%s" listener!', event);
+        });
+      };
+      nextTick(() => {
+        this.readyState = "APPLIED" /* APPLIED */;
+      });
+      return;
+    }
+    log("no running instance found, setting up a new instance...");
+    this.setup();
+    this.setInstance();
+    nextTick(() => {
+      this.readyState = "APPLIED" /* APPLIED */;
+    });
+  }
+  setup() {
+  }
+  on(eventName, listener) {
+    const log = this.log.extend("on");
+    if (this.readyState === "DISPOSING" /* DISPOSING */ || this.readyState === "DISPOSED" /* DISPOSED */) {
+      log("cannot listen to events, already disposed!");
+      return;
+    }
+    log('adding "%s" event listener:', eventName, listener.name);
+    this.emitter.on(eventName, listener);
+  }
+  dispose() {
+    const log = this.log.extend("dispose");
+    if (this.readyState === "DISPOSED" /* DISPOSED */) {
+      log("cannot dispose, already disposed!");
+      return;
+    }
+    log("disposing the interceptor...");
+    this.readyState = "DISPOSING" /* DISPOSING */;
+    if (!this.getInstance()) {
+      log("no interceptors running, skipping dispose...");
+      return;
+    }
+    this.clearInstance();
+    log("global symbol deleted:", getGlobalSymbol(this.symbol));
+    if (this.subscriptions.length > 0) {
+      log("disposing of %d subscriptions...", this.subscriptions.length);
+      for (const dispose of this.subscriptions) {
+        dispose();
+      }
+      this.subscriptions = [];
+      log("disposed of all subscriptions!", this.subscriptions.length);
+    }
+    this.emitter.deactivate();
+    log("destroyed the listener!");
+    nextTick(() => {
+      this.readyState = "DISPOSED" /* DISPOSED */;
+    });
+  }
+  getInstance() {
+    var _a;
+    const instance = getGlobalSymbol(this.symbol);
+    this.log("retrieved global instance:", (_a = instance == null ? void 0 : instance.constructor) == null ? void 0 : _a.name);
+    return instance;
+  }
+  setInstance() {
+    setGlobalSymbol(this.symbol, this);
+    this.log("set global instance!", this.symbol.description);
+  }
+  clearInstance() {
+    deleteGlobalSymbol(this.symbol);
+    this.log("cleared global instance!", this.symbol.description);
+  }
+};
+
+export {
+  __commonJS,
+  IS_PATCHED_MODULE,
+  getGlobalSymbol,
+  deleteGlobalSymbol,
+  InterceptorReadyState,
+  Interceptor
+};