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

package/lib/node_modules/.pnpm/@vitest_utils@2.1.1/node_modules/@vitest/utils/dist/error.qwik.cjs

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const diff = require("./diff.qwik.cjs");
+const chunkDisplay = require("./chunk-display.qwik.cjs");
+require("../../../../../tinyrainbow@1.2.0/node_modules/tinyrainbow/dist/browser.qwik.cjs");
+require("../../../../../loupe@3.1.1/node_modules/loupe/lib/index.qwik.cjs");
+const IS_RECORD_SYMBOL = "@@__IMMUTABLE_RECORD__@@";
+const IS_COLLECTION_SYMBOL = "@@__IMMUTABLE_ITERABLE__@@";
+function isImmutable(v) {
+  return v && (v[IS_COLLECTION_SYMBOL] || v[IS_RECORD_SYMBOL]);
+}
+const OBJECT_PROTO = Object.getPrototypeOf({});
+function getUnserializableMessage(err) {
+  if (err instanceof Error) {
+    return `<unserializable>: ${err.message}`;
+  }
+  if (typeof err === "string") {
+    return `<unserializable>: ${err}`;
+  }
+  return "<unserializable>";
+}
+function serializeValue(val, seen = /* @__PURE__ */ new WeakMap()) {
+  if (!val || typeof val === "string") {
+    return val;
+  }
+  if (typeof val === "function") {
+    return `Function<${val.name || "anonymous"}>`;
+  }
+  if (typeof val === "symbol") {
+    return val.toString();
+  }
+  if (typeof val !== "object") {
+    return val;
+  }
+  if (isImmutable(val)) {
+    return serializeValue(val.toJSON(), seen);
+  }
+  if (val instanceof Promise || val.constructor && val.constructor.prototype === "AsyncFunction") {
+    return "Promise";
+  }
+  if (typeof Element !== "undefined" && val instanceof Element) {
+    return val.tagName;
+  }
+  if (typeof val.asymmetricMatch === "function") {
+    return `${val.toString()} ${chunkDisplay.f(val.sample)}`;
+  }
+  if (typeof val.toJSON === "function") {
+    return serializeValue(val.toJSON(), seen);
+  }
+  if (seen.has(val)) {
+    return seen.get(val);
+  }
+  if (Array.isArray(val)) {
+    const clone = new Array(val.length);
+    seen.set(val, clone);
+    val.forEach((e, i) => {
+      try {
+        clone[i] = serializeValue(e, seen);
+      } catch (err) {
+        clone[i] = getUnserializableMessage(err);
+      }
+    });
+    return clone;
+  } else {
+    const clone = /* @__PURE__ */ Object.create(null);
+    seen.set(val, clone);
+    let obj = val;
+    while (obj && obj !== OBJECT_PROTO) {
+      Object.getOwnPropertyNames(obj).forEach((key) => {
+        if (key in clone) {
+          return;
+        }
+        try {
+          clone[key] = serializeValue(val[key], seen);
+        } catch (err) {
+          delete clone[key];
+          clone[key] = getUnserializableMessage(err);
+        }
+      });
+      obj = Object.getPrototypeOf(obj);
+    }
+    return clone;
+  }
+}
+function normalizeErrorMessage(message) {
+  return message.replace(/__(vite_ssr_import|vi_import)_\d+__\./g, "");
+}
+function processError(_err, diffOptions, seen = /* @__PURE__ */ new WeakSet()) {
+  if (!_err || typeof _err !== "object") {
+    return { message: String(_err) };
+  }
+  const err = _err;
+  if (err.stack) {
+    err.stackStr = String(err.stack);
+  }
+  if (err.name) {
+    err.nameStr = String(err.name);
+  }
+  if (err.showDiff || err.showDiff === void 0 && err.expected !== void 0 && err.actual !== void 0) {
+    err.diff = diff.printDiffOrStringify(err.actual, err.expected, {
+      ...diffOptions,
+      ...err.diffOptions
+    });
+  }
+  if (typeof err.expected !== "string") {
+    err.expected = chunkDisplay.s(err.expected, 10);
+  }
+  if (typeof err.actual !== "string") {
+    err.actual = chunkDisplay.s(err.actual, 10);
+  }
+  try {
+    if (typeof err.message === "string") {
+      err.message = normalizeErrorMessage(err.message);
+    }
+  } catch {
+  }
+  try {
+    if (!seen.has(err) && typeof err.cause === "object") {
+      seen.add(err);
+      err.cause = processError(err.cause, diffOptions, seen);
+    }
+  } catch {
+  }
+  try {
+    return serializeValue(err);
+  } catch (e) {
+    return serializeValue(
+      new Error(
+        `Failed to fully serialize error: ${e == null ? void 0 : e.message}
+Inner error message: ${err == null ? void 0 : err.message}`
+      )
+    );
+  }
+}
+exports.processError = processError;
+exports.serializeError = serializeValue;
+exports.serializeValue = serializeValue;

package/lib/node_modules/.pnpm/@vitest_utils@2.1.1/node_modules/@vitest/utils/dist/error.qwik.mjs

@@ -0,0 +1,137 @@
+import { printDiffOrStringify } from "./diff.qwik.mjs";
+import { s as stringify, f as format } from "./chunk-display.qwik.mjs";
+import "../../../../../tinyrainbow@1.2.0/node_modules/tinyrainbow/dist/browser.qwik.mjs";
+import "../../../../../loupe@3.1.1/node_modules/loupe/lib/index.qwik.mjs";
+const IS_RECORD_SYMBOL = "@@__IMMUTABLE_RECORD__@@";
+const IS_COLLECTION_SYMBOL = "@@__IMMUTABLE_ITERABLE__@@";
+function isImmutable(v) {
+  return v && (v[IS_COLLECTION_SYMBOL] || v[IS_RECORD_SYMBOL]);
+}
+const OBJECT_PROTO = Object.getPrototypeOf({});
+function getUnserializableMessage(err) {
+  if (err instanceof Error) {
+    return `<unserializable>: ${err.message}`;
+  }
+  if (typeof err === "string") {
+    return `<unserializable>: ${err}`;
+  }
+  return "<unserializable>";
+}
+function serializeValue(val, seen = /* @__PURE__ */ new WeakMap()) {
+  if (!val || typeof val === "string") {
+    return val;
+  }
+  if (typeof val === "function") {
+    return `Function<${val.name || "anonymous"}>`;
+  }
+  if (typeof val === "symbol") {
+    return val.toString();
+  }
+  if (typeof val !== "object") {
+    return val;
+  }
+  if (isImmutable(val)) {
+    return serializeValue(val.toJSON(), seen);
+  }
+  if (val instanceof Promise || val.constructor && val.constructor.prototype === "AsyncFunction") {
+    return "Promise";
+  }
+  if (typeof Element !== "undefined" && val instanceof Element) {
+    return val.tagName;
+  }
+  if (typeof val.asymmetricMatch === "function") {
+    return `${val.toString()} ${format(val.sample)}`;
+  }
+  if (typeof val.toJSON === "function") {
+    return serializeValue(val.toJSON(), seen);
+  }
+  if (seen.has(val)) {
+    return seen.get(val);
+  }
+  if (Array.isArray(val)) {
+    const clone = new Array(val.length);
+    seen.set(val, clone);
+    val.forEach((e, i) => {
+      try {
+        clone[i] = serializeValue(e, seen);
+      } catch (err) {
+        clone[i] = getUnserializableMessage(err);
+      }
+    });
+    return clone;
+  } else {
+    const clone = /* @__PURE__ */ Object.create(null);
+    seen.set(val, clone);
+    let obj = val;
+    while (obj && obj !== OBJECT_PROTO) {
+      Object.getOwnPropertyNames(obj).forEach((key) => {
+        if (key in clone) {
+          return;
+        }
+        try {
+          clone[key] = serializeValue(val[key], seen);
+        } catch (err) {
+          delete clone[key];
+          clone[key] = getUnserializableMessage(err);
+        }
+      });
+      obj = Object.getPrototypeOf(obj);
+    }
+    return clone;
+  }
+}
+function normalizeErrorMessage(message) {
+  return message.replace(/__(vite_ssr_import|vi_import)_\d+__\./g, "");
+}
+function processError(_err, diffOptions, seen = /* @__PURE__ */ new WeakSet()) {
+  if (!_err || typeof _err !== "object") {
+    return { message: String(_err) };
+  }
+  const err = _err;
+  if (err.stack) {
+    err.stackStr = String(err.stack);
+  }
+  if (err.name) {
+    err.nameStr = String(err.name);
+  }
+  if (err.showDiff || err.showDiff === void 0 && err.expected !== void 0 && err.actual !== void 0) {
+    err.diff = printDiffOrStringify(err.actual, err.expected, {
+      ...diffOptions,
+      ...err.diffOptions
+    });
+  }
+  if (typeof err.expected !== "string") {
+    err.expected = stringify(err.expected, 10);
+  }
+  if (typeof err.actual !== "string") {
+    err.actual = stringify(err.actual, 10);
+  }
+  try {
+    if (typeof err.message === "string") {
+      err.message = normalizeErrorMessage(err.message);
+    }
+  } catch {
+  }
+  try {
+    if (!seen.has(err) && typeof err.cause === "object") {
+      seen.add(err);
+      err.cause = processError(err.cause, diffOptions, seen);
+    }
+  } catch {
+  }
+  try {
+    return serializeValue(err);
+  } catch (e) {
+    return serializeValue(
+      new Error(
+        `Failed to fully serialize error: ${e == null ? void 0 : e.message}
+Inner error message: ${err == null ? void 0 : err.message}`
+      )
+    );
+  }
+}
+export {
+  processError,
+  serializeValue as serializeError,
+  serializeValue
+};

package/lib/node_modules/.pnpm/@vitest_utils@2.1.1/node_modules/@vitest/utils/dist/helpers.qwik.cjs

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function createSimpleStackTrace(options) {
+  const { message = "$$stack trace error", stackTraceLimit = 1 } = options || {};
+  const limit = Error.stackTraceLimit;
+  const prepareStackTrace = Error.prepareStackTrace;
+  Error.stackTraceLimit = stackTraceLimit;
+  Error.prepareStackTrace = (e) => e.stack;
+  const err = new Error(message);
+  const stackTrace = err.stack || "";
+  Error.prepareStackTrace = prepareStackTrace;
+  Error.stackTraceLimit = limit;
+  return stackTrace;
+}
+function assertTypes(value, name, types) {
+  const receivedType = typeof value;
+  const pass = types.includes(receivedType);
+  if (!pass) {
+    throw new TypeError(
+      `${name} value must be ${types.join(" or ")}, received "${receivedType}"`
+    );
+  }
+}
+function toArray(array) {
+  if (array === null || array === void 0) {
+    array = [];
+  }
+  if (Array.isArray(array)) {
+    return array;
+  }
+  return [array];
+}
+function isObject(item) {
+  return item != null && typeof item === "object" && !Array.isArray(item);
+}
+function isFinalObj(obj) {
+  return obj === Object.prototype || obj === Function.prototype || obj === RegExp.prototype;
+}
+function getType(value) {
+  return Object.prototype.toString.apply(value).slice(8, -1);
+}
+function collectOwnProperties(obj, collector) {
+  const collect = typeof collector === "function" ? collector : (key) => collector.add(key);
+  Object.getOwnPropertyNames(obj).forEach(collect);
+  Object.getOwnPropertySymbols(obj).forEach(collect);
+}
+function getOwnProperties(obj) {
+  const ownProps = /* @__PURE__ */ new Set();
+  if (isFinalObj(obj)) {
+    return [];
+  }
+  collectOwnProperties(obj, ownProps);
+  return Array.from(ownProps);
+}
+const defaultCloneOptions = { forceWritable: false };
+function deepClone(val, options = defaultCloneOptions) {
+  const seen = /* @__PURE__ */ new WeakMap();
+  return clone(val, seen, options);
+}
+function clone(val, seen, options = defaultCloneOptions) {
+  let k, out;
+  if (seen.has(val)) {
+    return seen.get(val);
+  }
+  if (Array.isArray(val)) {
+    out = Array.from({ length: k = val.length });
+    seen.set(val, out);
+    while (k--) {
+      out[k] = clone(val[k], seen, options);
+    }
+    return out;
+  }
+  if (Object.prototype.toString.call(val) === "[object Object]") {
+    out = Object.create(Object.getPrototypeOf(val));
+    seen.set(val, out);
+    const props = getOwnProperties(val);
+    for (const k2 of props) {
+      const descriptor = Object.getOwnPropertyDescriptor(val, k2);
+      if (!descriptor) {
+        continue;
+      }
+      const cloned = clone(val[k2], seen, options);
+      if (options.forceWritable) {
+        Object.defineProperty(out, k2, {
+          enumerable: descriptor.enumerable,
+          configurable: true,
+          writable: true,
+          value: cloned
+        });
+      } else if ("get" in descriptor) {
+        Object.defineProperty(out, k2, {
+          ...descriptor,
+          get() {
+            return cloned;
+          }
+        });
+      } else {
+        Object.defineProperty(out, k2, {
+          ...descriptor,
+          value: cloned
+        });
+      }
+    }
+    return out;
+  }
+  return val;
+}
+function objectAttr(source, path, defaultValue = void 0) {
+  const paths = path.replace(/\[(\d+)\]/g, ".$1").split(".");
+  let result = source;
+  for (const p of paths) {
+    result = new Object(result)[p];
+    if (result === void 0) {
+      return defaultValue;
+    }
+  }
+  return result;
+}
+function createDefer() {
+  let resolve = null;
+  let reject = null;
+  const p = new Promise((_resolve, _reject) => {
+    resolve = _resolve;
+    reject = _reject;
+  });
+  p.resolve = resolve;
+  p.reject = reject;
+  return p;
+}
+function isNegativeNaN(val) {
+  if (!Number.isNaN(val)) {
+    return false;
+  }
+  const f64 = new Float64Array(1);
+  f64[0] = val;
+  const u32 = new Uint32Array(f64.buffer);
+  const isNegative = u32[1] >>> 31 === 1;
+  return isNegative;
+}
+exports.assertTypes = assertTypes;
+exports.clone = clone;
+exports.createDefer = createDefer;
+exports.createSimpleStackTrace = createSimpleStackTrace;
+exports.deepClone = deepClone;
+exports.getOwnProperties = getOwnProperties;
+exports.getType = getType;
+exports.isNegativeNaN = isNegativeNaN;
+exports.isObject = isObject;
+exports.objectAttr = objectAttr;
+exports.toArray = toArray;

package/lib/node_modules/.pnpm/@vitest_utils@2.1.1/node_modules/@vitest/utils/dist/helpers.qwik.mjs

@@ -0,0 +1,150 @@
+function createSimpleStackTrace(options) {
+  const { message = "$$stack trace error", stackTraceLimit = 1 } = options || {};
+  const limit = Error.stackTraceLimit;
+  const prepareStackTrace = Error.prepareStackTrace;
+  Error.stackTraceLimit = stackTraceLimit;
+  Error.prepareStackTrace = (e) => e.stack;
+  const err = new Error(message);
+  const stackTrace = err.stack || "";
+  Error.prepareStackTrace = prepareStackTrace;
+  Error.stackTraceLimit = limit;
+  return stackTrace;
+}
+function assertTypes(value, name, types) {
+  const receivedType = typeof value;
+  const pass = types.includes(receivedType);
+  if (!pass) {
+    throw new TypeError(
+      `${name} value must be ${types.join(" or ")}, received "${receivedType}"`
+    );
+  }
+}
+function toArray(array) {
+  if (array === null || array === void 0) {
+    array = [];
+  }
+  if (Array.isArray(array)) {
+    return array;
+  }
+  return [array];
+}
+function isObject(item) {
+  return item != null && typeof item === "object" && !Array.isArray(item);
+}
+function isFinalObj(obj) {
+  return obj === Object.prototype || obj === Function.prototype || obj === RegExp.prototype;
+}
+function getType(value) {
+  return Object.prototype.toString.apply(value).slice(8, -1);
+}
+function collectOwnProperties(obj, collector) {
+  const collect = typeof collector === "function" ? collector : (key) => collector.add(key);
+  Object.getOwnPropertyNames(obj).forEach(collect);
+  Object.getOwnPropertySymbols(obj).forEach(collect);
+}
+function getOwnProperties(obj) {
+  const ownProps = /* @__PURE__ */ new Set();
+  if (isFinalObj(obj)) {
+    return [];
+  }
+  collectOwnProperties(obj, ownProps);
+  return Array.from(ownProps);
+}
+const defaultCloneOptions = { forceWritable: false };
+function deepClone(val, options = defaultCloneOptions) {
+  const seen = /* @__PURE__ */ new WeakMap();
+  return clone(val, seen, options);
+}
+function clone(val, seen, options = defaultCloneOptions) {
+  let k, out;
+  if (seen.has(val)) {
+    return seen.get(val);
+  }
+  if (Array.isArray(val)) {
+    out = Array.from({ length: k = val.length });
+    seen.set(val, out);
+    while (k--) {
+      out[k] = clone(val[k], seen, options);
+    }
+    return out;
+  }
+  if (Object.prototype.toString.call(val) === "[object Object]") {
+    out = Object.create(Object.getPrototypeOf(val));
+    seen.set(val, out);
+    const props = getOwnProperties(val);
+    for (const k2 of props) {
+      const descriptor = Object.getOwnPropertyDescriptor(val, k2);
+      if (!descriptor) {
+        continue;
+      }
+      const cloned = clone(val[k2], seen, options);
+      if (options.forceWritable) {
+        Object.defineProperty(out, k2, {
+          enumerable: descriptor.enumerable,
+          configurable: true,
+          writable: true,
+          value: cloned
+        });
+      } else if ("get" in descriptor) {
+        Object.defineProperty(out, k2, {
+          ...descriptor,
+          get() {
+            return cloned;
+          }
+        });
+      } else {
+        Object.defineProperty(out, k2, {
+          ...descriptor,
+          value: cloned
+        });
+      }
+    }
+    return out;
+  }
+  return val;
+}
+function objectAttr(source, path, defaultValue = void 0) {
+  const paths = path.replace(/\[(\d+)\]/g, ".$1").split(".");
+  let result = source;
+  for (const p of paths) {
+    result = new Object(result)[p];
+    if (result === void 0) {
+      return defaultValue;
+    }
+  }
+  return result;
+}
+function createDefer() {
+  let resolve = null;
+  let reject = null;
+  const p = new Promise((_resolve, _reject) => {
+    resolve = _resolve;
+    reject = _reject;
+  });
+  p.resolve = resolve;
+  p.reject = reject;
+  return p;
+}
+function isNegativeNaN(val) {
+  if (!Number.isNaN(val)) {
+    return false;
+  }
+  const f64 = new Float64Array(1);
+  f64[0] = val;
+  const u32 = new Uint32Array(f64.buffer);
+  const isNegative = u32[1] >>> 31 === 1;
+  return isNegative;
+}
+export {
+  assertTypes,
+  clone,
+  createDefer,
+  createSimpleStackTrace,
+  deepClone,
+  getOwnProperties,
+  getType,
+  isNegativeNaN,
+  isObject,
+  objectAttr,
+  toArray
+};

package/lib/node_modules/.pnpm/@vitest_utils@2.1.1/node_modules/@vitest/utils/dist/index.qwik.cjs

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("../../../../../tinyrainbow@1.2.0/node_modules/tinyrainbow/dist/browser.qwik.cjs");
+require("../../../../../loupe@3.1.1/node_modules/loupe/lib/index.qwik.cjs");
+const SAFE_TIMERS_SYMBOL = Symbol("vitest:SAFE_TIMERS");
+function getSafeTimers() {
+  const {
+    setTimeout: safeSetTimeout,
+    setInterval: safeSetInterval,
+    clearInterval: safeClearInterval,
+    clearTimeout: safeClearTimeout,
+    setImmediate: safeSetImmediate,
+    clearImmediate: safeClearImmediate
+  } = globalThis[SAFE_TIMERS_SYMBOL] || globalThis;
+  const { nextTick: safeNextTick } = globalThis[SAFE_TIMERS_SYMBOL] || globalThis.process || { nextTick: (cb) => cb() };
+  return {
+    nextTick: safeNextTick,
+    setTimeout: safeSetTimeout,
+    setInterval: safeSetInterval,
+    clearInterval: safeClearInterval,
+    clearTimeout: safeClearTimeout,
+    setImmediate: safeSetImmediate,
+    clearImmediate: safeClearImmediate
+  };
+}
+var LineTerminatorSequence;
+LineTerminatorSequence = /\r?\n|[\r\u2028\u2029]/y;
+RegExp(LineTerminatorSequence.source);
+var reservedWords = {
+  keyword: [
+    "break",
+    "case",
+    "catch",
+    "continue",
+    "debugger",
+    "default",
+    "do",
+    "else",
+    "finally",
+    "for",
+    "function",
+    "if",
+    "return",
+    "switch",
+    "throw",
+    "try",
+    "var",
+    "const",
+    "while",
+    "with",
+    "new",
+    "this",
+    "super",
+    "class",
+    "extends",
+    "export",
+    "import",
+    "null",
+    "true",
+    "false",
+    "in",
+    "instanceof",
+    "typeof",
+    "void",
+    "delete"
+  ],
+  strict: [
+    "implements",
+    "interface",
+    "let",
+    "package",
+    "private",
+    "protected",
+    "public",
+    "static",
+    "yield"
+  ]
+};
+new Set(reservedWords.keyword);
+new Set(reservedWords.strict);
+exports.getSafeTimers = getSafeTimers;