@multiplatform.one/test-utils 7.83.1 → 7.84.0

package/dist/cjs/setup.native.js

@@ -0,0 +1,957 @@
+"use strict";
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key3 of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key3) && key3 !== except) __defProp(to, key3, {
+      get: () => from[key3],
+      enumerable: !(desc = __getOwnPropDesc(from, key3)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+// If the importer is in node compatibility mode or this is not an ESM
+// file that has been converted to a CommonJS file using a Babel-
+// compatible transform (i.e. "__esModule" has not been set), then set
+// "default" to the CommonJS "module.exports" for node compatibility.
+isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+  value: mod,
+  enumerable: true
+}) : target, mod));
+var import_jest_dom = require("@testing-library/jest-dom");
+var import_matchmedia_polyfill = require("matchmedia-polyfill");
+var import_config = require("@tamagui/config");
+var import_react = require("@testing-library/react");
+var import_tamagui = require("tamagui");
+var import_vitest = require("vitest");
+var import_frames = require("./frames.native.js");
+function _assert_this_initialized(self1) {
+  if (self1 === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+  return self1;
+}
+function _call_super(_this, derived, args) {
+  derived = _get_prototype_of(derived);
+  return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+function _construct(Parent, args, Class) {
+  if (_is_native_reflect_construct()) {
+    _construct = Reflect.construct;
+  } else {
+    _construct = function construct(Parent2, args2, Class2) {
+      var a = [null];
+      a.push.apply(a, args2);
+      var Constructor = Function.bind.apply(Parent2, a);
+      var instance = new Constructor();
+      if (Class2) _set_prototype_of(instance, Class2.prototype);
+      return instance;
+    };
+  }
+  return _construct.apply(null, arguments);
+}
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  return Constructor;
+}
+function _define_property(obj, key3, value) {
+  if (key3 in obj) {
+    Object.defineProperty(obj, key3, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key3] = value;
+  }
+  return obj;
+}
+function _get_prototype_of(o) {
+  _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o2) {
+    return o2.__proto__ || Object.getPrototypeOf(o2);
+  };
+  return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function");
+  }
+  subClass.prototype = Object.create(superClass && superClass.prototype, {
+    constructor: {
+      value: subClass,
+      writable: true,
+      configurable: true
+    }
+  });
+  if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _instanceof(left, right) {
+  "@swc/helpers - instanceof";
+
+  if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+    return !!right[Symbol.hasInstance](left);
+  } else {
+    return left instanceof right;
+  }
+}
+function _is_native_function(fn) {
+  return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+function _possible_constructor_return(self1, call) {
+  if (call && (_type_of(call) === "object" || typeof call === "function")) {
+    return call;
+  }
+  return _assert_this_initialized(self1);
+}
+function _set_prototype_of(o, p) {
+  _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o2, p2) {
+    o2.__proto__ = p2;
+    return o2;
+  };
+  return _set_prototype_of(o, p);
+}
+function _type_of(obj) {
+  "@swc/helpers - typeof";
+
+  return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _wrap_native_super(Class) {
+  var _cache = typeof Map === "function" ? /* @__PURE__ */new Map() : void 0;
+  _wrap_native_super = function wrapNativeSuper(Class2) {
+    if (Class2 === null || !_is_native_function(Class2)) return Class2;
+    if (typeof Class2 !== "function") {
+      throw new TypeError("Super expression must either be null or a function");
+    }
+    if (typeof _cache !== "undefined") {
+      if (_cache.has(Class2)) return _cache.get(Class2);
+      _cache.set(Class2, Wrapper);
+    }
+    function Wrapper() {
+      return _construct(Class2, arguments, _get_prototype_of(this).constructor);
+    }
+    Wrapper.prototype = Object.create(Class2.prototype, {
+      constructor: {
+        value: Wrapper,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+    return _set_prototype_of(Wrapper, Class2);
+  };
+  return _wrap_native_super(Class);
+}
+function _is_native_reflect_construct() {
+  try {
+    var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+  } catch (_) {}
+  return (_is_native_reflect_construct = function () {
+    return !!result;
+  })();
+}
+var _noopStorage = {
+  getItem: function getItem() {
+    return null;
+  },
+  setItem: function setItem() {},
+  removeItem: function removeItem() {},
+  clear: function clear() {},
+  get length() {
+    return 0;
+  },
+  key: function key() {
+    return null;
+  }
+};
+if (typeof globalThis !== "undefined" && typeof globalThis.localStorage === "undefined") {
+  Object.defineProperty(globalThis, "localStorage", {
+    value: _noopStorage,
+    writable: true
+  });
+}
+if (typeof global !== "undefined" && !("localStorage" in global)) {
+  Object.defineProperty(global, "localStorage", {
+    value: _noopStorage,
+    writable: true
+  });
+}
+if (typeof window !== "undefined" && typeof document !== "undefined") {
+  if (typeof CSSStyleDeclaration !== "undefined" && CSSStyleDeclaration.prototype) {
+    for (var i = 0; i <= 64; i++) {
+      var key3 = String(i);
+      var desc = Object.getOwnPropertyDescriptor(CSSStyleDeclaration.prototype, key3);
+      if (!desc || desc.set == null) {
+        Object.defineProperty(CSSStyleDeclaration.prototype, key3, {
+          configurable: true,
+          enumerable: false,
+          get() {
+            return "";
+          },
+          set() {}
+        });
+      }
+    }
+  }
+  if (typeof NodeList !== "undefined" && NodeList.prototype) {
+    if (!NodeList.prototype.forEach) {
+      NodeList.prototype.forEach = Array.prototype.forEach;
+    }
+  }
+  if (typeof HTMLCollection !== "undefined" && HTMLCollection.prototype) {
+    if (!HTMLCollection.prototype.forEach) {
+      HTMLCollection.prototype.forEach = Array.prototype.forEach;
+    }
+  }
+  var matchesImpl = function matchesImpl2(selector) {
+    if (!this || _type_of(this) !== "object") return false;
+    if (this.nodeType === 1) {
+      if (this.webkitMatchesSelector) return this.webkitMatchesSelector(selector);
+      if (this.mozMatchesSelector) return this.mozMatchesSelector(selector);
+      if (this.msMatchesSelector) return this.msMatchesSelector(selector);
+      var matches = (this.ownerDocument || document).querySelectorAll(selector);
+      var i = matches.length;
+      while (--i >= 0 && matches[i] !== this) {}
+      return i > -1;
+    }
+    return false;
+  };
+  if (Element.prototype && !Element.prototype.matches) {
+    Object.defineProperty(Element.prototype, "matches", {
+      value: matchesImpl,
+      writable: true,
+      configurable: true,
+      enumerable: false
+    });
+  }
+  if (typeof HTMLElement !== "undefined" && HTMLElement.prototype && !HTMLElement.prototype.matches) {
+    Object.defineProperty(HTMLElement.prototype, "matches", {
+      value: matchesImpl,
+      writable: true,
+      configurable: true,
+      enumerable: false
+    });
+  }
+  var hasAttributeImpl = function hasAttributeImpl2(name) {
+    if (!this || this.nodeType !== 1) return false;
+    if (Element.prototype.hasAttribute && _instanceof(this, Element)) {
+      return Element.prototype.hasAttribute.call(this, name);
+    }
+    if (this.attributes) {
+      for (var i = 0; i < this.attributes.length; i++) {
+        if (this.attributes[i].name === name) return true;
+      }
+    }
+    return false;
+  };
+  var getAttributeImpl = function getAttributeImpl2(name) {
+    if (!this || this.nodeType !== 1) return null;
+    if (Element.prototype.getAttribute && _instanceof(this, Element)) {
+      return Element.prototype.getAttribute.call(this, name);
+    }
+    if (this.attributes) {
+      for (var i = 0; i < this.attributes.length; i++) {
+        if (this.attributes[i].name === name) return this.attributes[i].value;
+      }
+    }
+    return null;
+  };
+  var nodeTypes = [typeof Node !== "undefined" && Node, typeof Element !== "undefined" && Element, typeof HTMLElement !== "undefined" && HTMLElement, typeof HTMLDivElement !== "undefined" && HTMLDivElement, typeof HTMLSpanElement !== "undefined" && HTMLSpanElement, typeof HTMLInputElement !== "undefined" && HTMLInputElement, typeof HTMLButtonElement !== "undefined" && HTMLButtonElement, typeof HTMLFormElement !== "undefined" && HTMLFormElement, typeof HTMLLabelElement !== "undefined" && HTMLLabelElement, typeof Text !== "undefined" && Text, typeof Comment !== "undefined" && Comment, typeof Document !== "undefined" && Document, typeof DocumentFragment !== "undefined" && DocumentFragment].filter(Boolean);
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = nodeTypes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var NodeType = _step.value;
+      if (NodeType === null || NodeType === void 0 ? void 0 : NodeType.prototype) {
+        if (!NodeType.prototype.hasAttribute) {
+          Object.defineProperty(NodeType.prototype, "hasAttribute", {
+            value: hasAttributeImpl,
+            writable: true,
+            configurable: true,
+            enumerable: false
+          });
+        }
+        if (!NodeType.prototype.getAttribute) {
+          Object.defineProperty(NodeType.prototype, "getAttribute", {
+            value: getAttributeImpl,
+            writable: true,
+            configurable: true,
+            enumerable: false
+          });
+        }
+        if (!NodeType.prototype.setAttribute) {
+          Object.defineProperty(NodeType.prototype, "setAttribute", {
+            value: function value(name, value) {
+              if (this.nodeType === 1 && Element.prototype.setAttribute) {
+                Element.prototype.setAttribute.call(this, name, value);
+              }
+            },
+            writable: true,
+            configurable: true,
+            enumerable: false
+          });
+        }
+      }
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  if (typeof HTMLFormElement !== "undefined") {
+    Object.defineProperty(HTMLFormElement.prototype, "requestSubmit", {
+      value: function value(submitter) {
+        if (submitter) {
+          if (submitter.type !== "submit") {
+            throw new TypeError("The specified element is not a submit button");
+          }
+          if (submitter.form !== this) {
+            throw new DOMException("The specified element is not owned by this form element", "NotFoundError");
+          }
+        }
+        var submitEvent = new Event("submit", {
+          bubbles: true,
+          cancelable: true
+        });
+        this.dispatchEvent(submitEvent);
+      },
+      writable: true,
+      configurable: true,
+      enumerable: false
+    });
+  }
+}
+var floatingUiPatched = import("@floating-ui/react/utils").then(function (floatingUiUtils) {
+  if (floatingUiUtils === null || floatingUiUtils === void 0 ? void 0 : floatingUiUtils.enableFocusInside) {
+    var originalEnableFocusInside = floatingUiUtils.enableFocusInside;
+    floatingUiUtils.enableFocusInside = function (container) {
+      if (!container || !container.querySelectorAll) return;
+      var elements = container.querySelectorAll("[data-tabindex]");
+      if (!elements.forEach) {
+        elements.forEach = Array.prototype.forEach;
+      }
+      return originalEnableFocusInside(container);
+    };
+  }
+}).catch(function () {});
+(0, import_vitest.beforeAll)(function () {
+  return floatingUiPatched;
+});
+(0, import_tamagui.createTamagui)(import_config.config);
+var noopStorage = {
+  getItem: function getItem2() {
+    return null;
+  },
+  setItem: function setItem2() {},
+  removeItem: function removeItem2() {},
+  clear: function clear2() {},
+  get length() {
+    return 0;
+  },
+  key: function key2() {
+    return null;
+  }
+};
+import_vitest.vi.stubGlobal("localStorage", noopStorage);
+Object.defineProperty(globalThis, "localStorage", {
+  value: noopStorage,
+  writable: true
+});
+if (typeof global !== "undefined") {
+  Object.defineProperty(global, "localStorage", {
+    value: noopStorage,
+    writable: true
+  });
+}
+if (typeof globalThis !== "undefined" && typeof globalThis.BroadcastChannel === "undefined") {
+  globalThis.BroadcastChannel = /* @__PURE__ */function () {
+    "use strict";
+
+    function BroadcastChannelMock(name) {
+      _class_call_check(this, BroadcastChannelMock);
+      _define_property(this, "name", void 0);
+      _define_property(this, "onmessage", null);
+      this.name = name;
+    }
+    _create_class(BroadcastChannelMock, [{
+      key: "postMessage",
+      value: function postMessage(_message) {}
+    }, {
+      key: "close",
+      value: function close() {}
+    }]);
+    return BroadcastChannelMock;
+  }();
+}
+if (typeof window !== "undefined" && !window.indexedDB) {
+  Object.defineProperty(window, "indexedDB", {
+    value: {
+      open: function open() {
+        return {
+          onsuccess: null,
+          onerror: null,
+          onupgradeneeded: null,
+          result: null
+        };
+      },
+      deleteDatabase: function deleteDatabase() {
+        return {
+          onsuccess: null,
+          onerror: null
+        };
+      }
+    },
+    writable: true
+  });
+}
+import_vitest.vi.stubGlobal("fetch", import_vitest.vi.fn(function () {
+  return Promise.resolve(new Response(JSON.stringify({
+    data: []
+  }), {
+    status: 200,
+    headers: {
+      "Content-Type": "application/json"
+    }
+  }));
+}));
+window.matchMedia = window.matchMedia || function () {
+  return {
+    matches: false,
+    addListener: function addListener() {},
+    removeListener: function removeListener() {}
+  };
+};
+var animationFrames = (0, import_frames.createAnimationFrames)();
+global.requestAnimationFrame = animationFrames.request;
+global.cancelAnimationFrame = animationFrames.cancel;
+(0, import_vitest.afterAll)(animationFrames.close);
+var MockResizeObserver = /* @__PURE__ */function () {
+  "use strict";
+
+  function MockResizeObserver2() {
+    _class_call_check(this, MockResizeObserver2);
+  }
+  _create_class(MockResizeObserver2, [{
+    key: "observe",
+    value: function observe() {}
+  }, {
+    key: "unobserve",
+    value: function unobserve() {}
+  }, {
+    key: "disconnect",
+    value: function disconnect() {}
+  }]);
+  return MockResizeObserver2;
+}();
+window.ResizeObserver = MockResizeObserver;
+var MockIntersectionObserver = /* @__PURE__ */function () {
+  "use strict";
+
+  function MockIntersectionObserver2() {
+    _class_call_check(this, MockIntersectionObserver2);
+    _define_property(this, "root", null);
+    _define_property(this, "rootMargin", "0px");
+    _define_property(this, "scrollMargin", "0px");
+    _define_property(this, "thresholds", [0]);
+  }
+  _create_class(MockIntersectionObserver2, [{
+    key: "observe",
+    value: function observe() {}
+  }, {
+    key: "unobserve",
+    value: function unobserve() {}
+  }, {
+    key: "disconnect",
+    value: function disconnect() {}
+  }, {
+    key: "takeRecords",
+    value: function takeRecords() {
+      return [];
+    }
+  }]);
+  return MockIntersectionObserver2;
+}();
+if (typeof window !== "undefined") {
+  Object.defineProperty(window, "IntersectionObserver", {
+    value: MockIntersectionObserver,
+    writable: true,
+    configurable: true
+  });
+}
+Object.defineProperty(globalThis, "IntersectionObserver", {
+  value: MockIntersectionObserver,
+  writable: true,
+  configurable: true
+});
+if (typeof global !== "undefined") {
+  Object.defineProperty(global, "IntersectionObserver", {
+    value: MockIntersectionObserver,
+    writable: true,
+    configurable: true
+  });
+}
+if (typeof self !== "undefined") {
+  Object.defineProperty(self, "IntersectionObserver", {
+    value: MockIntersectionObserver,
+    writable: true,
+    configurable: true
+  });
+}
+if (typeof DataTransfer === "undefined") {
+  global.DataTransfer = /* @__PURE__ */function () {
+    "use strict";
+
+    function DataTransfer1() {
+      _class_call_check(this, DataTransfer1);
+      _define_property(this, "data", void 0);
+      this.data = /* @__PURE__ */new Map();
+    }
+    _create_class(DataTransfer1, [{
+      key: "getData",
+      value: function getData(format) {
+        return this.data.get(format) || "";
+      }
+    }, {
+      key: "setData",
+      value: function setData(format, data) {
+        this.data.set(format, data);
+      }
+    }, {
+      key: "clearData",
+      value: function clearData(format) {
+        if (format) {
+          this.data.delete(format);
+        } else {
+          this.data.clear();
+        }
+      }
+    }]);
+    return DataTransfer1;
+  }();
+}
+if (typeof ClipboardEvent === "undefined") {
+  global.ClipboardEvent = /* @__PURE__ */function (Event1) {
+    "use strict";
+
+    _inherits(ClipboardEvent1, Event1);
+    function ClipboardEvent1(type, options) {
+      _class_call_check(this, ClipboardEvent1);
+      var _this;
+      _this = _call_super(this, ClipboardEvent1, [type, options]), _define_property(_this, "clipboardData", void 0);
+      _this.clipboardData = (options === null || options === void 0 ? void 0 : options.clipboardData) || {
+        getData: function getData() {
+          return "";
+        },
+        setData: function setData() {}
+      };
+      return _this;
+    }
+    return ClipboardEvent1;
+  }(_wrap_native_super(Event));
+}
+var ESBuildAndJSDOMCompatibleTextEncoder = /* @__PURE__ */function (TextEncoder1) {
+  "use strict";
+
+  _inherits(ESBuildAndJSDOMCompatibleTextEncoder2, TextEncoder1);
+  function ESBuildAndJSDOMCompatibleTextEncoder2() {
+    _class_call_check(this, ESBuildAndJSDOMCompatibleTextEncoder2);
+    return _call_super(this, ESBuildAndJSDOMCompatibleTextEncoder2, arguments);
+  }
+  _create_class(ESBuildAndJSDOMCompatibleTextEncoder2, [{
+    key: "encode",
+    value: function encode(input) {
+      if (typeof input !== "string") throw new TypeError("`input` must be a string");
+      var decodedURI = decodeURIComponent(encodeURIComponent(input));
+      var arr = new Uint8Array(decodedURI.length);
+      var chars = decodedURI.split("");
+      for (var i = 0; i < chars.length; i++) {
+        arr[i] = (decodedURI[i] || "").charCodeAt(0);
+      }
+      return arr;
+    }
+  }]);
+  return ESBuildAndJSDOMCompatibleTextEncoder2;
+}(_wrap_native_super(TextEncoder));
+Object.defineProperty(global, "TextEncoder", {
+  value: ESBuildAndJSDOMCompatibleTextEncoder,
+  writable: true
+});
+import_vitest.vi.mock("@multiplatform.one/theme", async function (importOriginal) {
+  var actual = await importOriginal();
+  var getSizeClass = actual.getLayoutSizeClass;
+  var getPaneBudget = actual.defaultMaxPanes;
+  var fallbackWidth = actual.layoutBreakpoints.medium;
+  var viewportWidth = function viewportWidth2() {
+    return typeof window === "undefined" ? fallbackWidth : window.innerWidth;
+  };
+  return {
+    ...actual,
+    // Real useLayoutSizeClass subscribes via matchMedia().addEventListener,
+    // which test matchMedia polyfills / per-spec vi.fn mocks routinely lack;
+    // resolve from window.innerWidth at render (the same value the real hook
+    // computes at mount) through the real getLayoutSizeClass.
+    useLayoutSizeClass: function useLayoutSizeClass() {
+      return getSizeClass(viewportWidth());
+    },
+    // Rides useLayoutSizeClass (same matchMedia dependency); derive the pane
+    // budget through the real defaultMaxPanes.
+    useMultiPane: function useMultiPane(maxPanes) {
+      var budget = getPaneBudget(getSizeClass(viewportWidth()));
+      return (maxPanes !== null && maxPanes !== void 0 ? maxPanes : budget) >= 2 && budget >= 2;
+    },
+    // Real tracker installs document-level capture listeners backed by module
+    // state, leaking "last input was keyboard" across tests in a file; noop.
+    ensureKeyboardModalityTracking: function ensureKeyboardModalityTracking() {},
+    // Pin pointer modality so manual focus-ring painting is deterministic.
+    wasKeyboardFocus: function wasKeyboardFocus() {
+      return false;
+    }
+  };
+});
+import_vitest.vi.mock("one", function () {
+  return {
+    default: {},
+    SafeAreaView: function SafeAreaView(param) {
+      var {
+        children
+      } = param;
+      return children;
+    },
+    Head: function Head(param) {
+      var {
+        children
+      } = param;
+      return children;
+    },
+    useRouter: function useRouter() {
+      return {
+        push: import_vitest.vi.fn(),
+        replace: import_vitest.vi.fn(),
+        back: import_vitest.vi.fn()
+      };
+    }
+  };
+});
+import_vitest.vi.mock("@tamagui/animations-reanimated", function () {
+  return {
+    createAnimations: function createAnimations(config2) {
+      return {
+        ...config2,
+        View: void 0,
+        Text: void 0,
+        isReactNative: false,
+        animations: config2,
+        useAnimatedNumber: function useAnimatedNumber(initial) {
+          return {
+            value: initial,
+            setValue: function setValue() {}
+          };
+        },
+        useAnimatedNumberReaction: function useAnimatedNumberReaction() {},
+        useAnimatedNumberStyle: function useAnimatedNumberStyle() {
+          return {};
+        },
+        AnimatedView: function AnimatedView(param) {
+          var {
+            children
+          } = param;
+          return children;
+        },
+        AnimatedText: function AnimatedText(param) {
+          var {
+            children
+          } = param;
+          return children;
+        }
+      };
+    }
+  };
+});
+import_vitest.vi.mock("react-native-reanimated", function () {
+  return {
+    default: {
+      useSharedValue: function useSharedValue(init) {
+        return {
+          value: init
+        };
+      },
+      useAnimatedStyle: function useAnimatedStyle() {
+        return {};
+      },
+      withTiming: function withTiming(val) {
+        return val;
+      },
+      withSpring: function withSpring(val) {
+        return val;
+      },
+      withDecay: function withDecay(val) {
+        return val;
+      },
+      withSequence: function withSequence() {
+        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+        return args[args.length - 1];
+      },
+      withDelay: function withDelay(_, val) {
+        return val;
+      },
+      createAnimatedComponent: function createAnimatedComponent(component) {
+        return component;
+      },
+      useDerivedValue: function useDerivedValue(fn) {
+        return {
+          value: fn()
+        };
+      },
+      useAnimatedRef: function useAnimatedRef() {
+        return {
+          current: null
+        };
+      },
+      runOnJS: function runOnJS(fn) {
+        return fn;
+      },
+      runOnUI: function runOnUI(fn) {
+        return fn;
+      },
+      Extrapolation: {
+        CLAMP: "clamp"
+      },
+      Layout: {
+        duration: function duration() {
+          return {};
+        }
+      },
+      FadeIn: {
+        duration: function duration() {
+          return {};
+        }
+      },
+      FadeOut: {
+        duration: function duration() {
+          return {};
+        }
+      },
+      Easing: {
+        linear: function linear(v) {
+          return v;
+        },
+        ease: function ease(v) {
+          return v;
+        },
+        bezier: function bezier() {
+          return function (v) {
+            return v;
+          };
+        }
+      },
+      measure: function measure() {
+        return null;
+      },
+      scrollTo: function scrollTo() {},
+      makeMutable: function makeMutable(init) {
+        return {
+          value: init
+        };
+      }
+    },
+    useSharedValue: function useSharedValue(init) {
+      return {
+        value: init
+      };
+    },
+    useAnimatedStyle: function useAnimatedStyle() {
+      return {};
+    },
+    withTiming: function withTiming(val) {
+      return val;
+    },
+    withSpring: function withSpring(val) {
+      return val;
+    },
+    createAnimatedComponent: function createAnimatedComponent(component) {
+      return component;
+    },
+    runOnJS: function runOnJS(fn) {
+      return fn;
+    },
+    runOnUI: function runOnUI(fn) {
+      return fn;
+    },
+    useDerivedValue: function useDerivedValue(fn) {
+      return {
+        value: fn()
+      };
+    },
+    useAnimatedRef: function useAnimatedRef() {
+      return {
+        current: null
+      };
+    },
+    Easing: {
+      linear: function linear(v) {
+        return v;
+      },
+      ease: function ease(v) {
+        return v;
+      },
+      bezier: function bezier() {
+        return function (v) {
+          return v;
+        };
+      }
+    },
+    FadeIn: {
+      duration: function duration() {
+        return {};
+      }
+    },
+    FadeOut: {
+      duration: function duration() {
+        return {};
+      }
+    },
+    Layout: {
+      duration: function duration() {
+        return {};
+      }
+    }
+  };
+});
+import_vitest.vi.mock("@react-navigation/native", function () {
+  return {
+    NavigationContainer: function NavigationContainer(param) {
+      var {
+        children
+      } = param;
+      return children;
+    },
+    useNavigation: function useNavigation() {
+      return {};
+    },
+    useRoute: function useRoute() {
+      return {};
+    },
+    useFocusEffect: function useFocusEffect() {}
+  };
+});
+if (typeof document !== "undefined") {
+  var style = document.createElement("style");
+  style.textContent = "html { pointer-events: auto !important; }";
+  document.head.appendChild(style);
+}
+var ignoredTestWarnings = ["React does not recognize the `scaleIcon` prop on a DOM element", "React does not recognize the `pressTheme` prop on a DOM element", "React does not recognize the `marginLeft` prop on a DOM element", "Received `true` for a non-boolean attribute `editable`", "non-boolean attribute `editable`", "Received `true` for a non-boolean attribute `elevate`", "Received `true` for a non-boolean attribute `bordered`", "react-i18next:: useTranslation: You will need to pass in an i18next instance"];
+var originalConsoleWarn = console.warn.bind(console);
+var originalConsoleError = console.error.bind(console);
+var shouldIgnoreTestWarning = function shouldIgnoreTestWarning2(args) {
+  var message = args.map(function (arg) {
+    if (typeof arg === "string") return arg;
+    if (_instanceof(arg, Error)) return arg.message;
+    return String(arg);
+  }).join(" ");
+  if (ignoredTestWarnings.some(function (pattern) {
+    return message.includes(pattern);
+  })) {
+    return true;
+  }
+  var firstArg = typeof args[0] === "string" ? args[0] : "";
+  var hasNonBooleanTemplate = firstArg.includes("non-boolean attribute");
+  if (hasNonBooleanTemplate) {
+    var tokens = args.map(function (arg) {
+      return String(arg);
+    });
+    if (tokens.includes("editable") || tokens.includes("elevate") || tokens.includes("bordered")) {
+      return true;
+    }
+  }
+  return false;
+};
+var consoleWarnSpy = null;
+var consoleErrorSpy = null;
+(0, import_vitest.beforeEach)(function () {
+  Object.defineProperty(globalThis, "IntersectionObserver", {
+    value: MockIntersectionObserver,
+    writable: true,
+    configurable: true
+  });
+  if (typeof window !== "undefined") {
+    Object.defineProperty(window, "IntersectionObserver", {
+      value: MockIntersectionObserver,
+      writable: true,
+      configurable: true
+    });
+  }
+  if (typeof global !== "undefined") {
+    Object.defineProperty(global, "IntersectionObserver", {
+      value: MockIntersectionObserver,
+      writable: true,
+      configurable: true
+    });
+  }
+  consoleWarnSpy = import_vitest.vi.spyOn(console, "warn").mockImplementation(function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    if (shouldIgnoreTestWarning(args)) return;
+    originalConsoleWarn(...args);
+  });
+  consoleErrorSpy = import_vitest.vi.spyOn(console, "error").mockImplementation(function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    if (shouldIgnoreTestWarning(args)) return;
+    originalConsoleError(...args);
+  });
+});
+(0, import_vitest.afterEach)(function () {
+  Object.defineProperty(globalThis, "IntersectionObserver", {
+    value: MockIntersectionObserver,
+    writable: true,
+    configurable: true
+  });
+  if (typeof window !== "undefined") {
+    Object.defineProperty(window, "IntersectionObserver", {
+      value: MockIntersectionObserver,
+      writable: true,
+      configurable: true
+    });
+  }
+  consoleWarnSpy === null || consoleWarnSpy === void 0 ? void 0 : consoleWarnSpy.mockRestore();
+  consoleErrorSpy === null || consoleErrorSpy === void 0 ? void 0 : consoleErrorSpy.mockRestore();
+  consoleWarnSpy = null;
+  consoleErrorSpy = null;
+  (0, import_react.cleanup)();
+});
+//# sourceMappingURL=setup.native.js.map