importmap_mocha-rails 0.3.1 → 0.3.2

data/vendor/javascripts/@mswjs--interceptors.js

@@ -0,0 +1,238 @@
+// src/glossary.ts
+var IS_PATCHED_MODULE = Symbol("isPatchedModule");
+
+// src/Interceptor.ts
+import { Logger } from "@open-draft/logger";
+import { Emitter } from "strict-event-emitter";
+function getGlobalSymbol(symbol) {
+  return (
+    // @ts-ignore https://github.com/Microsoft/TypeScript/issues/24587
+    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 Emitter();
+    this.subscriptions = [];
+    this.logger = new Logger(symbol.description);
+    this.emitter.setMaxListeners(0);
+    this.logger.info("constructing the interceptor...");
+  }
+  /**
+   * Determine if this interceptor can be applied
+   * in the current environment.
+   */
+  checkEnvironment() {
+    return true;
+  }
+  /**
+   * Apply this interceptor to the current process.
+   * Returns an already running interceptor instance if it's present.
+   */
+  apply() {
+    const logger = this.logger.extend("apply");
+    logger.info("applying the interceptor...");
+    if (this.readyState === "APPLIED" /* APPLIED */) {
+      logger.info("intercepted already applied!");
+      return;
+    }
+    const shouldApply = this.checkEnvironment();
+    if (!shouldApply) {
+      logger.info("the interceptor cannot be applied in this environment!");
+      return;
+    }
+    this.readyState = "APPLYING" /* APPLYING */;
+    const runningInstance = this.getInstance();
+    if (runningInstance) {
+      logger.info("found a running instance, reusing...");
+      this.on = (event, listener) => {
+        logger.info('proxying the "%s" listener', event);
+        runningInstance.emitter.addListener(event, listener);
+        this.subscriptions.push(() => {
+          runningInstance.emitter.removeListener(event, listener);
+          logger.info('removed proxied "%s" listener!', event);
+        });
+        return this;
+      };
+      this.readyState = "APPLIED" /* APPLIED */;
+      return;
+    }
+    logger.info("no running instance found, setting up a new instance...");
+    this.setup();
+    this.setInstance();
+    this.readyState = "APPLIED" /* APPLIED */;
+  }
+  /**
+   * Setup the module augments and stubs necessary for this interceptor.
+   * This method is not run if there's a running interceptor instance
+   * to prevent instantiating an interceptor multiple times.
+   */
+  setup() {
+  }
+  /**
+   * Listen to the interceptor's public events.
+   */
+  on(event, listener) {
+    const logger = this.logger.extend("on");
+    if (this.readyState === "DISPOSING" /* DISPOSING */ || this.readyState === "DISPOSED" /* DISPOSED */) {
+      logger.info("cannot listen to events, already disposed!");
+      return this;
+    }
+    logger.info('adding "%s" event listener:', event, listener);
+    this.emitter.on(event, listener);
+    return this;
+  }
+  once(event, listener) {
+    this.emitter.once(event, listener);
+    return this;
+  }
+  off(event, listener) {
+    this.emitter.off(event, listener);
+    return this;
+  }
+  removeAllListeners(event) {
+    this.emitter.removeAllListeners(event);
+    return this;
+  }
+  /**
+   * Disposes of any side-effects this interceptor has introduced.
+   */
+  dispose() {
+    const logger = this.logger.extend("dispose");
+    if (this.readyState === "DISPOSED" /* DISPOSED */) {
+      logger.info("cannot dispose, already disposed!");
+      return;
+    }
+    logger.info("disposing the interceptor...");
+    this.readyState = "DISPOSING" /* DISPOSING */;
+    if (!this.getInstance()) {
+      logger.info("no interceptors running, skipping dispose...");
+      return;
+    }
+    this.clearInstance();
+    logger.info("global symbol deleted:", getGlobalSymbol(this.symbol));
+    if (this.subscriptions.length > 0) {
+      logger.info("disposing of %d subscriptions...", this.subscriptions.length);
+      for (const dispose of this.subscriptions) {
+        dispose();
+      }
+      this.subscriptions = [];
+      logger.info("disposed of all subscriptions!", this.subscriptions.length);
+    }
+    this.emitter.removeAllListeners();
+    logger.info("destroyed the listener!");
+    this.readyState = "DISPOSED" /* DISPOSED */;
+  }
+  getInstance() {
+    var _a;
+    const instance = getGlobalSymbol(this.symbol);
+    this.logger.info("retrieved global instance:", (_a = instance == null ? void 0 : instance.constructor) == null ? void 0 : _a.name);
+    return instance;
+  }
+  setInstance() {
+    setGlobalSymbol(this.symbol, this);
+    this.logger.info("set global instance!", this.symbol.description);
+  }
+  clearInstance() {
+    deleteGlobalSymbol(this.symbol);
+    this.logger.info("cleared global instance!", this.symbol.description);
+  }
+};
+
+// src/BatchInterceptor.ts
+var BatchInterceptor = class extends Interceptor {
+  constructor(options) {
+    BatchInterceptor.symbol = Symbol(options.name);
+    super(BatchInterceptor.symbol);
+    this.interceptors = options.interceptors;
+  }
+  setup() {
+    const logger = this.logger.extend("setup");
+    logger.info("applying all %d interceptors...", this.interceptors.length);
+    for (const interceptor of this.interceptors) {
+      logger.info('applying "%s" interceptor...', interceptor.constructor.name);
+      interceptor.apply();
+      logger.info("adding interceptor dispose subscription");
+      this.subscriptions.push(() => interceptor.dispose());
+    }
+  }
+  on(event, listener) {
+    for (const interceptor of this.interceptors) {
+      interceptor.on(event, listener);
+    }
+    return this;
+  }
+  once(event, listener) {
+    for (const interceptor of this.interceptors) {
+      interceptor.once(event, listener);
+    }
+    return this;
+  }
+  off(event, listener) {
+    for (const interceptor of this.interceptors) {
+      interceptor.off(event, listener);
+    }
+    return this;
+  }
+  removeAllListeners(event) {
+    for (const interceptors of this.interceptors) {
+      interceptors.removeAllListeners(event);
+    }
+    return this;
+  }
+};
+
+// src/utils/getCleanUrl.ts
+function getCleanUrl(url, isAbsolute = true) {
+  return [isAbsolute && url.origin, url.pathname].filter(Boolean).join("");
+}
+
+// src/utils/bufferUtils.ts
+var encoder = new TextEncoder();
+function encodeBuffer(text) {
+  return encoder.encode(text);
+}
+function decodeBuffer(buffer, encoding) {
+  const decoder = new TextDecoder(encoding);
+  return decoder.decode(buffer);
+}
+
+// src/utils/responseUtils.ts
+var RESPONSE_STATUS_CODES_WITHOUT_BODY = /* @__PURE__ */ new Set([
+  101,
+  103,
+  204,
+  205,
+  304
+]);
+function isResponseWithoutBody(status) {
+  return RESPONSE_STATUS_CODES_WITHOUT_BODY.has(status);
+}
+export {
+  BatchInterceptor,
+  IS_PATCHED_MODULE,
+  Interceptor,
+  InterceptorReadyState,
+  decodeBuffer,
+  deleteGlobalSymbol,
+  encodeBuffer,
+  getCleanUrl,
+  getGlobalSymbol,
+  isResponseWithoutBody
+};

data/vendor/javascripts/@open-draft--deferred-promise.js

@@ -0,0 +1,2 @@
+function createDeferredExecutor(){const executor=(e,t)=>{executor.state="pending";executor.resolve=t=>{if("pending"!==executor.state)return;executor.result=t;const onFulfilled=e=>{executor.state="fulfilled";return e};return e(t instanceof Promise?t:Promise.resolve(t).then(onFulfilled))};executor.reject=e=>{if("pending"===executor.state){queueMicrotask((()=>{executor.state="rejected"}));return t(executor.rejectionReason=e)}}};return executor}var e=class extends Promise{#e;resolve;reject;constructor(e=null){const t=createDeferredExecutor();super(((r,s)=>{t(r,s);e?.(t.resolve,t.reject)}));this.#e=t;this.resolve=this.#e.resolve;this.reject=this.#e.reject}get state(){return this.#e.state}get rejectionReason(){return this.#e.rejectionReason}then(e,t){return this.#t(super.then(e,t))}catch(e){return this.#t(super.catch(e))}finally(e){return this.#t(super.finally(e))}#t(e){return Object.defineProperties(e,{resolve:{configurable:true,value:this.resolve},reject:{configurable:true,value:this.reject}})}};export{e as DeferredPromise,createDeferredExecutor};
+

data/vendor/javascripts/@open-draft--logger.js

@@ -0,0 +1,2 @@
+import{isNodeProcess as e}from"is-node-process";import{format as r}from"outvariant";var t=Object.defineProperty;var __export=(e,r)=>{for(var i in r)t(e,i,{get:r[i],enumerable:true})};var i={};__export(i,{blue:()=>blue,gray:()=>gray,green:()=>green,red:()=>red,yellow:()=>yellow});function yellow(e){return`${e}`}function blue(e){return`${e}`}function gray(e){return`${e}`}function red(e){return`${e}`}function green(e){return`${e}`}var s=e();var n=class{constructor(e){this.name=e;this.prefix=`[${this.name}]`;const r=getVariable("DEBUG");const t=getVariable("LOG_LEVEL");const i="1"===r||"true"===r||"undefined"!==typeof r&&this.name.startsWith(r);if(i){this.debug=isDefinedAndNotEquals(t,"debug")?noop:this.debug;this.info=isDefinedAndNotEquals(t,"info")?noop:this.info;this.success=isDefinedAndNotEquals(t,"success")?noop:this.success;this.warning=isDefinedAndNotEquals(t,"warning")?noop:this.warning;this.error=isDefinedAndNotEquals(t,"error")?noop:this.error}else{this.info=noop;this.success=noop;this.warning=noop;this.error=noop;this.only=noop}}prefix;extend(e){return new n(`${this.name}:${e}`)}debug(e,...r){this.logEntry({level:"debug",message:gray(e),positionals:r,prefix:this.prefix,colors:{prefix:"gray"}})}info(e,...r){this.logEntry({level:"info",message:e,positionals:r,prefix:this.prefix,colors:{prefix:"blue"}});const t=new o;return(e,...r)=>{t.measure();this.logEntry({level:"info",message:`${e} ${gray(`${t.deltaTime}ms`)}`,positionals:r,prefix:this.prefix,colors:{prefix:"blue"}})}}success(e,...r){this.logEntry({level:"info",message:e,positionals:r,prefix:`✔ ${this.prefix}`,colors:{timestamp:"green",prefix:"green"}})}warning(e,...r){this.logEntry({level:"warning",message:e,positionals:r,prefix:`⚠ ${this.prefix}`,colors:{timestamp:"yellow",prefix:"yellow"}})}error(e,...r){this.logEntry({level:"error",message:e,positionals:r,prefix:`✖ ${this.prefix}`,colors:{timestamp:"red",prefix:"red"}})}only(e){e()}createEntry(e,r){return{timestamp:new Date,level:e,message:r}}logEntry(e){const{level:r,message:t,prefix:s,colors:n,positionals:o=[]}=e;const a=this.createEntry(r,t);const l=n?.timestamp||"gray";const c=n?.prefix||"gray";const f={timestamp:i[l],prefix:i[c]};const u=this.getWriter(r);u([f.timestamp(this.formatTimestamp(a.timestamp))].concat(null!=s?f.prefix(s):[]).concat(serializeInput(t)).join(" "),...o.map(serializeInput))}formatTimestamp(e){return`${e.toLocaleTimeString("en-GB")}:${e.getMilliseconds()}`}getWriter(e){switch(e){case"debug":case"success":case"info":return log;case"warning":return warn;case"error":return error}}};var o=class{startTime;endTime;deltaTime;constructor(){this.startTime=performance.now()}measure(){this.endTime=performance.now();const e=this.endTime-this.startTime;this.deltaTime=e.toFixed(2)}};var noop=()=>{};function log(e,...t){s?process.stdout.write(r(e,...t)+"\n"):console.log(e,...t)}function warn(e,...t){s?process.stderr.write(r(e,...t)+"\n"):console.warn(e,...t)}function error(e,...t){s?process.stderr.write(r(e,...t)+"\n"):console.error(e,...t)}function getVariable(e){return s?process.env[e]:globalThis[e]?.toString()}function isDefinedAndNotEquals(e,r){return void 0!==e&&e!==r}function serializeInput(e){return"undefined"===typeof e?"undefined":null===e?"null":"string"===typeof e?e:"object"===typeof e?JSON.stringify(e):e.toString()}export{n as Logger};
+

data/vendor/javascripts/@open-draft--until.js

@@ -0,0 +1,2 @@
+var until=async r=>{try{const t=await r().catch((r=>{throw r}));return{error:null,data:t}}catch(r){return{error:r,data:null}}};export{until};
+