@accelint/design-system 0.4.0 → 0.5.1

package/dist/test/setup.js

@@ -12,18 +12,20 @@ import 'react-dom';
 import 'react-dom/client';
 import * as prettyFormat from 'pretty-format.js';
 import lzString from 'lz-string.js';
-import { JestExtend, JestChaiExpect, JestAsymmetricMatchers, GLOBAL_EXPECT, ASYMMETRIC_MATCHERS_OBJECT, getState, setState, addCustomEqualityTesters, equals, iterableEquality, subsetEquality } from '@vitest/expect.js';
-import { afterEach as afterEach$1, getCurrentTest } from '@vitest/runner.js';
-import { getNames } from '@vitest/runner/utils.js';
+import { test, suite, onTestFinished, onTestFailed, it, describe, beforeEach, beforeAll as beforeAll$1, afterEach as afterEach$1, afterAll as afterAll$1, getCurrentSuite, getCurrentTest } from '@vitest/runner.js';
+import { createChainable, getNames } from '@vitest/runner/utils.js';
+import { noop, getSafeTimers, assertTypes, createSimpleStackTrace } from '@vitest/utils.js';
+import 'pathe.js';
 import * as chai$1 from 'chai.js';
-import { assertTypes, createSimpleStackTrace, getSafeTimers } from '@vitest/utils.js';
+import { should, assert } from 'chai.js';
+import { JestExtend, JestChaiExpect, JestAsymmetricMatchers, GLOBAL_EXPECT, ASYMMETRIC_MATCHERS_OBJECT, getState, setState, addCustomEqualityTesters, equals, iterableEquality, subsetEquality } from '@vitest/expect.js';
 import { stripSnapshotIndentation, addSerializer, SnapshotClient } from '@vitest/snapshot.js';
 import '@vitest/utils/error.js';
 import { parseSingleStack } from '@vitest/utils/source-map.js';
-import { spyOn, fn, isMockFunction, mocks } from '@vitest/spy.js';
-import 'expect-type.js';
+import { fn, spyOn, mocks, isMockFunction } from '@vitest/spy.js';
+import 'std-env.js';
 
-// ../../node_modules/.pnpm/@testing-library+jest-dom@6.6.3/node_modules/@testing-library/jest-dom/dist/matchers.mjs
+// ../../node_modules/.pnpm/@testing-library+jest-dom@6.5.0/node_modules/@testing-library/jest-dom/dist/matchers.mjs
 var matchers_exports = {};
 __export(matchers_exports, {
   toBeChecked: () => toBeChecked,
@@ -51,7 +53,6 @@ __export(matchers_exports, {
   toHaveFocus: () => toHaveFocus,
   toHaveFormValues: () => toHaveFormValues,
   toHaveRole: () => toHaveRole,
-  toHaveSelection: () => toHaveSelection,
   toHaveStyle: () => toHaveStyle,
   toHaveTextContent: () => toHaveTextContent,
   toHaveValue: () => toHaveValue
@@ -1356,75 +1357,6 @@ function toHaveErrorMessage(htmlElement, checkWith) {
     }
   };
 }
-function getSelection(element) {
-  const selection = element.ownerDocument.getSelection();
-  if (["input", "textarea"].includes(element.tagName.toLowerCase())) {
-    if (["radio", "checkbox"].includes(element.type)) return "";
-    return element.value.toString().substring(element.selectionStart, element.selectionEnd);
-  }
-  if (selection.anchorNode === null || selection.focusNode === null) {
-    return "";
-  }
-  const originalRange = selection.getRangeAt(0);
-  const temporaryRange = element.ownerDocument.createRange();
-  if (selection.containsNode(element, false)) {
-    temporaryRange.selectNodeContents(element);
-    selection.removeAllRanges();
-    selection.addRange(temporaryRange);
-  } else if (element.contains(selection.anchorNode) && element.contains(selection.focusNode)) ;
-  else {
-    const selectionStartsWithinElement = element === originalRange.startContainer || element.contains(originalRange.startContainer);
-    const selectionEndsWithinElement = element === originalRange.endContainer || element.contains(originalRange.endContainer);
-    selection.removeAllRanges();
-    if (selectionStartsWithinElement || selectionEndsWithinElement) {
-      temporaryRange.selectNodeContents(element);
-      if (selectionStartsWithinElement) {
-        temporaryRange.setStart(
-          originalRange.startContainer,
-          originalRange.startOffset
-        );
-      }
-      if (selectionEndsWithinElement) {
-        temporaryRange.setEnd(
-          originalRange.endContainer,
-          originalRange.endOffset
-        );
-      }
-      selection.addRange(temporaryRange);
-    }
-  }
-  const result = selection.toString();
-  selection.removeAllRanges();
-  selection.addRange(originalRange);
-  return result;
-}
-function toHaveSelection(htmlElement, expectedSelection) {
-  checkHtmlElement(htmlElement, toHaveSelection, this);
-  const expectsSelection = expectedSelection !== void 0;
-  if (expectsSelection && typeof expectedSelection !== "string") {
-    throw new Error(`expected selection must be a string or undefined`);
-  }
-  const receivedSelection = getSelection(htmlElement);
-  return {
-    pass: expectsSelection ? isEqualWith(receivedSelection, expectedSelection, compareArraysAsSet) : Boolean(receivedSelection),
-    message: () => {
-      const to = this.isNot ? "not to" : "to";
-      const matcher = this.utils.matcherHint(
-        `${this.isNot ? ".not" : ""}.toHaveSelection`,
-        "element",
-        expectedSelection
-      );
-      return getMessage(
-        this,
-        matcher,
-        `Expected the element ${to} have selection`,
-        expectsSelection ? expectedSelection : "(any)",
-        "Received",
-        receivedSelection
-      );
-    }
-  };
-}
 function escapeHTML(str) {
   return str.replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
@@ -2145,7 +2077,7 @@ function makeSuggestion(queryName, element, content, _ref) {
   };
 }
 function canSuggest(currentMethod, requestedMethod, data) {
-  return data && (!requestedMethod);
+  return data && (true);
 }
 function getSuggestedQuery(element, variant, method) {
   var _element$getAttribute, _getImplicitAriaRoles;
@@ -3877,7 +3809,7 @@ typeof document !== "undefined" && document.body ? getQueriesForElement(document
   return helpers;
 }, initialValue);
 
-// ../../node_modules/.pnpm/@testing-library+react@16.0.1_@testing-library+dom@10.4.0_@types+react-dom@18.3.1_@types+reac_re4glwsosfgiowsxo2rn27ucqe/node_modules/@testing-library/react/dist/@testing-library/react.esm.js
+// ../../node_modules/.pnpm/@testing-library+react@16.0.1_@testing-library+dom@10.4.0_@types+react-dom@18.3.1_@types+reac_22rmz7z5hut5bauznyeu5nmbnq/node_modules/@testing-library/react/dist/@testing-library/react.esm.js
 var reactAct = typeof React.act === "function" ? React.act : DeprecatedReactTestUtils.act;
 function getGlobalThis() {
   if (typeof globalThis !== "undefined") {
@@ -4022,9 +3954,10 @@ if (typeof process === "undefined" || !process.env?.RTL_SKIP_AUTO_CLEANUP) {
     });
   }
 }
-var NAME_WORKER_STATE = "__vitest_worker__";
+
+// ../../node_modules/.pnpm/vitest@2.1.3_@types+node@20.17.19_jsdom@25.0.1_msw@2.7.0_@types+node@20.17.19_typescript@5.6.3__terser@5.39.0/node_modules/vitest/dist/chunks/utils.Ck2hJTRs.js
 function getWorkerState() {
-  const workerState = globalThis[NAME_WORKER_STATE];
+  const workerState = globalThis.__vitest_worker__;
   if (!workerState) {
     const errorMsg = 'Vitest failed to access its internal state.\n\nOne of the following is possible:\n- "vitest" is imported directly without running "vitest" command\n- "vitest" is imported inside "globalSetup" (to fix this, use "setupFiles" instead, because "globalSetup" runs in a different context)\n- Otherwise, it might be a Vitest bug. Please report it to https://github.com/vitest-dev/vitest/issues\n';
     throw new Error(errorMsg);
@@ -4035,59 +3968,80 @@ function getCurrentEnvironment() {
   const state = getWorkerState();
   return state?.environment.name;
 }
-function isChildProcess() {
-  return typeof process !== "undefined" && !!process.send;
+
+// ../../node_modules/.pnpm/vitest@2.1.3_@types+node@20.17.19_jsdom@25.0.1_msw@2.7.0_@types+node@20.17.19_typescript@5.6.3__terser@5.39.0/node_modules/vitest/dist/chunks/index.CxRxs566.js
+function getRunMode() {
+  return getWorkerState().config.mode;
 }
-function resetModules(modules, resetMocks = false) {
-  const skipPaths = [
-    // Vitest
-    /\/vitest\/dist\//,
-    /\/vite-node\/dist\//,
-    // yarn's .store folder
-    /vitest-virtual-\w+\/dist/,
-    // cnpm
-    /@vitest\/dist/,
-    // don't clear mocks
-    ...!resetMocks ? [/^mock:/] : []
-  ];
-  modules.forEach((mod, path) => {
-    if (skipPaths.some((re) => re.test(path))) {
-      return;
+function isRunningInBenchmark() {
+  return getRunMode() === "benchmark";
+}
+
+// ../../node_modules/.pnpm/vitest@2.1.3_@types+node@20.17.19_jsdom@25.0.1_msw@2.7.0_@types+node@20.17.19_typescript@5.6.3__terser@5.39.0/node_modules/vitest/dist/chunks/benchmark.C8CRJYG4.js
+var benchFns = /* @__PURE__ */ new WeakMap();
+var benchOptsMap = /* @__PURE__ */ new WeakMap();
+var bench = createBenchmark(function(name, fn2 = noop, options = {}) {
+  if (!isRunningInBenchmark()) {
+    throw new Error("`bench()` is only available in benchmark mode.");
+  }
+  const task = getCurrentSuite().task(formatName(name), {
+    ...this,
+    meta: {
+      benchmark: true
     }
-    modules.invalidateModule(mod);
   });
+  benchFns.set(task, fn2);
+  benchOptsMap.set(task, options);
+});
+function createBenchmark(fn2) {
+  const benchmark = createChainable(
+    ["skip", "only", "todo"],
+    fn2
+  );
+  benchmark.skipIf = (condition) => condition ? benchmark.skip : benchmark;
+  benchmark.runIf = (condition) => condition ? benchmark : benchmark.skip;
+  return benchmark;
 }
-function waitNextTick() {
-  const { setTimeout: setTimeout2 } = getSafeTimers();
-  return new Promise((resolve) => setTimeout2(resolve, 0));
+function formatName(name) {
+  return typeof name === "string" ? name : name instanceof Function ? name.name || "<anonymous>" : String(name);
 }
-async function waitForImportsToResolve() {
-  await waitNextTick();
-  const state = getWorkerState();
-  const promises = [];
-  let resolvingCount = 0;
-  for (const mod of state.moduleCache.values()) {
-    if (mod.promise && !mod.evaluated) {
-      promises.push(mod.promise);
-    }
-    if (mod.resolving) {
-      resolvingCount++;
-    }
-  }
-  if (!promises.length && !resolvingCount) {
-    return;
-  }
-  await Promise.allSettled(promises);
-  await waitForImportsToResolve();
+
+// ../../node_modules/.pnpm/vitest@2.1.3_@types+node@20.17.19_jsdom@25.0.1_msw@2.7.0_@types+node@20.17.19_typescript@5.6.3__terser@5.39.0/node_modules/vitest/dist/chunks/run-once.Sxe67Wng.js
+var filesCount = /* @__PURE__ */ new Map();
+var cache = /* @__PURE__ */ new Map();
+function runOnce(fn2, key) {
+  const filepath = getWorkerState().filepath || "__unknown_files__";
+  if (!key) {
+    filesCount.set(filepath, (filesCount.get(filepath) || 0) + 1);
+    key = String(filesCount.get(filepath));
+  }
+  const id = `${filepath}:${key}`;
+  if (!cache.has(id)) {
+    cache.set(id, fn2());
+  }
+  return cache.get(id);
+}
+function isFirstRun() {
+  let firstRun = false;
+  runOnce(() => {
+    firstRun = true;
+  }, "__vitest_first_run__");
+  return firstRun;
 }
 
-// ../../node_modules/.pnpm/vitest@2.1.5_@types+node@20.17.6_jsdom@25.0.1_msw@2.6.4_@types+node@20.17.6_typescript@5.6.3__terser@5.36.0/node_modules/vitest/dist/chunks/_commonjsHelpers.BFTU3MAI.js
+// ../../node_modules/.pnpm/vitest@2.1.3_@types+node@20.17.19_jsdom@25.0.1_msw@2.7.0_@types+node@20.17.19_typescript@5.6.3__terser@5.39.0/node_modules/vitest/dist/chunks/_commonjsHelpers.BFTU3MAI.js
 var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
 function getDefaultExportFromCjs(x) {
   return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
 }
+function getTestName(task, separator = " > ") {
+  return getNames(task).slice(1).join(separator);
+}
+function isChildProcess() {
+  return typeof process !== "undefined" && !!process.send;
+}
 
-// ../../node_modules/.pnpm/vitest@2.1.5_@types+node@20.17.6_jsdom@25.0.1_msw@2.6.4_@types+node@20.17.6_typescript@5.6.3__terser@5.36.0/node_modules/vitest/dist/chunks/date.W2xKR2qe.js
+// ../../node_modules/.pnpm/vitest@2.1.3_@types+node@20.17.19_jsdom@25.0.1_msw@2.7.0_@types+node@20.17.19_typescript@5.6.3__terser@5.39.0/node_modules/vitest/dist/chunks/date.W2xKR2qe.js
 var RealDate = Date;
 var now = null;
 var MockDate = class _MockDate extends RealDate {
@@ -4139,130 +4093,47 @@ function mockDate(date) {
 function resetDate() {
   globalThis.Date = RealDate;
 }
-var unsupported = [
-  // .poll is meant to retry matchers until they succeed, and
-  // snapshots will always succeed as long as the poll method doesn't thow an error
-  // in this case using the `vi.waitFor` method is more appropriate
-  "matchSnapshot",
-  "toMatchSnapshot",
-  "toMatchInlineSnapshot",
-  "toThrowErrorMatchingSnapshot",
-  "toThrowErrorMatchingInlineSnapshot",
-  // toThrow will never succeed because we call the poll callback until it doesn't throw
-  "throws",
-  "Throw",
-  "throw",
-  "toThrow",
-  "toThrowError"
-  // these are not supported because you can call them without `.poll`,
-  // we throw an error inside the rejects/resolves methods to prevent this
-  // rejects,
-  // resolves
-];
-function createExpectPoll(expect2) {
-  return function poll(fn2, options = {}) {
-    const state = getWorkerState();
-    const defaults = state.config.expect?.poll ?? {};
-    const {
-      interval = defaults.interval ?? 50,
-      timeout = defaults.timeout ?? 1e3,
-      message
-    } = options;
-    const assertion = expect2(null, message).withContext({
-      poll: true
-    });
-    fn2 = fn2.bind(assertion);
-    const test2 = chai$1.util.flag(assertion, "vitest-test");
-    if (!test2) {
-      throw new Error("expect.poll() must be called inside a test");
+function resetModules(modules, resetMocks = false) {
+  const skipPaths = [
+    // Vitest
+    /\/vitest\/dist\//,
+    /\/vite-node\/dist\//,
+    // yarn's .store folder
+    /vitest-virtual-\w+\/dist/,
+    // cnpm
+    /@vitest\/dist/,
+    // don't clear mocks
+    ...!resetMocks ? [/^mock:/] : []
+  ];
+  modules.forEach((mod, path) => {
+    if (skipPaths.some((re) => re.test(path))) {
+      return;
     }
-    const proxy = new Proxy(assertion, {
-      get(target, key, receiver) {
-        const assertionFunction = Reflect.get(target, key, receiver);
-        if (typeof assertionFunction !== "function") {
-          return assertionFunction instanceof chai$1.Assertion ? proxy : assertionFunction;
-        }
-        if (key === "assert") {
-          return assertionFunction;
-        }
-        if (typeof key === "string" && unsupported.includes(key)) {
-          throw new SyntaxError(
-            `expect.poll() is not supported in combination with .${key}(). Use vi.waitFor() if your assertion condition is unstable.`
-          );
-        }
-        return function(...args) {
-          const STACK_TRACE_ERROR = new Error("STACK_TRACE_ERROR");
-          const promise = () => new Promise((resolve, reject) => {
-            let intervalId;
-            let lastError;
-            const { setTimeout: setTimeout2, clearTimeout: clearTimeout2 } = getSafeTimers();
-            const timeoutId = setTimeout2(() => {
-              clearTimeout2(intervalId);
-              reject(
-                copyStackTrace$1(
-                  new Error(`Matcher did not succeed in ${timeout}ms`, {
-                    cause: lastError
-                  }),
-                  STACK_TRACE_ERROR
-                )
-              );
-            }, timeout);
-            const check = async () => {
-              try {
-                chai$1.util.flag(assertion, "_name", key);
-                const obj = await fn2();
-                chai$1.util.flag(assertion, "object", obj);
-                resolve(await assertionFunction.call(assertion, ...args));
-                clearTimeout2(intervalId);
-                clearTimeout2(timeoutId);
-              } catch (err) {
-                lastError = err;
-                intervalId = setTimeout2(check, interval);
-              }
-            };
-            check();
-          });
-          let awaited = false;
-          test2.onFinished ??= [];
-          test2.onFinished.push(() => {
-            if (!awaited) {
-              const negated = chai$1.util.flag(assertion, "negate") ? "not." : "";
-              const name = chai$1.util.flag(assertion, "_poll.element") ? "element(locator)" : "poll(assertion)";
-              const assertionString = `expect.${name}.${negated}${String(key)}()`;
-              const error = new Error(
-                `${assertionString} was not awaited. This assertion is asynchronous and must be awaited; otherwise, it is not executed to avoid unhandled rejections:
-
-await ${assertionString}
-`
-              );
-              throw copyStackTrace$1(error, STACK_TRACE_ERROR);
-            }
-          });
-          let resultPromise;
-          return {
-            then(onFulfilled, onRejected) {
-              awaited = true;
-              return (resultPromise ||= promise()).then(onFulfilled, onRejected);
-            },
-            catch(onRejected) {
-              return (resultPromise ||= promise()).catch(onRejected);
-            },
-            finally(onFinally) {
-              return (resultPromise ||= promise()).finally(onFinally);
-            },
-            [Symbol.toStringTag]: "Promise"
-          };
-        };
-      }
-    });
-    return proxy;
-  };
+    modules.invalidateModule(mod);
+  });
 }
-function copyStackTrace$1(target, source) {
-  if (source.stack !== void 0) {
-    target.stack = source.stack.replace(source.message, target.message);
+function waitNextTick() {
+  const { setTimeout: setTimeout2 } = getSafeTimers();
+  return new Promise((resolve) => setTimeout2(resolve, 0));
+}
+async function waitForImportsToResolve() {
+  await waitNextTick();
+  const state = getWorkerState();
+  const promises = [];
+  let resolvingCount = 0;
+  for (const mod of state.moduleCache.values()) {
+    if (mod.promise && !mod.evaluated) {
+      promises.push(mod.promise);
+    }
+    if (mod.resolving) {
+      resolvingCount++;
+    }
   }
-  return target;
+  if (!promises.length && !resolvingCount) {
+    return;
+  }
+  await Promise.allSettled(promises);
+  await waitForImportsToResolve();
 }
 function commonjsRequire(path) {
   throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
@@ -4281,12 +4152,12 @@ function requireChaiSubset() {
         } else {
           return chai.use(chaiSubset2);
         }
-      })(function(chai3, utils) {
-        var Assertion2 = chai3.Assertion;
+      })(function(chai4, utils) {
+        var Assertion2 = chai4.Assertion;
         var assertionPrototype = Assertion2.prototype;
         Assertion2.addMethod("containSubset", function(expected) {
           var actual = utils.flag(this, "object");
-          var showDiff = chai3.config.showDiff;
+          var showDiff = chai4.config.showDiff;
           assertionPrototype.assert.call(
             this,
             compare(expected, actual),
@@ -4297,8 +4168,8 @@ function requireChaiSubset() {
             showDiff
           );
         });
-        chai3.assert.containSubset = function(val, exp, msg) {
-          new chai3.Assertion(val, msg).to.be.containSubset(exp);
+        chai4.assert.containSubset = function(val, exp, msg) {
+          new chai4.Assertion(val, msg).to.be.containSubset(exp);
         };
         function compare(expected, actual) {
           if (expected === actual) {
@@ -4350,56 +4221,18 @@ function requireChaiSubset() {
 }
 var chaiSubsetExports = requireChaiSubset();
 var Subset = /* @__PURE__ */ getDefaultExportFromCjs(chaiSubsetExports);
-function createAssertionMessage(util2, assertion, hasArgs) {
-  const not = util2.flag(assertion, "negate") ? "not." : "";
-  const name = `${util2.flag(assertion, "_name")}(${"expected"})`;
-  const promiseName = util2.flag(assertion, "promise");
-  const promise = promiseName ? `.${promiseName}` : "";
-  return `expect(actual)${promise}.${not}${name}`;
-}
-function recordAsyncExpect(_test, promise, assertion, error) {
-  const test2 = _test;
-  if (test2 && promise instanceof Promise) {
+function recordAsyncExpect(test3, promise) {
+  if (test3 && promise instanceof Promise) {
     promise = promise.finally(() => {
-      if (!test2.promises) {
-        return;
-      }
-      const index = test2.promises.indexOf(promise);
+      const index = test3.promises.indexOf(promise);
       if (index !== -1) {
-        test2.promises.splice(index, 1);
-      }
-    });
-    if (!test2.promises) {
-      test2.promises = [];
-    }
-    test2.promises.push(promise);
-    let resolved = false;
-    test2.onFinished ??= [];
-    test2.onFinished.push(() => {
-      if (!resolved) {
-        const processor = globalThis.__vitest_worker__?.onFilterStackTrace || ((s) => s || "");
-        const stack = processor(error.stack);
-        console.warn([
-          `Promise returned by \`${assertion}\` was not awaited. `,
-          "Vitest currently auto-awaits hanging assertions at the end of the test, but this will cause the test to fail in Vitest 3. ",
-          "Please remember to await the assertion.\n",
-          stack
-        ].join(""));
+        test3.promises.splice(index, 1);
       }
     });
-    return {
-      then(onFullfilled, onRejected) {
-        resolved = true;
-        return promise.then(onFullfilled, onRejected);
-      },
-      catch(onRejected) {
-        return promise.catch(onRejected);
-      },
-      finally(onFinally) {
-        return promise.finally(onFinally);
-      },
-      [Symbol.toStringTag]: "Promise"
-    };
+    if (!test3.promises) {
+      test3.promises = [];
+    }
+    test3.promises.push(promise);
   }
   return promise;
 }
@@ -4430,28 +4263,27 @@ function getError(expected, promise) {
   }
   throw new Error("snapshot function didn't throw");
 }
-function getTestNames(test2) {
-  if (!test2) {
+function getTestNames(test3) {
+  if (!test3) {
     return {};
   }
   return {
-    filepath: test2.file.filepath,
-    name: getNames(test2).slice(1).join(" > ")
+    filepath: test3.file.filepath,
+    name: getNames(test3).slice(1).join(" > ")
   };
 }
-var SnapshotPlugin = (chai3, utils) => {
+var SnapshotPlugin = (chai4, utils) => {
   for (const key of ["matchSnapshot", "toMatchSnapshot"]) {
     utils.addMethod(
-      chai3.Assertion.prototype,
+      chai4.Assertion.prototype,
       key,
       function(properties, message) {
-        utils.flag(this, "_name", key);
         const isNot = utils.flag(this, "negate");
         if (isNot) {
           throw new Error(`${key} cannot be used with "not"`);
         }
         const expected = utils.flag(this, "object");
-        const test2 = utils.flag(this, "vitest-test");
+        const test3 = utils.flag(this, "vitest-test");
         if (typeof properties === "string" && typeof message === "undefined") {
           message = properties;
           properties = void 0;
@@ -4463,23 +4295,21 @@ var SnapshotPlugin = (chai3, utils) => {
           isInline: false,
           properties,
           errorMessage,
-          ...getTestNames(test2)
+          ...getTestNames(test3)
         });
       }
     );
   }
   utils.addMethod(
-    chai3.Assertion.prototype,
+    chai4.Assertion.prototype,
     "toMatchFileSnapshot",
     function(file, message) {
-      utils.flag(this, "_name", "toMatchFileSnapshot");
       const isNot = utils.flag(this, "negate");
       if (isNot) {
         throw new Error('toMatchFileSnapshot cannot be used with "not"');
       }
-      const error = new Error("resolves");
       const expected = utils.flag(this, "object");
-      const test2 = utils.flag(this, "vitest-test");
+      const test3 = utils.flag(this, "vitest-test");
       const errorMessage = utils.flag(this, "message");
       const promise = getSnapshotClient().assertRaw({
         received: expected,
@@ -4489,27 +4319,21 @@ var SnapshotPlugin = (chai3, utils) => {
           file
         },
         errorMessage,
-        ...getTestNames(test2)
+        ...getTestNames(test3)
       });
-      return recordAsyncExpect(
-        test2,
-        promise,
-        createAssertionMessage(utils, this),
-        error
-      );
+      return recordAsyncExpect(test3, promise);
     }
   );
   utils.addMethod(
-    chai3.Assertion.prototype,
+    chai4.Assertion.prototype,
     "toMatchInlineSnapshot",
     function __INLINE_SNAPSHOT__(properties, inlineSnapshot, message) {
-      utils.flag(this, "_name", "toMatchInlineSnapshot");
       const isNot = utils.flag(this, "negate");
       if (isNot) {
         throw new Error('toMatchInlineSnapshot cannot be used with "not"');
       }
-      const test2 = utils.flag(this, "vitest-test");
-      const isInsideEach = test2 && (test2.each || test2.suite?.each);
+      const test3 = utils.flag(this, "vitest-test");
+      const isInsideEach = test3 && (test3.each || test3.suite?.each);
       if (isInsideEach) {
         throw new Error(
           "InlineSnapshot cannot be used inside of test.each or describe.each"
@@ -4534,15 +4358,14 @@ var SnapshotPlugin = (chai3, utils) => {
         inlineSnapshot,
         error,
         errorMessage,
-        ...getTestNames(test2)
+        ...getTestNames(test3)
       });
     }
   );
   utils.addMethod(
-    chai3.Assertion.prototype,
+    chai4.Assertion.prototype,
     "toThrowErrorMatchingSnapshot",
     function(message) {
-      utils.flag(this, "_name", "toThrowErrorMatchingSnapshot");
       const isNot = utils.flag(this, "negate");
       if (isNot) {
         throw new Error(
@@ -4550,19 +4373,19 @@ var SnapshotPlugin = (chai3, utils) => {
         );
       }
       const expected = utils.flag(this, "object");
-      const test2 = utils.flag(this, "vitest-test");
+      const test3 = utils.flag(this, "vitest-test");
       const promise = utils.flag(this, "promise");
       const errorMessage = utils.flag(this, "message");
       getSnapshotClient().assert({
         received: getError(expected, promise),
         message,
         errorMessage,
-        ...getTestNames(test2)
+        ...getTestNames(test3)
       });
     }
   );
   utils.addMethod(
-    chai3.Assertion.prototype,
+    chai4.Assertion.prototype,
     "toThrowErrorMatchingInlineSnapshot",
     function __INLINE_SNAPSHOT__(inlineSnapshot, message) {
       const isNot = utils.flag(this, "negate");
@@ -4571,8 +4394,8 @@ var SnapshotPlugin = (chai3, utils) => {
           'toThrowErrorMatchingInlineSnapshot cannot be used with "not"'
         );
       }
-      const test2 = utils.flag(this, "vitest-test");
-      const isInsideEach = test2 && (test2.each || test2.suite?.each);
+      const test3 = utils.flag(this, "vitest-test");
+      const isInsideEach = test3 && (test3.each || test3.suite?.each);
       if (isInsideEach) {
         throw new Error(
           "InlineSnapshot cannot be used inside of test.each or describe.each"
@@ -4592,23 +4415,114 @@ var SnapshotPlugin = (chai3, utils) => {
         isInline: true,
         error,
         errorMessage,
-        ...getTestNames(test2)
+        ...getTestNames(test3)
       });
     }
   );
-  utils.addMethod(chai3.expect, "addSnapshotSerializer", addSerializer);
+  utils.addMethod(chai4.expect, "addSnapshotSerializer", addSerializer);
 };
 chai$1.use(JestExtend);
 chai$1.use(JestChaiExpect);
 chai$1.use(Subset);
 chai$1.use(SnapshotPlugin);
 chai$1.use(JestAsymmetricMatchers);
-function createExpect(test2) {
+var unsupported = [
+  // .poll is meant to retry matchers until they succeed, and
+  // snapshots will always succeed as long as the poll method doesn't thow an error
+  // in this case using the `vi.waitFor` method is more appropriate
+  "matchSnapshot",
+  "toMatchSnapshot",
+  "toMatchInlineSnapshot",
+  "toThrowErrorMatchingSnapshot",
+  "toThrowErrorMatchingInlineSnapshot",
+  // toThrow will never succeed because we call the poll callback until it doesn't throw
+  "throws",
+  "Throw",
+  "throw",
+  "toThrow",
+  "toThrowError"
+  // these are not supported because you can call them without `.poll`,
+  // we throw an error inside the rejects/resolves methods to prevent this
+  // rejects,
+  // resolves
+];
+function createExpectPoll(expect2) {
+  return function poll(fn2, options = {}) {
+    const state = getWorkerState();
+    const defaults = state.config.expect?.poll ?? {};
+    const {
+      interval = defaults.interval ?? 50,
+      timeout = defaults.timeout ?? 1e3,
+      message
+    } = options;
+    const assertion = expect2(null, message).withContext({
+      poll: true
+    });
+    fn2 = fn2.bind(assertion);
+    const proxy = new Proxy(assertion, {
+      get(target, key, receiver) {
+        const assertionFunction = Reflect.get(target, key, receiver);
+        if (typeof assertionFunction !== "function") {
+          return assertionFunction instanceof chai$1.Assertion ? proxy : assertionFunction;
+        }
+        if (key === "assert") {
+          return assertionFunction;
+        }
+        if (typeof key === "string" && unsupported.includes(key)) {
+          throw new SyntaxError(
+            `expect.poll() is not supported in combination with .${key}(). Use vi.waitFor() if your assertion condition is unstable.`
+          );
+        }
+        return function(...args) {
+          const STACK_TRACE_ERROR = new Error("STACK_TRACE_ERROR");
+          return new Promise((resolve, reject) => {
+            let intervalId;
+            let lastError;
+            const { setTimeout: setTimeout2, clearTimeout: clearTimeout2 } = getSafeTimers();
+            const timeoutId = setTimeout2(() => {
+              clearTimeout2(intervalId);
+              reject(
+                copyStackTrace$1(
+                  new Error(`Matcher did not succeed in ${timeout}ms`, {
+                    cause: lastError
+                  }),
+                  STACK_TRACE_ERROR
+                )
+              );
+            }, timeout);
+            const check = async () => {
+              try {
+                chai$1.util.flag(assertion, "_name", key);
+                const obj = await fn2();
+                chai$1.util.flag(assertion, "object", obj);
+                resolve(await assertionFunction.call(assertion, ...args));
+                clearTimeout2(intervalId);
+                clearTimeout2(timeoutId);
+              } catch (err) {
+                lastError = err;
+                intervalId = setTimeout2(check, interval);
+              }
+            };
+            check();
+          });
+        };
+      }
+    });
+    return proxy;
+  };
+}
+function copyStackTrace$1(target, source) {
+  if (source.stack !== void 0) {
+    target.stack = source.stack.replace(source.message, target.message);
+  }
+  return target;
+}
+function createExpect(test3) {
   const expect2 = (value, message) => {
     const { assertionCalls } = getState(expect2);
     setState({ assertionCalls: assertionCalls + 1 }, expect2);
     const assert22 = chai$1.expect(value, message);
-    const _test = getCurrentTest();
+    const _test = test3 || getCurrentTest();
     if (_test) {
       return assert22.withTest(_test);
     } else {
@@ -4633,7 +4547,7 @@ function createExpect(test2) {
       get testPath() {
         return getWorkerState().filepath;
       },
-      currentTestName: globalState.currentTestName
+      currentTestName: test3 ? getTestName(test3) : globalState.currentTestName
     },
     expect2
   );
@@ -6869,6 +6783,108 @@ function getImporter(name) {
   const stack = parseSingleStack(stackArray[importerStackIndex + 1]);
   return stack?.file || "";
 }
+var dist = {};
+var hasRequiredDist;
+function requireDist() {
+  if (hasRequiredDist) return dist;
+  hasRequiredDist = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.expectTypeOf = void 0;
+    const fn2 = () => true;
+    const expectTypeOf2 = (_actual) => {
+      const nonFunctionProperties = [
+        "parameters",
+        "returns",
+        "resolves",
+        "not",
+        "items",
+        "constructorParameters",
+        "thisParameter",
+        "instance",
+        "guards",
+        "asserts",
+        "branded"
+      ];
+      const obj = {
+        /* eslint-disable @typescript-eslint/no-unsafe-assignment */
+        toBeAny: fn2,
+        toBeUnknown: fn2,
+        toBeNever: fn2,
+        toBeFunction: fn2,
+        toBeObject: fn2,
+        toBeArray: fn2,
+        toBeString: fn2,
+        toBeNumber: fn2,
+        toBeBoolean: fn2,
+        toBeVoid: fn2,
+        toBeSymbol: fn2,
+        toBeNull: fn2,
+        toBeUndefined: fn2,
+        toBeNullable: fn2,
+        toMatchTypeOf: fn2,
+        toEqualTypeOf: fn2,
+        toBeCallableWith: fn2,
+        toBeConstructibleWith: fn2,
+        /* eslint-enable @typescript-eslint/no-unsafe-assignment */
+        extract: exports.expectTypeOf,
+        exclude: exports.expectTypeOf,
+        pick: exports.expectTypeOf,
+        omit: exports.expectTypeOf,
+        toHaveProperty: exports.expectTypeOf,
+        parameter: exports.expectTypeOf
+      };
+      const getterProperties = nonFunctionProperties;
+      getterProperties.forEach((prop) => Object.defineProperty(obj, prop, { get: () => (0, exports.expectTypeOf)({}) }));
+      return obj;
+    };
+    exports.expectTypeOf = expectTypeOf2;
+  })(dist);
+  return dist;
+}
+var distExports = requireDist();
+function noop2() {
+}
+var assertType = noop2;
+function getRunningMode() {
+  return process.env.VITEST_MODE === "WATCH" ? "watch" : "run";
+}
+function isWatchMode() {
+  return getRunningMode() === "watch";
+}
+function inject(key) {
+  const workerState = getWorkerState();
+  return workerState.providedContext[key];
+}
+/* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  afterAll: afterAll$1,
+  afterEach: afterEach$1,
+  assert: assert,
+  assertType,
+  beforeAll: beforeAll$1,
+  beforeEach,
+  bench,
+  chai: chai$1,
+  createExpect,
+  describe,
+  expect: globalExpect,
+  expectTypeOf: distExports.expectTypeOf,
+  getRunningMode,
+  inject,
+  isFirstRun,
+  isWatchMode,
+  it,
+  onTestFailed,
+  onTestFinished,
+  runOnce,
+  should,
+  suite,
+  test,
+  vi,
+  vitest
+});
+distExports.expectTypeOf;
 
 // src/test/setup.ts
 globalExpect.extend(matchers_exports);