vitest 0.0.98 → 0.0.102

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-70b78878.js → utils-c8e62373.js}

@@ -1,5 +1,6 @@
 import require$$0 from 'tty';
 import { isPackageExists } from 'local-pkg';
+import path from 'path';
 
 var picocolors = {exports: {}};
 
@@ -64,6 +65,189 @@ picocolors.exports.createColors = createColors;
 
 var c = picocolors.exports;
 
+function normalizeWindowsPath(input = "") {
+  if (!input.includes("\\")) {
+    return input;
+  }
+  return input.replace(/\\/g, "/");
+}
+
+const _UNC_REGEX = /^[/][/]/;
+const _UNC_DRIVE_REGEX = /^[/][/]([.]{1,2}[/])?([a-zA-Z]):[/]/;
+const _IS_ABSOLUTE_RE = /^\/|^\\|^[a-zA-Z]:[/\\]/;
+const sep = "/";
+const delimiter = ":";
+const normalize = function(path2) {
+  if (path2.length === 0) {
+    return ".";
+  }
+  path2 = normalizeWindowsPath(path2);
+  const isUNCPath = path2.match(_UNC_REGEX);
+  const hasUNCDrive = isUNCPath && path2.match(_UNC_DRIVE_REGEX);
+  const isPathAbsolute = isAbsolute(path2);
+  const trailingSeparator = path2[path2.length - 1] === "/";
+  path2 = normalizeString(path2, !isPathAbsolute);
+  if (path2.length === 0) {
+    if (isPathAbsolute) {
+      return "/";
+    }
+    return trailingSeparator ? "./" : ".";
+  }
+  if (trailingSeparator) {
+    path2 += "/";
+  }
+  if (isUNCPath) {
+    if (hasUNCDrive) {
+      return `//./${path2}`;
+    }
+    return `//${path2}`;
+  }
+  return isPathAbsolute && !isAbsolute(path2) ? `/${path2}` : path2;
+};
+const join = function(...args) {
+  if (args.length === 0) {
+    return ".";
+  }
+  let joined;
+  for (let i = 0; i < args.length; ++i) {
+    const arg = args[i];
+    if (arg.length > 0) {
+      if (joined === void 0) {
+        joined = arg;
+      } else {
+        joined += `/${arg}`;
+      }
+    }
+  }
+  if (joined === void 0) {
+    return ".";
+  }
+  return normalize(joined);
+};
+const resolve = function(...args) {
+  args = args.map((arg) => normalizeWindowsPath(arg));
+  let resolvedPath = "";
+  let resolvedAbsolute = false;
+  for (let i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+    const path2 = i >= 0 ? args[i] : process.cwd();
+    if (path2.length === 0) {
+      continue;
+    }
+    resolvedPath = `${path2}/${resolvedPath}`;
+    resolvedAbsolute = isAbsolute(path2);
+  }
+  resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+  if (resolvedAbsolute && !isAbsolute(resolvedPath)) {
+    return `/${resolvedPath}`;
+  }
+  return resolvedPath.length > 0 ? resolvedPath : ".";
+};
+function normalizeString(path2, allowAboveRoot) {
+  let res = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let char = null;
+  for (let i = 0; i <= path2.length; ++i) {
+    if (i < path2.length) {
+      char = path2[i];
+    } else if (char === "/") {
+      break;
+    } else {
+      char = "/";
+    }
+    if (char === "/") {
+      if (lastSlash === i - 1 || dots === 1) ; else if (dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+          if (res.length > 2) {
+            const lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex === -1) {
+              res = "";
+              lastSegmentLength = 0;
+            } else {
+              res = res.slice(0, lastSlashIndex);
+              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+            }
+            lastSlash = i;
+            dots = 0;
+            continue;
+          } else if (res.length !== 0) {
+            res = "";
+            lastSegmentLength = 0;
+            lastSlash = i;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          res += res.length > 0 ? "/.." : "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0) {
+          res += `/${path2.slice(lastSlash + 1, i)}`;
+        } else {
+          res = path2.slice(lastSlash + 1, i);
+        }
+        lastSegmentLength = i - lastSlash - 1;
+      }
+      lastSlash = i;
+      dots = 0;
+    } else if (char === "." && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}
+const isAbsolute = function(p) {
+  return _IS_ABSOLUTE_RE.test(p);
+};
+const toNamespacedPath = function(p) {
+  return normalizeWindowsPath(p);
+};
+const extname = function(p) {
+  return path.posix.extname(normalizeWindowsPath(p));
+};
+const relative = function(from, to) {
+  return path.posix.relative(normalizeWindowsPath(from), normalizeWindowsPath(to));
+};
+const dirname = function(p) {
+  return path.posix.dirname(normalizeWindowsPath(p));
+};
+const format = function(p) {
+  return normalizeWindowsPath(path.posix.format(p));
+};
+const basename = function(p, ext) {
+  return path.posix.basename(normalizeWindowsPath(p), ext);
+};
+const parse = function(p) {
+  return path.posix.parse(normalizeWindowsPath(p));
+};
+
+const _path = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  sep: sep,
+  delimiter: delimiter,
+  normalize: normalize,
+  join: join,
+  resolve: resolve,
+  normalizeString: normalizeString,
+  isAbsolute: isAbsolute,
+  toNamespacedPath: toNamespacedPath,
+  extname: extname,
+  relative: relative,
+  dirname: dirname,
+  format: format,
+  basename: basename,
+  parse: parse
+});
+
+const index = {
+  ..._path
+};
+
 function toArray(array) {
   array = array || [];
   if (Array.isArray(array))
@@ -139,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}'
@@ -153,10 +337,10 @@ async function ensurePackageInstalled(dependency, promptInstall = !process.env.C
     message: c.reset(`Do you want to install ${c.green(dependency)}?`)
   });
   if (install) {
-    await (await import('./index-e7a421bb.js')).installPackage(dependency, { dev: true });
+    await (await import('./index-0c3a317d.js')).installPackage(dependency, { dev: true });
     return true;
   }
   return false;
 }
 
-export { getTests as a, getSuites as b, c, notNullish as d, ensurePackageInstalled as e, hasTests as f, getNames as g, hasFailed as h, interpretOnlyMode as i, getTasks as j, noop as n, partitionSuiteChildren as p, slash as s, toArray as t };
+export { getTests as a, basename as b, c, dirname as d, ensurePackageInstalled as e, getSuites as f, getNames as g, resolve as h, isAbsolute as i, hasFailed as j, notNullish as k, index as l, interpretOnlyMode as m, noop as n, hasTests as o, partitionSuiteChildren as p, getTasks as q, relative as r, slash as s, toArray as t };

package/dist/utils.js

@@ -1,3 +1,4 @@
-export { e as ensurePackageInstalled, g as getNames, b as getSuites, j as getTasks, a as getTests, h as hasFailed, f as hasTests, i as interpretOnlyMode, n as noop, d as notNullish, p as partitionSuiteChildren, s as slash, t as toArray } from './utils-70b78878.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 { a as resolve, d as dirname$2 } from './index-1488b423.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-e78c749a.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';
@@ -8,7 +8,6 @@ import path from 'path';
 import fs, { promises, realpathSync, statSync, Stats } from 'fs';
 import assert from 'assert';
 import { format as format$2, inspect } from 'util';
-import { s as slash } from './utils-70b78878.js';
 import { s as send } from './rpc-7de86f29.js';
 import 'tty';
 import 'local-pkg';

package/node.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vitest",
-  "version": "0.0.98",
+  "version": "0.0.102",
   "description": "A blazing fast unit test framework powered by Vite",
   "keywords": [
     "vite",
@@ -25,34 +25,32 @@
       "import": "./dist/index.js",
       "types": "./dist/index.d.ts"
     },
-    "./node": {
-      "import": "./dist/node.js",
-      "types": "./dist/node.d.ts"
-    },
+    "./*": "./*",
     "./global": {
       "types": "./global.d.ts"
     },
-    "./*": "./*"
+    "./node": {
+      "import": "./dist/node.js",
+      "types": "./dist/node.d.ts"
+    }
   },
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "bin": {
-    "vitest": "./bin/vitest.mjs"
+    "vitest": "./vitest.mjs"
   },
   "files": [
     "dist",
     "bin",
-    "*.d.ts"
+    "*.d.ts",
+    "*.mjs"
   ],
   "dependencies": {
     "@types/chai": "^4.3.0",
     "@types/chai-subset": "^1.3.3",
     "chai": "^4.3.4",
-    "chai-subset": "^1.6.0",
-    "fast-glob": "^3.2.7",
     "local-pkg": "^0.4.0",
-    "source-map": "^0.7.3",
     "tinypool": "^0.0.3",
     "tinyspy": "^0.1.2"
   },
@@ -66,8 +64,10 @@
     "@types/prompts": "^2.4.0",
     "c8": "^7.10.0",
     "cac": "^6.7.12",
+    "chai-subset": "^1.6.0",
     "cli-truncate": "^3.1.0",
     "diff": "^5.0.0",
+    "fast-glob": "^3.2.7",
     "find-up": "^6.2.0",
     "flatted": "^3.2.4",
     "happy-dom": "^2.25.0",
@@ -83,6 +83,7 @@
     "pretty-format": "^27.4.2",
     "prompts": "^2.4.2",
     "rollup": "^2.61.1",
+    "source-map-js": "^1.0.1",
     "strip-ansi": "^7.0.1",
     "typescript": "^4.5.4"
   },
@@ -104,7 +105,7 @@
     }
   },
   "engines": {
-    "node": ">=16.0.0"
+    "node": ">=14.14.0"
   },
   "scripts": {
     "build": "rimraf dist && rollup -c",

package/{bin/vitest.mjs → vitest.mjs}

@@ -1,8 +1,7 @@
 #!/usr/bin/env node
 
 import { fileURLToPath } from 'url'
-import { resolve } from 'pathe'
-import { ensurePackageInstalled } from '../dist/utils.js'
+import { ensurePackageInstalled, resolvePath } from './dist/utils.js'
 
 const argv = process.argv.slice(2)
 
@@ -13,10 +12,10 @@ if (argv.includes('--coverage')) {
   if (!await ensurePackageInstalled('c8'))
     process.exit(1)
   const filename = fileURLToPath(import.meta.url)
-  const entry = resolve(filename, '../../dist/cli.js')
+  const entry = resolvePath(filename, '../../dist/cli.js')
   process.argv.splice(2, 0, process.argv[0], entry)
   await import('c8/bin/c8.js')
 }
 else {
-  await import('../dist/cli.js')
+  await import('./dist/cli.js')
 }

package/LICENSE

@@ -1,22 +0,0 @@
-MIT License
-
-Copyright (c) 2021-Present Anthony Fu <https://github.com/antfu>
-Copyright (c) 2021-Present Matias Capeletto <https://github.com/patak-dev>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.