@noma.to/qwik-testing-library 1.0.4 → 1.2.0

package/lib/node_modules/.pnpm/@vitest_runner@2.1.1/node_modules/@vitest/runner/dist/index.qwik.mjs

@@ -0,0 +1,665 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { getSafeTimers } from "../../../../../@vitest_utils@2.1.1/node_modules/@vitest/utils/dist/index.qwik.mjs";
+import { l as createChainable } from "./chunk-tasks.qwik.mjs";
+import { isNegativeNaN, isObject, objectAttr, toArray, createDefer } from "../../../../../@vitest_utils@2.1.1/node_modules/@vitest/utils/dist/helpers.qwik.mjs";
+import { f as format, o as objDisplay } from "../../../../../@vitest_utils@2.1.1/node_modules/@vitest/utils/dist/chunk-display.qwik.mjs";
+const fnMap = /* @__PURE__ */ new WeakMap();
+const fixtureMap = /* @__PURE__ */ new WeakMap();
+const hooksMap = /* @__PURE__ */ new WeakMap();
+function setFn(key, fn) {
+  fnMap.set(key, fn);
+}
+function setFixture(key, fixture) {
+  fixtureMap.set(key, fixture);
+}
+function getFixture(key) {
+  return fixtureMap.get(key);
+}
+function setHooks(key, hooks) {
+  hooksMap.set(key, hooks);
+}
+function getHooks(key) {
+  return hooksMap.get(key);
+}
+class PendingError extends Error {
+  constructor(message, task) {
+    super(message);
+    __publicField(this, "code", "VITEST_PENDING");
+    __publicField(this, "taskId");
+    this.message = message;
+    this.taskId = task.id;
+  }
+}
+const collectorContext = {
+  tasks: [],
+  currentSuite: null
+};
+function collectTask(task) {
+  var _a;
+  (_a = collectorContext.currentSuite) == null ? void 0 : _a.tasks.push(task);
+}
+async function runWithSuite(suite2, fn) {
+  const prev = collectorContext.currentSuite;
+  collectorContext.currentSuite = suite2;
+  await fn();
+  collectorContext.currentSuite = prev;
+}
+function withTimeout(fn, timeout, isHook = false) {
+  if (timeout <= 0 || timeout === Number.POSITIVE_INFINITY) {
+    return fn;
+  }
+  const { setTimeout, clearTimeout } = getSafeTimers();
+  return function runWithTimeout(...args) {
+    return Promise.race([
+      fn(...args),
+      new Promise((resolve, reject) => {
+        var _a;
+        const timer = setTimeout(() => {
+          clearTimeout(timer);
+          reject(new Error(makeTimeoutMsg(isHook, timeout)));
+        }, timeout);
+        (_a = timer.unref) == null ? void 0 : _a.call(timer);
+      })
+    ]);
+  };
+}
+function createTestContext(test, runner2) {
+  var _a;
+  const context = function() {
+    throw new Error("done() callback is deprecated, use promise instead");
+  };
+  context.task = test;
+  context.skip = () => {
+    test.pending = true;
+    throw new PendingError("test is skipped; abort execution", test);
+  };
+  context.onTestFailed = (fn) => {
+    test.onFailed || (test.onFailed = []);
+    test.onFailed.push(fn);
+  };
+  context.onTestFinished = (fn) => {
+    test.onFinished || (test.onFinished = []);
+    test.onFinished.push(fn);
+  };
+  return ((_a = runner2.extendTaskContext) == null ? void 0 : _a.call(runner2, context)) || context;
+}
+function makeTimeoutMsg(isHook, timeout) {
+  return `${isHook ? "Hook" : "Test"} timed out in ${timeout}ms.
+If this is a long-running ${isHook ? "hook" : "test"}, pass a timeout value as the last argument or configure it globally with "${isHook ? "hookTimeout" : "testTimeout"}".`;
+}
+function mergeContextFixtures(fixtures, context = {}) {
+  const fixtureOptionKeys = ["auto"];
+  const fixtureArray = Object.entries(fixtures).map(
+    ([prop, value]) => {
+      const fixtureItem = { value };
+      if (Array.isArray(value) && value.length >= 2 && isObject(value[1]) && Object.keys(value[1]).some((key) => fixtureOptionKeys.includes(key))) {
+        Object.assign(fixtureItem, value[1]);
+        fixtureItem.value = value[0];
+      }
+      fixtureItem.prop = prop;
+      fixtureItem.isFn = typeof fixtureItem.value === "function";
+      return fixtureItem;
+    }
+  );
+  if (Array.isArray(context.fixtures)) {
+    context.fixtures = context.fixtures.concat(fixtureArray);
+  } else {
+    context.fixtures = fixtureArray;
+  }
+  fixtureArray.forEach((fixture) => {
+    if (fixture.isFn) {
+      const usedProps = getUsedProps(fixture.value);
+      if (usedProps.length) {
+        fixture.deps = context.fixtures.filter(
+          ({ prop }) => prop !== fixture.prop && usedProps.includes(prop)
+        );
+      }
+    }
+  });
+  return context;
+}
+const fixtureValueMaps = /* @__PURE__ */ new Map();
+const cleanupFnArrayMap = /* @__PURE__ */ new Map();
+function withFixtures(fn, testContext) {
+  return (hookContext) => {
+    const context = hookContext || testContext;
+    if (!context) {
+      return fn({});
+    }
+    const fixtures = getFixture(context);
+    if (!(fixtures == null ? void 0 : fixtures.length)) {
+      return fn(context);
+    }
+    const usedProps = getUsedProps(fn);
+    const hasAutoFixture = fixtures.some(({ auto }) => auto);
+    if (!usedProps.length && !hasAutoFixture) {
+      return fn(context);
+    }
+    if (!fixtureValueMaps.get(context)) {
+      fixtureValueMaps.set(context, /* @__PURE__ */ new Map());
+    }
+    const fixtureValueMap = fixtureValueMaps.get(context);
+    if (!cleanupFnArrayMap.has(context)) {
+      cleanupFnArrayMap.set(context, []);
+    }
+    const cleanupFnArray = cleanupFnArrayMap.get(context);
+    const usedFixtures = fixtures.filter(
+      ({ prop, auto }) => auto || usedProps.includes(prop)
+    );
+    const pendingFixtures = resolveDeps(usedFixtures);
+    if (!pendingFixtures.length) {
+      return fn(context);
+    }
+    async function resolveFixtures() {
+      for (const fixture of pendingFixtures) {
+        if (fixtureValueMap.has(fixture)) {
+          continue;
+        }
+        const resolvedValue = fixture.isFn ? await resolveFixtureFunction(fixture.value, context, cleanupFnArray) : fixture.value;
+        context[fixture.prop] = resolvedValue;
+        fixtureValueMap.set(fixture, resolvedValue);
+        cleanupFnArray.unshift(() => {
+          fixtureValueMap.delete(fixture);
+        });
+      }
+    }
+    return resolveFixtures().then(() => fn(context));
+  };
+}
+async function resolveFixtureFunction(fixtureFn, context, cleanupFnArray) {
+  const useFnArgPromise = createDefer();
+  let isUseFnArgResolved = false;
+  const fixtureReturn = fixtureFn(context, async (useFnArg) => {
+    isUseFnArgResolved = true;
+    useFnArgPromise.resolve(useFnArg);
+    const useReturnPromise = createDefer();
+    cleanupFnArray.push(async () => {
+      useReturnPromise.resolve();
+      await fixtureReturn;
+    });
+    await useReturnPromise;
+  }).catch((e) => {
+    if (!isUseFnArgResolved) {
+      useFnArgPromise.reject(e);
+      return;
+    }
+    throw e;
+  });
+  return useFnArgPromise;
+}
+function resolveDeps(fixtures, depSet = /* @__PURE__ */ new Set(), pendingFixtures = []) {
+  fixtures.forEach((fixture) => {
+    if (pendingFixtures.includes(fixture)) {
+      return;
+    }
+    if (!fixture.isFn || !fixture.deps) {
+      pendingFixtures.push(fixture);
+      return;
+    }
+    if (depSet.has(fixture)) {
+      throw new Error(
+        `Circular fixture dependency detected: ${fixture.prop} <- ${[...depSet].reverse().map((d) => d.prop).join(" <- ")}`
+      );
+    }
+    depSet.add(fixture);
+    resolveDeps(fixture.deps, depSet, pendingFixtures);
+    pendingFixtures.push(fixture);
+    depSet.clear();
+  });
+  return pendingFixtures;
+}
+function getUsedProps(fn) {
+  const match = fn.toString().match(/[^(]*\(([^)]*)/);
+  if (!match) {
+    return [];
+  }
+  const args = splitByComma(match[1]);
+  if (!args.length) {
+    return [];
+  }
+  let first = args[0];
+  if ("__VITEST_FIXTURE_INDEX__" in fn) {
+    first = args[fn.__VITEST_FIXTURE_INDEX__];
+    if (!first) {
+      return [];
+    }
+  }
+  if (!(first.startsWith("{") && first.endsWith("}"))) {
+    throw new Error(
+      `The first argument inside a fixture must use object destructuring pattern, e.g. ({ test } => {}). Instead, received "${first}".`
+    );
+  }
+  const _first = first.slice(1, -1).replace(/\s/g, "");
+  const props = splitByComma(_first).map((prop) => {
+    return prop.replace(/:.*|=.*/g, "");
+  });
+  const last = props.at(-1);
+  if (last && last.startsWith("...")) {
+    throw new Error(
+      `Rest parameters are not supported in fixtures, received "${last}".`
+    );
+  }
+  return props;
+}
+function splitByComma(s) {
+  const result = [];
+  const stack = [];
+  let start = 0;
+  for (let i = 0; i < s.length; i++) {
+    if (s[i] === "{" || s[i] === "[") {
+      stack.push(s[i] === "{" ? "}" : "]");
+    } else if (s[i] === stack[stack.length - 1]) {
+      stack.pop();
+    } else if (!stack.length && s[i] === ",") {
+      const token = s.substring(start, i).trim();
+      if (token) {
+        result.push(token);
+      }
+      start = i + 1;
+    }
+  }
+  const lastToken = s.substring(start).trim();
+  if (lastToken) {
+    result.push(lastToken);
+  }
+  return result;
+}
+const suite = createSuite();
+createTest(function(name, optionsOrFn, optionsOrTest) {
+  getCurrentSuite().test.fn.call(
+    this,
+    formatName(name),
+    optionsOrFn,
+    optionsOrTest
+  );
+});
+let runner;
+let defaultSuite;
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(`Vitest failed to find ${message}. This is a bug in Vitest. Please, open an issue with reproduction.`);
+  }
+}
+function getCurrentSuite() {
+  const currentSuite = collectorContext.currentSuite || defaultSuite;
+  assert(currentSuite, "the current suite");
+  return currentSuite;
+}
+function createSuiteHooks() {
+  return {
+    beforeAll: [],
+    afterAll: [],
+    beforeEach: [],
+    afterEach: []
+  };
+}
+function parseArguments(optionsOrFn, optionsOrTest) {
+  let options = {};
+  let fn = () => {
+  };
+  if (typeof optionsOrTest === "object") {
+    if (typeof optionsOrFn === "object") {
+      throw new TypeError(
+        "Cannot use two objects as arguments. Please provide options and a function callback in that order."
+      );
+    }
+    options = optionsOrTest;
+  } else if (typeof optionsOrTest === "number") {
+    options = { timeout: optionsOrTest };
+  } else if (typeof optionsOrFn === "object") {
+    options = optionsOrFn;
+  }
+  if (typeof optionsOrFn === "function") {
+    if (typeof optionsOrTest === "function") {
+      throw new TypeError(
+        "Cannot use two functions as arguments. Please use the second argument for options."
+      );
+    }
+    fn = optionsOrFn;
+  } else if (typeof optionsOrTest === "function") {
+    fn = optionsOrTest;
+  }
+  return {
+    options,
+    handler: fn
+  };
+}
+function createSuiteCollector(name, factory = () => {
+}, mode, shuffle, each, suiteOptions) {
+  const tasks = [];
+  const factoryQueue = [];
+  let suite2;
+  initSuite();
+  const task = function(name2 = "", options = {}) {
+    const task2 = {
+      id: "",
+      name: name2,
+      suite: void 0,
+      each: options.each,
+      fails: options.fails,
+      context: void 0,
+      type: "custom",
+      file: void 0,
+      retry: options.retry ?? runner.config.retry,
+      repeats: options.repeats,
+      mode: options.only ? "only" : options.skip ? "skip" : options.todo ? "todo" : "run",
+      meta: options.meta ?? /* @__PURE__ */ Object.create(null)
+    };
+    const handler = options.handler;
+    if (options.concurrent || !options.sequential && runner.config.sequence.concurrent) {
+      task2.concurrent = true;
+    }
+    if (shuffle) {
+      task2.shuffle = true;
+    }
+    const context = createTestContext(task2, runner);
+    Object.defineProperty(task2, "context", {
+      value: context,
+      enumerable: false
+    });
+    setFixture(context, options.fixtures);
+    if (handler) {
+      setFn(
+        task2,
+        withTimeout(
+          withAwaitAsyncAssetions(withFixtures(handler, context), task2),
+          (options == null ? void 0 : options.timeout) ?? runner.config.testTimeout
+        )
+      );
+    }
+    if (runner.config.includeTaskLocation) ;
+    tasks.push(task2);
+    return task2;
+  };
+  const test2 = createTest(function(name2, optionsOrFn, optionsOrTest) {
+    let { options, handler } = parseArguments(optionsOrFn, optionsOrTest);
+    if (typeof suiteOptions === "object") {
+      options = Object.assign({}, suiteOptions, options);
+    }
+    options.concurrent = this.concurrent || !this.sequential && (options == null ? void 0 : options.concurrent);
+    options.sequential = this.sequential || !this.concurrent && (options == null ? void 0 : options.sequential);
+    const test3 = task(formatName(name2), {
+      ...this,
+      ...options,
+      handler
+    });
+    test3.type = "test";
+  });
+  const collector = {
+    type: "collector",
+    name,
+    mode,
+    options: suiteOptions,
+    test: test2,
+    tasks,
+    collect,
+    task,
+    clear,
+    on: addHook
+  };
+  function addHook(name2, ...fn) {
+    getHooks(suite2)[name2].push(...fn);
+  }
+  function initSuite(includeLocation) {
+    if (typeof suiteOptions === "number") {
+      suiteOptions = { timeout: suiteOptions };
+    }
+    suite2 = {
+      id: "",
+      type: "suite",
+      name,
+      mode,
+      each,
+      file: void 0,
+      shuffle,
+      tasks: [],
+      meta: /* @__PURE__ */ Object.create(null),
+      concurrent: suiteOptions == null ? void 0 : suiteOptions.concurrent
+    };
+    setHooks(suite2, createSuiteHooks());
+  }
+  function clear() {
+    tasks.length = 0;
+    factoryQueue.length = 0;
+    initSuite();
+  }
+  async function collect(file) {
+    if (!file) {
+      throw new TypeError("File is required to collect tasks.");
+    }
+    factoryQueue.length = 0;
+    if (factory) {
+      await runWithSuite(collector, () => factory(test2));
+    }
+    const allChildren = [];
+    for (const i of [...factoryQueue, ...tasks]) {
+      allChildren.push(i.type === "collector" ? await i.collect(file) : i);
+    }
+    suite2.file = file;
+    suite2.tasks = allChildren;
+    allChildren.forEach((task2) => {
+      task2.suite = suite2;
+      task2.file = file;
+    });
+    return suite2;
+  }
+  collectTask(collector);
+  return collector;
+}
+function withAwaitAsyncAssetions(fn, task) {
+  return async (...args) => {
+    await fn(...args);
+    if (task.promises) {
+      const result = await Promise.allSettled(task.promises);
+      const errors = result.map((r) => r.status === "rejected" ? r.reason : void 0).filter(Boolean);
+      if (errors.length) {
+        throw errors;
+      }
+    }
+  };
+}
+function createSuite() {
+  function suiteFn(name, factoryOrOptions, optionsOrFactory = {}) {
+    const mode = this.only ? "only" : this.skip ? "skip" : this.todo ? "todo" : "run";
+    const currentSuite = collectorContext.currentSuite || defaultSuite;
+    let { options, handler: factory } = parseArguments(
+      factoryOrOptions,
+      optionsOrFactory
+    );
+    if (currentSuite == null ? void 0 : currentSuite.options) {
+      options = { ...currentSuite.options, ...options };
+    }
+    const isConcurrent = options.concurrent || this.concurrent && !this.sequential;
+    const isSequential = options.sequential || this.sequential && !this.concurrent;
+    options.concurrent = isConcurrent && !isSequential;
+    options.sequential = isSequential && !isConcurrent;
+    return createSuiteCollector(
+      formatName(name),
+      factory,
+      mode,
+      this.shuffle,
+      this.each,
+      options
+    );
+  }
+  suiteFn.each = function(cases, ...args) {
+    const suite2 = this.withContext();
+    this.setContext("each", true);
+    if (Array.isArray(cases) && args.length) {
+      cases = formatTemplateString(cases, args);
+    }
+    return (name, optionsOrFn, fnOrOptions) => {
+      const _name = formatName(name);
+      const arrayOnlyCases = cases.every(Array.isArray);
+      const { options, handler } = parseArguments(optionsOrFn, fnOrOptions);
+      const fnFirst = typeof optionsOrFn === "function";
+      cases.forEach((i, idx) => {
+        const items = Array.isArray(i) ? i : [i];
+        if (fnFirst) {
+          if (arrayOnlyCases) {
+            suite2(
+              formatTitle(_name, items, idx),
+              () => handler(...items),
+              options
+            );
+          } else {
+            suite2(formatTitle(_name, items, idx), () => handler(i), options);
+          }
+        } else {
+          if (arrayOnlyCases) {
+            suite2(formatTitle(_name, items, idx), options, () => handler(...items));
+          } else {
+            suite2(formatTitle(_name, items, idx), options, () => handler(i));
+          }
+        }
+      });
+      this.setContext("each", void 0);
+    };
+  };
+  suiteFn.skipIf = (condition) => condition ? suite.skip : suite;
+  suiteFn.runIf = (condition) => condition ? suite : suite.skip;
+  return createChainable(
+    ["concurrent", "sequential", "shuffle", "skip", "only", "todo"],
+    suiteFn
+  );
+}
+function createTaskCollector(fn, context) {
+  const taskFn = fn;
+  taskFn.each = function(cases, ...args) {
+    const test2 = this.withContext();
+    this.setContext("each", true);
+    if (Array.isArray(cases) && args.length) {
+      cases = formatTemplateString(cases, args);
+    }
+    return (name, optionsOrFn, fnOrOptions) => {
+      const _name = formatName(name);
+      const arrayOnlyCases = cases.every(Array.isArray);
+      const { options, handler } = parseArguments(optionsOrFn, fnOrOptions);
+      const fnFirst = typeof optionsOrFn === "function";
+      cases.forEach((i, idx) => {
+        const items = Array.isArray(i) ? i : [i];
+        if (fnFirst) {
+          if (arrayOnlyCases) {
+            test2(
+              formatTitle(_name, items, idx),
+              () => handler(...items),
+              options
+            );
+          } else {
+            test2(formatTitle(_name, items, idx), () => handler(i), options);
+          }
+        } else {
+          if (arrayOnlyCases) {
+            test2(formatTitle(_name, items, idx), options, () => handler(...items));
+          } else {
+            test2(formatTitle(_name, items, idx), options, () => handler(i));
+          }
+        }
+      });
+      this.setContext("each", void 0);
+    };
+  };
+  taskFn.for = function(cases, ...args) {
+    const test2 = this.withContext();
+    if (Array.isArray(cases) && args.length) {
+      cases = formatTemplateString(cases, args);
+    }
+    return (name, optionsOrFn, fnOrOptions) => {
+      const _name = formatName(name);
+      const { options, handler } = parseArguments(optionsOrFn, fnOrOptions);
+      cases.forEach((item, idx) => {
+        const handlerWrapper = (ctx) => handler(item, ctx);
+        handlerWrapper.__VITEST_FIXTURE_INDEX__ = 1;
+        handlerWrapper.toString = () => handler.toString();
+        test2(formatTitle(_name, toArray(item), idx), options, handlerWrapper);
+      });
+    };
+  };
+  taskFn.skipIf = function(condition) {
+    return condition ? this.skip : this;
+  };
+  taskFn.runIf = function(condition) {
+    return condition ? this : this.skip;
+  };
+  taskFn.extend = function(fixtures) {
+    const _context = mergeContextFixtures(fixtures, context);
+    return createTest(function fn2(name, optionsOrFn, optionsOrTest) {
+      getCurrentSuite().test.fn.call(
+        this,
+        formatName(name),
+        optionsOrFn,
+        optionsOrTest
+      );
+    }, _context);
+  };
+  const _test = createChainable(
+    ["concurrent", "sequential", "skip", "only", "todo", "fails"],
+    taskFn
+  );
+  if (context) {
+    _test.mergeContext(context);
+  }
+  return _test;
+}
+function createTest(fn, context) {
+  return createTaskCollector(fn, context);
+}
+function formatName(name) {
+  return typeof name === "string" ? name : name instanceof Function ? name.name || "<anonymous>" : String(name);
+}
+function formatTitle(template, items, idx) {
+  if (template.includes("%#")) {
+    template = template.replace(/%%/g, "__vitest_escaped_%__").replace(/%#/g, `${idx}`).replace(/__vitest_escaped_%__/g, "%%");
+  }
+  const count = template.split("%").length - 1;
+  if (template.includes("%f")) {
+    const placeholders = template.match(/%f/g) || [];
+    placeholders.forEach((_, i) => {
+      if (isNegativeNaN(items[i]) || Object.is(items[i], -0)) {
+        let occurrence = 0;
+        template = template.replace(/%f/g, (match) => {
+          occurrence++;
+          return occurrence === i + 1 ? "-%f" : match;
+        });
+      }
+    });
+  }
+  let formatted = format(template, ...items.slice(0, count));
+  if (isObject(items[0])) {
+    formatted = formatted.replace(
+      /\$([$\w.]+)/g,
+      // https://github.com/chaijs/chai/pull/1490
+      (_, key) => {
+        var _a, _b;
+        return objDisplay(objectAttr(items[0], key), {
+          truncate: (_b = (_a = void 0) == null ? void 0 : _a.chaiConfig) == null ? void 0 : _b.truncateThreshold
+        });
+      }
+    );
+  }
+  return formatted;
+}
+function formatTemplateString(cases, args) {
+  const header = cases.join("").trim().replace(/ /g, "").split("\n").map((i) => i.split("|"))[0];
+  const res = [];
+  for (let i = 0; i < Math.floor(args.length / header.length); i++) {
+    const oneCase = {};
+    for (let j = 0; j < header.length; j++) {
+      oneCase[header[j]] = args[i * header.length + j];
+    }
+    res.push(oneCase);
+  }
+  return res;
+}
+globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
+globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
+export {
+  createTaskCollector,
+  getCurrentSuite,
+  getHooks,
+  setFn,
+  setHooks,
+  suite
+};