vitest 0.0.99 → 0.0.103

package/dist/index.js

@@ -1,9 +1,9 @@
-export { b as assert, f as chai, d as describe, e as expect, i as it, c as should, s as suite, t as test } from './index-aa25bceb.js';
-export { a as afterAll, d as afterEach, b as beforeAll, c as beforeEach, f as fn, s as spyOn, e as vi, v as vitest } from './index-af51d171.js';
+export { d as describe, i as it, s as suite, t as test } from './suite-64b3e636.js';
+export { a as afterAll, d as afterEach, b as beforeAll, c as beforeEach, f as fn, s as spyOn, e as vi, v as vitest } from './index-a190f5a1.js';
+export { assert, default as chai, expect, should } from 'chai';
 import './index-9e71c815.js';
-import './utils-b780070b.js';
+import './utils-c8e62373.js';
 import 'tty';
 import 'local-pkg';
 import 'path';
-import './_commonjsHelpers-bdec4bbd.js';
 import 'tinyspy';

package/dist/{middleware-991dfa87.js → middleware-05e03d95.js}

@@ -1,6 +1,6 @@
-import { A as API_PATH } from './constants-3cbd9066.js';
+import { A as API_PATH } from './constants-a1417084.js';
 import 'url';
-import './utils-b780070b.js';
+import './utils-c8e62373.js';
 import 'tty';
 import 'local-pkg';
 import 'path';

package/dist/node.d.ts

@@ -0,0 +1,313 @@
+import { ViteDevServer, UserConfig as UserConfig$1 } from 'vite';
+import { OptionsReceived } from 'pretty-format';
+
+declare type Awaitable<T> = T | PromiseLike<T>;
+declare type ArgumentsType<T> = T extends (...args: infer U) => any ? U : never;
+interface UserConsoleLog {
+    content: string;
+    type: 'stdout' | 'stderr';
+    taskId?: string;
+}
+
+declare type RunMode = 'run' | 'skip' | 'only' | 'todo';
+declare type TaskState = RunMode | 'pass' | 'fail';
+declare type ComputeMode = 'serial' | 'concurrent';
+interface TaskBase {
+    id: string;
+    name: string;
+    mode: RunMode;
+    computeMode: ComputeMode;
+    suite?: Suite;
+    file?: File;
+    result?: TaskResult;
+}
+interface TaskResult {
+    state: TaskState;
+    start: number;
+    end?: number;
+    error?: unknown;
+}
+declare type TaskResultPack = [id: string, result: TaskResult | undefined];
+interface Suite extends TaskBase {
+    type: 'suite';
+    tasks: Task[];
+}
+interface File extends Suite {
+    filepath: string;
+}
+interface Test extends TaskBase {
+    type: 'test';
+    suite: Suite;
+    result?: TaskResult;
+    fails?: boolean;
+}
+declare type Task = Test | Suite | File;
+
+interface Reporter {
+    onStart?: (files?: string[]) => Awaitable<void>;
+    onFinished?: (files?: File[]) => Awaitable<void>;
+    onTaskUpdate?: (pack: TaskResultPack) => Awaitable<void>;
+    onWatcherStart?: () => Awaitable<void>;
+    onWatcherRerun?: (files: string[], trigger: string) => Awaitable<void>;
+    onServerRestart?: () => Awaitable<void>;
+    onUserConsoleLog?: (log: UserConsoleLog) => Awaitable<void>;
+}
+
+declare type SnapshotUpdateState = 'all' | 'new' | 'none';
+declare type SnapshotStateOptions = {
+    updateSnapshot: SnapshotUpdateState;
+    expand?: boolean;
+    snapshotFormat?: OptionsReceived;
+};
+interface SnapshotResult {
+    filepath: string;
+    added: number;
+    fileDeleted: boolean;
+    matched: number;
+    unchecked: number;
+    uncheckedKeys: Array<string>;
+    unmatched: number;
+    updated: number;
+}
+interface UncheckedSnapshot {
+    filePath: string;
+    keys: Array<string>;
+}
+interface SnapshotSummary {
+    added: number;
+    didUpdate: boolean;
+    failure: boolean;
+    filesAdded: number;
+    filesRemoved: number;
+    filesRemovedList: Array<string>;
+    filesUnmatched: number;
+    filesUpdated: number;
+    matched: number;
+    total: number;
+    unchecked: number;
+    uncheckedKeysByFile: Array<UncheckedSnapshot>;
+    unmatched: number;
+    updated: number;
+}
+
+declare type BuiltinEnvironment = 'node' | 'jsdom' | 'happy-dom';
+interface InlineConfig {
+    /**
+     * Include globs for test files
+     *
+     * @default ['**\/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}']
+     */
+    include?: string[];
+    /**
+     * Exclude globs for test files
+     * @default ['node_modules', 'dist', '.idea', '.git', '.cache']
+     */
+    exclude?: string[];
+    /**
+     * Handling for dependencies inlining or externalizing
+     */
+    deps?: {
+        /**
+         * Externalize means that Vite will bypass the package to native Node.
+         *
+         * Externalized dependencies will not be applied Vite's transformers and resolvers.
+         * And does not support HMR on reload.
+         *
+         * Typically, packages under `node_modules` are externalized.
+         */
+        external?: (string | RegExp)[];
+        /**
+         * Vite will process inlined modules.
+         *
+         * This could be helpful to handle packages that ship `.js` in ESM format (that Node can't handle).
+         */
+        inline?: (string | RegExp)[];
+    };
+    /**
+     * Register apis globally
+     *
+     * @default false
+     */
+    global?: boolean;
+    /**
+     * Running environment
+     *
+     * Supports 'node', 'jsdom', 'happy-dom'
+     *
+     * @default 'node'
+     */
+    environment?: BuiltinEnvironment;
+    /**
+     * Update snapshot files
+     *
+     * @default false
+     */
+    update?: boolean;
+    /**
+     * Watch mode
+     *
+     * @default false
+     */
+    watch?: boolean;
+    /**
+     * Project root
+     */
+    root?: string;
+    /**
+     * Custom reporter for output
+     */
+    reporters?: Reporter | Reporter[];
+    /**
+     * Enable multi-threading
+     *
+     * @default true
+     */
+    threads?: boolean;
+    /**
+     * Maximum number of threads
+     *
+     * @default available CPUs
+     */
+    maxThreads?: number;
+    /**
+     * Minimum number of threads
+     *
+     * @default available CPUs
+     */
+    minThreads?: number;
+    interpretDefault?: boolean;
+    /**
+     * Default timeout of a test in milliseconds
+     *
+     * @default 5000
+     */
+    testTimeout?: number;
+    /**
+     * Default timeout of a hook in milliseconds
+     *
+     * @default 5000
+     */
+    hookTimeout?: number;
+    /**
+     * Silent mode
+     *
+     * @default false
+     */
+    silent?: boolean;
+    /**
+     * Path to setup files
+     */
+    setupFiles?: string | string[];
+    /**
+     * Pattern of file paths to be ignore from triggering watch rerun
+     *
+     * @default ['**\/node_modules\/**', '**\/dist/**']
+     */
+    watchIgnore?: (string | RegExp)[];
+    /**
+     * Open Vitest UI
+     * @internal WIP
+     */
+    open?: boolean;
+    /**
+     * Listen to port and serve API
+     *
+     * When set to true, the default port is 55555
+     *
+     * @internal WIP
+     * @default false
+     */
+    api?: boolean | number;
+}
+interface UserConfig extends InlineConfig {
+    /**
+     * Path to the config file.
+     *
+     * Default resolving to one of:
+     * - `vitest.config.js`
+     * - `vitest.config.ts`
+     * - `vite.config.js`
+     * - `vite.config.ts`
+     */
+    config?: string | undefined;
+    /**
+     * Use happy-dom
+     */
+    dom?: boolean;
+    /**
+     * Do not watch
+     */
+    run?: boolean;
+    /**
+     * Pass with no tests
+     */
+    passWithNoTests?: boolean;
+}
+interface ResolvedConfig extends Omit<Required<UserConfig>, 'config' | 'filters'> {
+    config?: string;
+    filters?: string[];
+    depsInline: (string | RegExp)[];
+    depsExternal: (string | RegExp)[];
+    snapshotOptions: SnapshotStateOptions;
+}
+
+declare class SnapshotManager {
+    config: ResolvedConfig;
+    summary: SnapshotSummary;
+    constructor(config: ResolvedConfig);
+    clear(): void;
+    add(result: SnapshotResult): void;
+}
+
+declare type RunWithFiles = (files: string[], invalidates?: string[]) => Promise<void>;
+interface WorkerPool {
+    runTests: RunWithFiles;
+    collectTests: RunWithFiles;
+    close: () => Promise<void>;
+}
+
+declare class StateManager {
+    filesMap: Record<string, File>;
+    idMap: Record<string, Task>;
+    taskFileMap: WeakMap<Task, File>;
+    getFiles(keys?: string[]): File[];
+    collectFiles(files: File[]): void;
+    updateId(task: Task): void;
+    updateTasks(packs: TaskResultPack[]): void;
+}
+
+declare class Vitest {
+    config: ResolvedConfig;
+    server: ViteDevServer;
+    state: StateManager;
+    snapshot: SnapshotManager;
+    reporters: Reporter[];
+    console: Console;
+    pool: WorkerPool | undefined;
+    invalidates: Set<string>;
+    changedTests: Set<string>;
+    runningPromise?: Promise<void>;
+    isFirstRun: boolean;
+    restartsCount: number;
+    private _onRestartListeners;
+    constructor();
+    setServer(options: UserConfig, server: ViteDevServer): void;
+    start(filters?: string[]): Promise<void>;
+    runFiles(files: string[]): Promise<void>;
+    log(...args: any[]): void;
+    error(...args: any[]): void;
+    private _rerunTimer;
+    private scheduleRerun;
+    private unregisterWatcher;
+    private registerWatcher;
+    private handleFileChanged;
+    close(): Promise<void>;
+    report<T extends keyof Reporter>(name: T, ...args: ArgumentsType<Reporter[T]>): Promise<void>;
+    globTestFiles(filters?: string[]): Promise<string[]>;
+    isTargetFile(id: string): boolean;
+    onServerRestarted(fn: () => void): void;
+}
+
+declare function createVitest(options: UserConfig, viteOverrides?: UserConfig$1): Promise<Vitest>;
+
+export { Vitest, createVitest };

package/dist/node.js

@@ -1,5 +1,5 @@
-export { c as createVitest } from './index-d5bb350e.js';
-import './utils-b780070b.js';
+export { c as createVitest } from './index-6f17b444.js';
+import './utils-c8e62373.js';
 import 'tty';
 import 'local-pkg';
 import 'path';
@@ -10,10 +10,10 @@ import 'os';
 import 'util';
 import 'stream';
 import 'events';
-import './constants-3cbd9066.js';
+import './constants-a1417084.js';
 import 'url';
 import 'perf_hooks';
-import './error-34c1d9e5.js';
+import './error-0e2f75a4.js';
 import './index-825cb54c.js';
 import './_commonjsHelpers-bdec4bbd.js';
 import 'assert';

package/dist/suite-64b3e636.js

@@ -0,0 +1,201 @@
+import { n as nanoid } from './index-9e71c815.js';
+import { n as noop } from './utils-c8e62373.js';
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+function createChainable(keys, fn) {
+  function create(obj) {
+    const chain2 = function(...args) {
+      return fn.apply(obj, args);
+    };
+    for (const key of keys) {
+      Object.defineProperty(chain2, key, {
+        get() {
+          return create(__spreadProps(__spreadValues({}, obj), { [key]: true }));
+        }
+      });
+    }
+    return chain2;
+  }
+  const chain = create({});
+  chain.fn = fn;
+  return chain;
+}
+
+const context = {
+  tasks: [],
+  currentSuite: null
+};
+function collectTask(task) {
+  var _a;
+  (_a = context.currentSuite) == null ? void 0 : _a.tasks.push(task);
+}
+async function runWithSuite(suite, fn) {
+  const prev = context.currentSuite;
+  context.currentSuite = suite;
+  await fn();
+  context.currentSuite = prev;
+}
+function getDefaultTestTimeout() {
+  return process.__vitest_worker__.config.testTimeout;
+}
+function getDefaultHookTimeout() {
+  return process.__vitest_worker__.config.hookTimeout;
+}
+function withTimeout(fn, _timeout) {
+  const timeout = _timeout ?? getDefaultTestTimeout();
+  if (timeout <= 0 || timeout === Infinity)
+    return fn;
+  return (...args) => {
+    return Promise.race([fn(...args), new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        clearTimeout(timer);
+        reject(new Error(`Test timed out in ${timeout}ms.`));
+      }, timeout);
+      timer.unref();
+    })]);
+  };
+}
+function ensureAsyncTest(fn) {
+  if (!fn.length)
+    return fn;
+  return () => new Promise((resolve, reject) => {
+    const done = (...args) => args[0] ? reject(args[0]) : resolve();
+    fn(done);
+  });
+}
+function normalizeTest(fn, timeout) {
+  return withTimeout(ensureAsyncTest(fn), timeout);
+}
+
+const fnMap = /* @__PURE__ */ new WeakMap();
+const hooksMap = /* @__PURE__ */ new WeakMap();
+function setFn(key, fn) {
+  fnMap.set(key, fn);
+}
+function getFn(key) {
+  return fnMap.get(key);
+}
+function setHooks(key, hooks) {
+  hooksMap.set(key, hooks);
+}
+function getHooks(key) {
+  return hooksMap.get(key);
+}
+
+const suite = createSuite();
+const test = createChainable(["concurrent", "skip", "only", "todo", "fails"], function(name, fn, timeout) {
+  getCurrentSuite().test.fn.call(this, name, fn, timeout);
+});
+const describe = suite;
+const it = test;
+const defaultSuite = suite("");
+function clearContext() {
+  context.tasks.length = 0;
+  defaultSuite.clear();
+  context.currentSuite = defaultSuite;
+}
+function getCurrentSuite() {
+  return context.currentSuite || defaultSuite;
+}
+function createSuiteHooks() {
+  return {
+    beforeAll: [],
+    afterAll: [],
+    beforeEach: [],
+    afterEach: []
+  };
+}
+function createSuiteCollector(name, factory = () => {
+}, mode, suiteComputeMode) {
+  const tasks = [];
+  const factoryQueue = [];
+  let suite2;
+  initSuite();
+  const test2 = createChainable(["concurrent", "skip", "only", "todo", "fails"], function(name2, fn, timeout) {
+    const mode2 = this.only ? "only" : this.skip ? "skip" : this.todo ? "todo" : "run";
+    const computeMode = this.concurrent ? "concurrent" : void 0;
+    const test3 = {
+      id: nanoid(),
+      type: "test",
+      name: name2,
+      mode: mode2,
+      computeMode: computeMode ?? (suiteComputeMode ?? "serial"),
+      suite: void 0,
+      fails: this.fails
+    };
+    setFn(test3, normalizeTest(fn || noop, timeout));
+    tasks.push(test3);
+  });
+  const collector = {
+    type: "collector",
+    name,
+    mode,
+    test: test2,
+    tasks,
+    collect,
+    clear,
+    on: addHook
+  };
+  function addHook(name2, ...fn) {
+    getHooks(suite2)[name2].push(...fn);
+  }
+  function initSuite() {
+    suite2 = {
+      id: nanoid(),
+      type: "suite",
+      computeMode: "serial",
+      name,
+      mode,
+      tasks: []
+    };
+    setHooks(suite2, createSuiteHooks());
+  }
+  function clear() {
+    tasks.length = 0;
+    factoryQueue.length = 0;
+    initSuite();
+  }
+  async function collect(file) {
+    factoryQueue.length = 0;
+    if (factory)
+      await runWithSuite(collector, () => factory(test2));
+    const allChildren = await Promise.all([...factoryQueue, ...tasks].map((i) => i.type === "collector" ? i.collect(file) : i));
+    suite2.file = file;
+    suite2.tasks = allChildren;
+    allChildren.forEach((task) => {
+      task.suite = suite2;
+      if (file)
+        task.file = file;
+    });
+    return suite2;
+  }
+  collectTask(collector);
+  return collector;
+}
+function createSuite() {
+  return createChainable(["concurrent", "skip", "only", "todo"], function(name, factory) {
+    const mode = this.only ? "only" : this.skip ? "skip" : this.todo ? "todo" : "run";
+    const computeMode = this.concurrent ? "concurrent" : void 0;
+    return createSuiteCollector(name, factory, mode, computeMode);
+  });
+}
+
+export { getDefaultHookTimeout as a, defaultSuite as b, clearContext as c, describe as d, setHooks as e, getHooks as f, getCurrentSuite as g, context as h, it as i, getFn as j, suite as s, test as t, withTimeout as w };

package/dist/{utils-b780070b.js → utils-c8e62373.js}

@@ -323,7 +323,7 @@ function getNames(task) {
   }
   return names;
 }
-async function ensurePackageInstalled(dependency, promptInstall = !process.env.CI) {
+async function ensurePackageInstalled(dependency, promptInstall = !process.env.CI && process.stdout.isTTY) {
   if (isPackageExists(dependency))
     return true;
   console.log(c.red(`${c.inverse(c.red(" MISSING DEP "))} Can not find dependency '${dependency}'

package/dist/utils.js

@@ -1,4 +1,4 @@
-export { e as ensurePackageInstalled, g as getNames, f as getSuites, q as getTasks, a as getTests, j as hasFailed, o as hasTests, m as interpretOnlyMode, n as noop, k as notNullish, p as partitionSuiteChildren, h as resolvePath, s as slash, t as toArray } from './utils-b780070b.js';
+export { e as ensurePackageInstalled, g as getNames, f as getSuites, q as getTasks, a as getTests, j as hasFailed, o as hasTests, m as interpretOnlyMode, n as noop, k as notNullish, p as partitionSuiteChildren, h as resolvePath, s as slash, t as toArray } from './utils-c8e62373.js';
 import 'local-pkg';
 import 'tty';
 import 'path';

package/dist/worker.js

@@ -1,6 +1,6 @@
-import { s as slash, h as resolve, d as dirname$2 } from './utils-b780070b.js';
+import { s as slash, h as resolve, d as dirname$2 } from './utils-c8e62373.js';
 import { n as nanoid } from './index-9e71c815.js';
-import { c as distDir } from './constants-3cbd9066.js';
+import { c as distDir } from './constants-a1417084.js';
 import { builtinModules, createRequire } from 'module';
 import { pathToFileURL, fileURLToPath as fileURLToPath$2, URL as URL$1 } from 'url';
 import vm from 'vm';

package/node.d.ts

@@ -0,0 +1 @@
+export * from './dist/node'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vitest",
-  "version": "0.0.99",
+  "version": "0.0.103",
   "description": "A blazing fast unit test framework powered by Vite",
   "keywords": [
     "vite",
@@ -49,9 +49,10 @@
   "dependencies": {
     "@types/chai": "^4.3.0",
     "@types/chai-subset": "^1.3.3",
+    "chai": "^4.3.4",
     "local-pkg": "^0.4.0",
     "tinypool": "^0.0.3",
-    "tinyspy": "^0.1.2"
+    "tinyspy": "^0.2.4"
   },
   "devDependencies": {
     "@antfu/install-pkg": "^0.1.0",
@@ -63,7 +64,6 @@
     "@types/prompts": "^2.4.0",
     "c8": "^7.10.0",
     "cac": "^6.7.12",
-    "chai": "^4.3.4",
     "chai-subset": "^1.6.0",
     "cli-truncate": "^3.1.0",
     "diff": "^5.0.0",