@mswjs/interceptors 0.19.5 → 0.21.0

package/lib/node/chunk-QMIXLBOU.js

@@ -0,0 +1,291 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw new Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Interceptor.ts
+var _debug = require('debug');
+
+// src/utils/AsyncEventEmitter.ts
+
+var _stricteventemitter = require('strict-event-emitter');
+
+// src/utils/nextTick.ts
+function nextTick(callback) {
+  setTimeout(callback, 0);
+}
+
+// src/utils/AsyncEventEmitter.ts
+var AsyncEventEmitter = class extends _stricteventemitter.Emitter {
+  constructor() {
+    super();
+    this.log = _debug.debug.call(void 0, "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 = _debug.debug.call(void 0, 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);
+  }
+};
+
+
+
+
+
+
+
+
+
+
+
+
+exports.__require = __require; exports.__esm = __esm; exports.__commonJS = __commonJS; exports.__export = __export; exports.__toESM = __toESM; exports.__toCommonJS = __toCommonJS; exports.getGlobalSymbol = getGlobalSymbol; exports.deleteGlobalSymbol = deleteGlobalSymbol; exports.InterceptorReadyState = InterceptorReadyState; exports.Interceptor = Interceptor;

package/lib/node/chunk-STA6QBYM.mjs

@@ -0,0 +1,64 @@
+// src/utils/toInteractiveRequest.ts
+import { format } from "outvariant";
+
+// src/utils/createLazyCallback.ts
+function createLazyCallback(options = {}) {
+  let calledTimes = 0;
+  let autoResolveTimeout;
+  let remoteResolve;
+  const callPromise = new Promise((resolve) => {
+    remoteResolve = resolve;
+  }).finally(() => {
+    clearTimeout(autoResolveTimeout);
+  });
+  const fn = function(...args) {
+    var _a;
+    if (options.maxCalls && calledTimes >= options.maxCalls) {
+      (_a = options.maxCallsCallback) == null ? void 0 : _a.call(options);
+    }
+    remoteResolve(args);
+    calledTimes++;
+  };
+  fn.invoked = async () => {
+    autoResolveTimeout = setTimeout(() => {
+      remoteResolve([]);
+    }, 0);
+    return callPromise;
+  };
+  return fn;
+}
+
+// src/utils/toInteractiveRequest.ts
+function toInteractiveRequest(request) {
+  Object.defineProperty(request, "respondWith", {
+    writable: false,
+    enumerable: true,
+    value: createLazyCallback({
+      maxCalls: 1,
+      maxCallsCallback() {
+        throw new Error(
+          format(
+            'Failed to respond to "%s %s" request: the "request" event has already been responded to.',
+            request.method,
+            request.url
+          )
+        );
+      }
+    })
+  });
+  return request;
+}
+
+// src/utils/uuid.ts
+function uuidv4() {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
+    const r = Math.random() * 16 | 0;
+    const v = c == "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+
+export {
+  toInteractiveRequest,
+  uuidv4
+};