@multiplatform.one/test-utils 7.83.1 → 7.83.2

package/dist/cjs/setup.cjs

@@ -0,0 +1,583 @@
+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 key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || 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.cjs");
+const _noopStorage = {
+  getItem: () => null,
+  setItem: () => {},
+  removeItem: () => {},
+  clear: () => {},
+  get length() {
+    return 0;
+  },
+  key: () => 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 (let i = 0; i <= 64; i++) {
+      const key = String(i);
+      const desc = Object.getOwnPropertyDescriptor(CSSStyleDeclaration.prototype, key);
+      if (!desc || desc.set == null) {
+        Object.defineProperty(CSSStyleDeclaration.prototype, key, {
+          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;
+    }
+  }
+  const matchesImpl = function (selector) {
+    if (!this || typeof 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);
+      const matches = (this.ownerDocument || document).querySelectorAll(selector);
+      let 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
+    });
+  }
+  const hasAttributeImpl = function (name) {
+    if (!this || this.nodeType !== 1) return false;
+    if (Element.prototype.hasAttribute && this instanceof Element) {
+      return Element.prototype.hasAttribute.call(this, name);
+    }
+    if (this.attributes) {
+      for (let i = 0; i < this.attributes.length; i++) {
+        if (this.attributes[i].name === name) return true;
+      }
+    }
+    return false;
+  };
+  const getAttributeImpl = function (name) {
+    if (!this || this.nodeType !== 1) return null;
+    if (Element.prototype.getAttribute && this instanceof Element) {
+      return Element.prototype.getAttribute.call(this, name);
+    }
+    if (this.attributes) {
+      for (let i = 0; i < this.attributes.length; i++) {
+        if (this.attributes[i].name === name) return this.attributes[i].value;
+      }
+    }
+    return null;
+  };
+  const 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);
+  for (const NodeType of nodeTypes) {
+    if (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 (name, value) {
+            if (this.nodeType === 1 && Element.prototype.setAttribute) {
+              Element.prototype.setAttribute.call(this, name, value);
+            }
+          },
+          writable: true,
+          configurable: true,
+          enumerable: false
+        });
+      }
+    }
+  }
+  if (typeof HTMLFormElement !== "undefined") {
+    Object.defineProperty(HTMLFormElement.prototype, "requestSubmit", {
+      value: function (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");
+          }
+        }
+        const submitEvent = new Event("submit", {
+          bubbles: true,
+          cancelable: true
+        });
+        this.dispatchEvent(submitEvent);
+      },
+      writable: true,
+      configurable: true,
+      enumerable: false
+    });
+  }
+}
+const floatingUiPatched = import("@floating-ui/react/utils").then(floatingUiUtils => {
+  if (floatingUiUtils?.enableFocusInside) {
+    const originalEnableFocusInside = floatingUiUtils.enableFocusInside;
+    floatingUiUtils.enableFocusInside = container => {
+      if (!container || !container.querySelectorAll) return;
+      const elements = container.querySelectorAll("[data-tabindex]");
+      if (!elements.forEach) {
+        elements.forEach = Array.prototype.forEach;
+      }
+      return originalEnableFocusInside(container);
+    };
+  }
+}).catch(() => {});
+(0, import_vitest.beforeAll)(() => floatingUiPatched);
+(0, import_tamagui.createTamagui)(import_config.config);
+const noopStorage = {
+  getItem: () => null,
+  setItem: () => {},
+  removeItem: () => {},
+  clear: () => {},
+  get length() {
+    return 0;
+  },
+  key: () => 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 = class BroadcastChannelMock {
+    name;
+    onmessage = null;
+    constructor(name) {
+      this.name = name;
+    }
+    postMessage(_message) {}
+    close() {}
+  };
+}
+if (typeof window !== "undefined" && !window.indexedDB) {
+  Object.defineProperty(window, "indexedDB", {
+    value: {
+      open: () => ({
+        onsuccess: null,
+        onerror: null,
+        onupgradeneeded: null,
+        result: null
+      }),
+      deleteDatabase: () => ({
+        onsuccess: null,
+        onerror: null
+      })
+    },
+    writable: true
+  });
+}
+import_vitest.vi.stubGlobal("fetch", import_vitest.vi.fn(() => Promise.resolve(new Response(JSON.stringify({
+  data: []
+}), {
+  status: 200,
+  headers: {
+    "Content-Type": "application/json"
+  }
+}))));
+window.matchMedia = window.matchMedia || (() => ({
+  matches: false,
+  addListener: () => {},
+  removeListener: () => {}
+}));
+const animationFrames = (0, import_frames.createAnimationFrames)();
+global.requestAnimationFrame = animationFrames.request;
+global.cancelAnimationFrame = animationFrames.cancel;
+(0, import_vitest.afterAll)(animationFrames.close);
+class MockResizeObserver {
+  observe() {}
+  unobserve() {}
+  disconnect() {}
+}
+window.ResizeObserver = MockResizeObserver;
+class MockIntersectionObserver {
+  root = null;
+  rootMargin = "0px";
+  // TS7's dom lib added scrollMargin to the interface.
+  scrollMargin = "0px";
+  thresholds = [0];
+  observe() {}
+  unobserve() {}
+  disconnect() {}
+  takeRecords() {
+    return [];
+  }
+}
+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 = class DataTransfer {
+    data;
+    constructor() {
+      this.data = /* @__PURE__ */new Map();
+    }
+    getData(format) {
+      return this.data.get(format) || "";
+    }
+    setData(format, data) {
+      this.data.set(format, data);
+    }
+    clearData(format) {
+      if (format) {
+        this.data.delete(format);
+      } else {
+        this.data.clear();
+      }
+    }
+  };
+}
+if (typeof ClipboardEvent === "undefined") {
+  global.ClipboardEvent = class ClipboardEvent extends Event {
+    clipboardData;
+    constructor(type, options) {
+      super(type, options);
+      this.clipboardData = options?.clipboardData || {
+        getData: () => "",
+        setData: () => {}
+      };
+    }
+  };
+}
+class ESBuildAndJSDOMCompatibleTextEncoder extends TextEncoder {
+  encode(input) {
+    if (typeof input !== "string") throw new TypeError("`input` must be a string");
+    const decodedURI = decodeURIComponent(encodeURIComponent(input));
+    const arr = new Uint8Array(decodedURI.length);
+    const chars = decodedURI.split("");
+    for (let i = 0; i < chars.length; i++) {
+      arr[i] = (decodedURI[i] || "").charCodeAt(0);
+    }
+    return arr;
+  }
+}
+Object.defineProperty(global, "TextEncoder", {
+  value: ESBuildAndJSDOMCompatibleTextEncoder,
+  writable: true
+});
+import_vitest.vi.mock("@multiplatform.one/theme", async importOriginal => {
+  const actual = await importOriginal();
+  const getSizeClass = actual.getLayoutSizeClass;
+  const getPaneBudget = actual.defaultMaxPanes;
+  const fallbackWidth = actual.layoutBreakpoints.medium;
+  const viewportWidth = () => 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: () => getSizeClass(viewportWidth()),
+    // Rides useLayoutSizeClass (same matchMedia dependency); derive the pane
+    // budget through the real defaultMaxPanes.
+    useMultiPane: maxPanes => {
+      const budget = getPaneBudget(getSizeClass(viewportWidth()));
+      return (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: () => {},
+    // Pin pointer modality so manual focus-ring painting is deterministic.
+    wasKeyboardFocus: () => false
+  };
+});
+import_vitest.vi.mock("one", () => ({
+  default: {},
+  SafeAreaView: ({
+    children
+  }) => children,
+  Head: ({
+    children
+  }) => children,
+  useRouter: () => ({
+    push: import_vitest.vi.fn(),
+    replace: import_vitest.vi.fn(),
+    back: import_vitest.vi.fn()
+  })
+}));
+import_vitest.vi.mock("@tamagui/animations-reanimated", () => ({
+  createAnimations: config2 => ({
+    ...config2,
+    View: void 0,
+    Text: void 0,
+    isReactNative: false,
+    animations: config2,
+    useAnimatedNumber: initial => ({
+      value: initial,
+      setValue: () => {}
+    }),
+    useAnimatedNumberReaction: () => {},
+    useAnimatedNumberStyle: () => ({}),
+    AnimatedView: ({
+      children
+    }) => children,
+    AnimatedText: ({
+      children
+    }) => children
+  })
+}));
+import_vitest.vi.mock("react-native-reanimated", () => ({
+  default: {
+    useSharedValue: init => ({
+      value: init
+    }),
+    useAnimatedStyle: () => ({}),
+    withTiming: val => val,
+    withSpring: val => val,
+    withDecay: val => val,
+    withSequence: (...args) => args[args.length - 1],
+    withDelay: (_, val) => val,
+    createAnimatedComponent: component => component,
+    useDerivedValue: fn => ({
+      value: fn()
+    }),
+    useAnimatedRef: () => ({
+      current: null
+    }),
+    runOnJS: fn => fn,
+    runOnUI: fn => fn,
+    Extrapolation: {
+      CLAMP: "clamp"
+    },
+    Layout: {
+      duration: () => ({})
+    },
+    FadeIn: {
+      duration: () => ({})
+    },
+    FadeOut: {
+      duration: () => ({})
+    },
+    Easing: {
+      linear: v => v,
+      ease: v => v,
+      bezier: () => v => v
+    },
+    measure: () => null,
+    scrollTo: () => {},
+    makeMutable: init => ({
+      value: init
+    })
+  },
+  useSharedValue: init => ({
+    value: init
+  }),
+  useAnimatedStyle: () => ({}),
+  withTiming: val => val,
+  withSpring: val => val,
+  createAnimatedComponent: component => component,
+  runOnJS: fn => fn,
+  runOnUI: fn => fn,
+  useDerivedValue: fn => ({
+    value: fn()
+  }),
+  useAnimatedRef: () => ({
+    current: null
+  }),
+  Easing: {
+    linear: v => v,
+    ease: v => v,
+    bezier: () => v => v
+  },
+  FadeIn: {
+    duration: () => ({})
+  },
+  FadeOut: {
+    duration: () => ({})
+  },
+  Layout: {
+    duration: () => ({})
+  }
+}));
+import_vitest.vi.mock("@react-navigation/native", () => ({
+  NavigationContainer: ({
+    children
+  }) => children,
+  useNavigation: () => ({}),
+  useRoute: () => ({}),
+  useFocusEffect: () => {}
+}));
+if (typeof document !== "undefined") {
+  const style = document.createElement("style");
+  style.textContent = "html { pointer-events: auto !important; }";
+  document.head.appendChild(style);
+}
+const 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"];
+const originalConsoleWarn = console.warn.bind(console);
+const originalConsoleError = console.error.bind(console);
+const shouldIgnoreTestWarning = args => {
+  const message = args.map(arg => {
+    if (typeof arg === "string") return arg;
+    if (arg instanceof Error) return arg.message;
+    return String(arg);
+  }).join(" ");
+  if (ignoredTestWarnings.some(pattern => message.includes(pattern))) {
+    return true;
+  }
+  const firstArg = typeof args[0] === "string" ? args[0] : "";
+  const hasNonBooleanTemplate = firstArg.includes("non-boolean attribute");
+  if (hasNonBooleanTemplate) {
+    const tokens = args.map(arg => String(arg));
+    if (tokens.includes("editable") || tokens.includes("elevate") || tokens.includes("bordered")) {
+      return true;
+    }
+  }
+  return false;
+};
+let consoleWarnSpy = null;
+let consoleErrorSpy = null;
+(0, import_vitest.beforeEach)(() => {
+  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((...args) => {
+    if (shouldIgnoreTestWarning(args)) return;
+    originalConsoleWarn(...args);
+  });
+  consoleErrorSpy = import_vitest.vi.spyOn(console, "error").mockImplementation((...args) => {
+    if (shouldIgnoreTestWarning(args)) return;
+    originalConsoleError(...args);
+  });
+});
+(0, import_vitest.afterEach)(() => {
+  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?.mockRestore();
+  consoleErrorSpy?.mockRestore();
+  consoleWarnSpy = null;
+  consoleErrorSpy = null;
+  (0, import_react.cleanup)();
+});