vitest 0.0.90 → 0.0.94

package/dist/index-368448f4.js

@@ -0,0 +1,352 @@
+import { g as getCurrentSuite, w as withTimeout, a as getDefaultHookTimeout, s as suite, t as test, d as describe, i as it } from './suite-b8c6cb53.js';
+import chai, { util, assert, should, expect } from 'chai';
+import * as tinyspy from 'tinyspy';
+import { spies } from 'tinyspy';
+
+const beforeAll = (fn, timeout) => getCurrentSuite().on("beforeAll", withTimeout(fn, timeout ?? getDefaultHookTimeout()));
+const afterAll = (fn, timeout) => getCurrentSuite().on("afterAll", withTimeout(fn, timeout ?? getDefaultHookTimeout()));
+const beforeEach = (fn, timeout) => getCurrentSuite().on("beforeEach", withTimeout(fn, timeout ?? getDefaultHookTimeout()));
+const afterEach = (fn, timeout) => getCurrentSuite().on("afterEach", withTimeout(fn, timeout ?? getDefaultHookTimeout()));
+
+function spyOn(obj, method, accessType) {
+  const dictionary = {
+    get: "getter",
+    set: "setter"
+  };
+  const objMethod = accessType ? { [dictionary[accessType]]: method } : method;
+  const stub = tinyspy.spyOn(obj, objMethod);
+  return enhanceSpy(stub);
+}
+function enhanceSpy(spy) {
+  const stub = spy;
+  let implementation;
+  const instances = [];
+  const mockContext = {
+    get calls() {
+      return stub.calls;
+    },
+    get instances() {
+      return instances;
+    },
+    get invocationCallOrder() {
+      return [];
+    },
+    get results() {
+      return stub.results.map(([callType, value]) => {
+        const type = callType === "error" ? "throw" : "return";
+        return { type, value };
+      });
+    }
+  };
+  let onceImplementations = [];
+  let name = "";
+  Object.defineProperty(stub, "name", {
+    get: () => name
+  });
+  stub.getMockName = () => name || "vi.fn()";
+  stub.mockName = (n) => {
+    name = n;
+    return stub;
+  };
+  stub.mockClear = () => {
+    stub.reset();
+    return stub;
+  };
+  stub.mockReset = () => {
+    stub.reset();
+    return stub;
+  };
+  stub.mockRestore = () => {
+    implementation = void 0;
+    onceImplementations = [];
+    stub.reset();
+    stub.restore();
+    return stub;
+  };
+  stub.getMockImplementation = () => implementation;
+  stub.mockImplementation = (fn2) => {
+    implementation = fn2;
+    return stub;
+  };
+  stub.mockImplementationOnce = (fn2) => {
+    onceImplementations.push(fn2);
+    return stub;
+  };
+  stub.mockReturnThis = () => stub.mockImplementation(function() {
+    return this;
+  });
+  stub.mockReturnValue = (val) => stub.mockImplementation(() => val);
+  stub.mockReturnValueOnce = (val) => stub.mockImplementationOnce(() => val);
+  stub.mockResolvedValue = (val) => stub.mockImplementation(() => Promise.resolve(val));
+  stub.mockResolvedValueOnce = (val) => stub.mockImplementationOnce(() => Promise.resolve(val));
+  stub.mockRejectedValue = (val) => stub.mockImplementation(() => Promise.reject(val));
+  stub.mockRejectedValueOnce = (val) => stub.mockImplementation(() => Promise.reject(val));
+  util.addProperty(stub, "mock", () => mockContext);
+  stub.willCall(function(...args) {
+    instances.push(this);
+    const impl = onceImplementations.shift() || implementation || stub.getOriginal() || (() => {
+    });
+    return impl.apply(this, args);
+  });
+  return stub;
+}
+function fn(implementation) {
+  return enhanceSpy(tinyspy.spyOn({ fn: implementation || (() => {
+  }) }, "fn"));
+}
+
+const originalSetTimeout = global.setTimeout;
+const originalSetInterval = global.setInterval;
+const originalClearTimeout = global.clearTimeout;
+const originalClearInterval = global.clearInterval;
+const MAX_LOOPS = 1e4;
+const assertEvery = (assertions, message) => {
+  if (assertions.some((a) => !a))
+    throw new Error(message);
+};
+const assertMaxLoop = (times) => {
+  if (times >= MAX_LOOPS)
+    throw new Error("setTimeout/setInterval called 10 000 times. It's possible it stuck in an infinite loop.");
+};
+const getNodeTimeout = (id) => {
+  const timer = {
+    ref: () => timer,
+    unref: () => timer,
+    hasRef: () => true,
+    refresh: () => timer,
+    [Symbol.toPrimitive]: () => id
+  };
+  return timer;
+};
+class FakeTimers {
+  constructor() {
+    this._advancedTime = 0;
+    this._nestedTime = {};
+    this._scopeId = 0;
+    this._isNested = false;
+    this._isOnlyPending = false;
+    this._spyid = 0;
+    this._isMocked = false;
+    this._tasksQueue = [];
+    this._queueCount = 0;
+  }
+  useFakeTimers() {
+    this._isMocked = true;
+    this.reset();
+    const spyFactory = (spyType, resultBuilder) => {
+      return (cb, ms = 0) => {
+        const id = ++this._spyid;
+        const nestedTo = Object.entries(this._nestedTime).filter(([key]) => Number(key) <= this._scopeId);
+        const nestedMs = nestedTo.reduce((total, [, ms2]) => total + ms2, ms);
+        const call = { id, cb, ms, nestedMs, scopeId: this._scopeId };
+        const task = { type: spyType, call, nested: this._isNested };
+        this.pushTask(task);
+        return resultBuilder(id, cb);
+      };
+    };
+    this._setTimeout = spyOn(global, "setTimeout").mockImplementation(spyFactory("timeout" /* Timeout */, getNodeTimeout));
+    this._setInterval = spyOn(global, "setInterval").mockImplementation(spyFactory("interval" /* Interval */, getNodeTimeout));
+    const clearTimerFactory = (spyType) => (id) => {
+      if (id === void 0)
+        return;
+      const index = this._tasksQueue.findIndex(({ call, type }) => type === spyType && call.id === Number(id));
+      if (index !== -1)
+        this._tasksQueue.splice(index, 1);
+    };
+    this._clearTimeout = spyOn(global, "clearTimeout").mockImplementation(clearTimerFactory("timeout" /* Timeout */));
+    this._clearInterval = spyOn(global, "clearInterval").mockImplementation(clearTimerFactory("interval" /* Interval */));
+  }
+  useRealTimers() {
+    this._isMocked = false;
+    this.reset();
+    global.setTimeout = originalSetTimeout;
+    global.setInterval = originalSetInterval;
+    global.clearTimeout = originalClearTimeout;
+    global.clearInterval = originalClearInterval;
+  }
+  runOnlyPendingTimers() {
+    this.assertMocked();
+    this._isOnlyPending = true;
+    this.runQueue();
+  }
+  runAllTimers() {
+    this.assertMocked();
+    this.runQueue();
+  }
+  advanceTimersByTime(ms) {
+    this.assertMocked();
+    this._advancedTime += ms;
+    this.runQueue();
+  }
+  advanceTimersToNextTimer() {
+    throw new Error("advanceTimersToNextTimer is not implemented");
+  }
+  runAllTicks() {
+    throw new Error("runAllTicks is not implemented");
+  }
+  setSystemTime(now) {
+    throw new Error("setSystemTime is not implemented");
+  }
+  getRealSystemTime() {
+    return Date.now();
+  }
+  getTimerCount() {
+    this.assertMocked();
+    return this._tasksQueue.length;
+  }
+  reset() {
+    var _a, _b, _c, _d;
+    this._advancedTime = 0;
+    this._nestedTime = {};
+    this._isNested = false;
+    this._isOnlyPending = false;
+    this._spyid = 0;
+    this._queueCount = 0;
+    this._tasksQueue = [];
+    (_a = this._clearInterval) == null ? void 0 : _a.mockRestore();
+    (_b = this._clearTimeout) == null ? void 0 : _b.mockRestore();
+    (_c = this._setInterval) == null ? void 0 : _c.mockRestore();
+    (_d = this._setTimeout) == null ? void 0 : _d.mockRestore();
+  }
+  runQueue() {
+    var _a, _b;
+    let index = 0;
+    while (this._tasksQueue[index]) {
+      assertMaxLoop(this._queueCount);
+      const task = this._tasksQueue[index];
+      const { call, nested, type } = task;
+      if (this._advancedTime && call.nestedMs > this._advancedTime)
+        break;
+      if (this._isOnlyPending && nested) {
+        index++;
+        continue;
+      }
+      this._scopeId = call.id;
+      this._isNested = true;
+      (_a = this._nestedTime)[_b = call.id] ?? (_a[_b] = 0);
+      this._nestedTime[call.id] += call.ms;
+      if (type === "timeout") {
+        this.removeTask(index);
+      } else if (type === "interval") {
+        call.nestedMs += call.ms;
+        const nestedMs = call.nestedMs;
+        const closestTask = this._tasksQueue.findIndex(({ type: type2, call: call2 }) => type2 === "interval" && call2.nestedMs < nestedMs);
+        if (closestTask !== -1 && closestTask !== index)
+          this.ensureQueueOrder();
+      }
+      call.cb();
+      this._queueCount++;
+    }
+  }
+  removeTask(index) {
+    if (index === 0)
+      this._tasksQueue.shift();
+    else
+      this._tasksQueue.splice(index, 1);
+  }
+  pushTask(task) {
+    this._tasksQueue.push(task);
+    this.ensureQueueOrder();
+  }
+  ensureQueueOrder() {
+    this._tasksQueue.sort((t1, t2) => {
+      const diff = t1.call.nestedMs - t2.call.nestedMs;
+      if (diff === 0) {
+        if (t1.type === "immediate" /* Immediate */ && t2.type !== "immediate" /* Immediate */)
+          return 1;
+        return 0;
+      }
+      return diff;
+    });
+  }
+  assertMocked() {
+    assertEvery([
+      this._isMocked,
+      this._setTimeout,
+      this._setInterval,
+      this._clearTimeout,
+      this._clearInterval
+    ], 'timers are not mocked. try calling "vitest.useFakeTimers()" first');
+  }
+}
+
+class VitestUtils {
+  constructor() {
+    this.spyOn = spyOn;
+    this.fn = fn;
+    this.mock = (path) => path;
+    this._timers = new FakeTimers();
+  }
+  useFakeTimers() {
+    return this._timers.useFakeTimers();
+  }
+  useRealTimers() {
+    return this._timers.useRealTimers();
+  }
+  runOnlyPendingTimers() {
+    return this._timers.runOnlyPendingTimers();
+  }
+  runAllTimers() {
+    return this._timers.runAllTimers();
+  }
+  advanceTimersByTime(ms) {
+    return this._timers.advanceTimersByTime(ms);
+  }
+  advanceTimersToNextTimer() {
+    return this._timers.advanceTimersToNextTimer();
+  }
+  runAllTicks() {
+    return this._timers.runAllTicks();
+  }
+  setSystemTime(time) {
+    return this._timers.setSystemTime(time);
+  }
+  getRealSystemTime() {
+    return this._timers.getRealSystemTime();
+  }
+  getTimerCount() {
+    return this._timers.getTimerCount();
+  }
+  isMockFunction(fn2) {
+    return typeof fn2 === "function" && "__isSpy" in fn2 && fn2.__isSpy;
+  }
+  clearAllMocks() {
+    spies.forEach((spy) => {
+      spy.reset();
+    });
+  }
+  resetAllMocks() {
+    spies.forEach((spy) => {
+      spy.reset();
+    });
+  }
+  restoreAllMocks() {
+    spies.forEach((spy) => {
+      spy.restore();
+    });
+  }
+}
+const vitest = new VitestUtils();
+const vi = vitest;
+
+var index = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  suite: suite,
+  test: test,
+  describe: describe,
+  it: it,
+  beforeAll: beforeAll,
+  afterAll: afterAll,
+  beforeEach: beforeEach,
+  afterEach: afterEach,
+  assert: assert,
+  should: should,
+  expect: expect,
+  chai: chai,
+  spyOn: spyOn,
+  fn: fn,
+  vitest: vitest,
+  vi: vi
+});
+
+export { afterAll as a, beforeAll as b, beforeEach as c, afterEach as d, vi as e, fn as f, index as i, spyOn as s, vitest as v };

package/dist/index-5cc247ff.js

@@ -0,0 +1,331 @@
+import assert$1 from 'assert';
+import require$$2 from 'events';
+
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+var onetime$2 = {exports: {}};
+
+var mimicFn$2 = {exports: {}};
+
+const mimicFn$1 = (to, from) => {
+	for (const prop of Reflect.ownKeys(from)) {
+		Object.defineProperty(to, prop, Object.getOwnPropertyDescriptor(from, prop));
+	}
+
+	return to;
+};
+
+mimicFn$2.exports = mimicFn$1;
+// TODO: Remove this for the next major release
+mimicFn$2.exports.default = mimicFn$1;
+
+const mimicFn = mimicFn$2.exports;
+
+const calledFunctions = new WeakMap();
+
+const onetime = (function_, options = {}) => {
+	if (typeof function_ !== 'function') {
+		throw new TypeError('Expected a function');
+	}
+
+	let returnValue;
+	let callCount = 0;
+	const functionName = function_.displayName || function_.name || '<anonymous>';
+
+	const onetime = function (...arguments_) {
+		calledFunctions.set(onetime, ++callCount);
+
+		if (callCount === 1) {
+			returnValue = function_.apply(this, arguments_);
+			function_ = null;
+		} else if (options.throw === true) {
+			throw new Error(`Function \`${functionName}\` can only be called once`);
+		}
+
+		return returnValue;
+	};
+
+	mimicFn(onetime, function_);
+	calledFunctions.set(onetime, callCount);
+
+	return onetime;
+};
+
+onetime$2.exports = onetime;
+// TODO: Remove this for the next major release
+onetime$2.exports.default = onetime;
+
+onetime$2.exports.callCount = function_ => {
+	if (!calledFunctions.has(function_)) {
+		throw new Error(`The given function \`${function_.name}\` is not wrapped by the \`onetime\` package`);
+	}
+
+	return calledFunctions.get(function_);
+};
+
+var onetime$1 = onetime$2.exports;
+
+var signalExit$1 = {exports: {}};
+
+var signals$1 = {exports: {}};
+
+(function (module) {
+// This is not the set of all possible signals.
+//
+// It IS, however, the set of all signals that trigger
+// an exit on either Linux or BSD systems.  Linux is a
+// superset of the signal names supported on BSD, and
+// the unknown signals just fail to register, so we can
+// catch that easily enough.
+//
+// Don't bother with SIGKILL.  It's uncatchable, which
+// means that we can't fire any callbacks anyway.
+//
+// If a user does happen to register a handler on a non-
+// fatal signal like SIGWINCH or something, and then
+// exit, it'll end up firing `process.emit('exit')`, so
+// the handler will be fired anyway.
+//
+// SIGBUS, SIGFPE, SIGSEGV and SIGILL, when not raised
+// artificially, inherently leave the process in a
+// state from which it is not safe to try and enter JS
+// listeners.
+module.exports = [
+  'SIGABRT',
+  'SIGALRM',
+  'SIGHUP',
+  'SIGINT',
+  'SIGTERM'
+];
+
+if (process.platform !== 'win32') {
+  module.exports.push(
+    'SIGVTALRM',
+    'SIGXCPU',
+    'SIGXFSZ',
+    'SIGUSR2',
+    'SIGTRAP',
+    'SIGSYS',
+    'SIGQUIT',
+    'SIGIOT'
+    // should detect profiler and enable/disable accordingly.
+    // see #21
+    // 'SIGPROF'
+  );
+}
+
+if (process.platform === 'linux') {
+  module.exports.push(
+    'SIGIO',
+    'SIGPOLL',
+    'SIGPWR',
+    'SIGSTKFLT',
+    'SIGUNUSED'
+  );
+}
+}(signals$1));
+
+// Note: since nyc uses this module to output coverage, any lines
+// that are in the direct sync flow of nyc's outputCoverage are
+// ignored, since we can never get coverage for them.
+// grab a reference to node's real process object right away
+var process$1 = commonjsGlobal.process;
+
+const processOk = function (process) {
+  return process &&
+    typeof process === 'object' &&
+    typeof process.removeListener === 'function' &&
+    typeof process.emit === 'function' &&
+    typeof process.reallyExit === 'function' &&
+    typeof process.listeners === 'function' &&
+    typeof process.kill === 'function' &&
+    typeof process.pid === 'number' &&
+    typeof process.on === 'function'
+};
+
+// some kind of non-node environment, just no-op
+/* istanbul ignore if */
+if (!processOk(process$1)) {
+  signalExit$1.exports = function () {};
+} else {
+  var assert = assert$1;
+  var signals = signals$1.exports;
+  var isWin = /^win/i.test(process$1.platform);
+
+  var EE = require$$2;
+  /* istanbul ignore if */
+  if (typeof EE !== 'function') {
+    EE = EE.EventEmitter;
+  }
+
+  var emitter;
+  if (process$1.__signal_exit_emitter__) {
+    emitter = process$1.__signal_exit_emitter__;
+  } else {
+    emitter = process$1.__signal_exit_emitter__ = new EE();
+    emitter.count = 0;
+    emitter.emitted = {};
+  }
+
+  // Because this emitter is a global, we have to check to see if a
+  // previous version of this library failed to enable infinite listeners.
+  // I know what you're about to say.  But literally everything about
+  // signal-exit is a compromise with evil.  Get used to it.
+  if (!emitter.infinite) {
+    emitter.setMaxListeners(Infinity);
+    emitter.infinite = true;
+  }
+
+  signalExit$1.exports = function (cb, opts) {
+    /* istanbul ignore if */
+    if (!processOk(commonjsGlobal.process)) {
+      return
+    }
+    assert.equal(typeof cb, 'function', 'a callback must be provided for exit handler');
+
+    if (loaded === false) {
+      load();
+    }
+
+    var ev = 'exit';
+    if (opts && opts.alwaysLast) {
+      ev = 'afterexit';
+    }
+
+    var remove = function () {
+      emitter.removeListener(ev, cb);
+      if (emitter.listeners('exit').length === 0 &&
+          emitter.listeners('afterexit').length === 0) {
+        unload();
+      }
+    };
+    emitter.on(ev, cb);
+
+    return remove
+  };
+
+  var unload = function unload () {
+    if (!loaded || !processOk(commonjsGlobal.process)) {
+      return
+    }
+    loaded = false;
+
+    signals.forEach(function (sig) {
+      try {
+        process$1.removeListener(sig, sigListeners[sig]);
+      } catch (er) {}
+    });
+    process$1.emit = originalProcessEmit;
+    process$1.reallyExit = originalProcessReallyExit;
+    emitter.count -= 1;
+  };
+  signalExit$1.exports.unload = unload;
+
+  var emit = function emit (event, code, signal) {
+    /* istanbul ignore if */
+    if (emitter.emitted[event]) {
+      return
+    }
+    emitter.emitted[event] = true;
+    emitter.emit(event, code, signal);
+  };
+
+  // { <signal>: <listener fn>, ... }
+  var sigListeners = {};
+  signals.forEach(function (sig) {
+    sigListeners[sig] = function listener () {
+      /* istanbul ignore if */
+      if (!processOk(commonjsGlobal.process)) {
+        return
+      }
+      // If there are no other listeners, an exit is coming!
+      // Simplest way: remove us and then re-send the signal.
+      // We know that this will kill the process, so we can
+      // safely emit now.
+      var listeners = process$1.listeners(sig);
+      if (listeners.length === emitter.count) {
+        unload();
+        emit('exit', null, sig);
+        /* istanbul ignore next */
+        emit('afterexit', null, sig);
+        /* istanbul ignore next */
+        if (isWin && sig === 'SIGHUP') {
+          // "SIGHUP" throws an `ENOSYS` error on Windows,
+          // so use a supported signal instead
+          sig = 'SIGINT';
+        }
+        /* istanbul ignore next */
+        process$1.kill(process$1.pid, sig);
+      }
+    };
+  });
+
+  signalExit$1.exports.signals = function () {
+    return signals
+  };
+
+  var loaded = false;
+
+  var load = function load () {
+    if (loaded || !processOk(commonjsGlobal.process)) {
+      return
+    }
+    loaded = true;
+
+    // This is the number of onSignalExit's that are in play.
+    // It's important so that we can count the correct number of
+    // listeners on signals, and don't wait for the other one to
+    // handle it instead of us.
+    emitter.count += 1;
+
+    signals = signals.filter(function (sig) {
+      try {
+        process$1.on(sig, sigListeners[sig]);
+        return true
+      } catch (er) {
+        return false
+      }
+    });
+
+    process$1.emit = processEmit;
+    process$1.reallyExit = processReallyExit;
+  };
+  signalExit$1.exports.load = load;
+
+  var originalProcessReallyExit = process$1.reallyExit;
+  var processReallyExit = function processReallyExit (code) {
+    /* istanbul ignore if */
+    if (!processOk(commonjsGlobal.process)) {
+      return
+    }
+    process$1.exitCode = code || /* istanbul ignore next */ 0;
+    emit('exit', process$1.exitCode, null);
+    /* istanbul ignore next */
+    emit('afterexit', process$1.exitCode, null);
+    /* istanbul ignore next */
+    originalProcessReallyExit.call(process$1, process$1.exitCode);
+  };
+
+  var originalProcessEmit = process$1.emit;
+  var processEmit = function processEmit (ev, arg) {
+    if (ev === 'exit' && processOk(commonjsGlobal.process)) {
+      /* istanbul ignore else */
+      if (arg !== undefined) {
+        process$1.exitCode = arg;
+      }
+      var ret = originalProcessEmit.apply(this, arguments);
+      /* istanbul ignore next */
+      emit('exit', process$1.exitCode, null);
+      /* istanbul ignore next */
+      emit('afterexit', process$1.exitCode, null);
+      /* istanbul ignore next */
+      return ret
+    } else {
+      return originalProcessEmit.apply(this, arguments)
+    }
+  };
+}
+
+var signalExit = signalExit$1.exports;
+
+export { signalExit$1 as a, onetime$2 as b, commonjsGlobal as c, onetime$1 as o, signalExit as s };