@tamagui/react-native-web-internals 1.116.1 → 1.116.3

package/dist/cjs/modules/useHover/__tests__/index-test.js

@@ -0,0 +1,195 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__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: !0 }) : target,
+  mod
+));
+var import_dom_event_testing_library = require("dom-event-testing-library"), React = __toESM(require("react")), ReactDOM = __toESM(require("react-dom")), import_test_utils = require("react-dom/test-utils"), import_modality = require("../../modality/index"), import__ = __toESM(require("..")), import_jsx_runtime = require("react/jsx-runtime");
+function createRoot(rootNode) {
+  return {
+    render(element) {
+      ReactDOM.render(element, rootNode);
+    }
+  };
+}
+(0, import_dom_event_testing_library.describeWithPointerEvent)("useHover", (hasPointerEvents) => {
+  let root, rootNode;
+  beforeEach(() => {
+    (0, import_dom_event_testing_library.setPointerEvent)(hasPointerEvents), rootNode = document.createElement("div"), document.body.appendChild(rootNode), root = createRoot(rootNode);
+  }), afterEach(() => {
+    root.render(null), document.body.removeChild(rootNode), rootNode = null, root = null, (0, import_modality.testOnly_resetActiveModality)(), (0, import_dom_event_testing_library.clearPointers)();
+  }), describe("contain", () => {
+    let onHoverChange, onHoverStart, onHoverUpdate, onHoverEnd, ref, childRef;
+    const componentInit = () => {
+      onHoverChange = jest.fn(), onHoverStart = jest.fn(), onHoverUpdate = jest.fn(), onHoverEnd = jest.fn(), ref = React.createRef(), childRef = React.createRef();
+      const Component = () => ((0, import__.default)(ref, {
+        onHoverChange,
+        onHoverStart,
+        onHoverUpdate,
+        onHoverEnd
+      }), (0, import__.default)(childRef, { contain: !0 }), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref: childRef }) }));
+      (0, import_test_utils.act)(() => {
+        root.render(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, {}));
+      });
+    };
+    test("contains the hover gesture", () => {
+      componentInit();
+      const target = (0, import_dom_event_testing_library.createEventTarget)(ref.current), child = (0, import_dom_event_testing_library.createEventTarget)(childRef.current);
+      (0, import_test_utils.act)(() => {
+        target.pointerover(), target.pointerout(), child.pointerover();
+      }), expect(onHoverEnd).toBeCalled(), (0, import_test_utils.act)(() => {
+        child.pointerout();
+      }), expect(onHoverStart).toBeCalled();
+    });
+  }), describe("disabled", () => {
+    let onHoverChange, onHoverStart, onHoverUpdate, onHoverEnd, ref;
+    const componentInit = () => {
+      onHoverChange = jest.fn(), onHoverStart = jest.fn(), onHoverUpdate = jest.fn(), onHoverEnd = jest.fn(), ref = React.createRef();
+      const Component = () => ((0, import__.default)(ref, {
+        disabled: !0,
+        onHoverChange,
+        onHoverStart,
+        onHoverUpdate,
+        onHoverEnd
+      }), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref }));
+      (0, import_test_utils.act)(() => {
+        root.render(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, {}));
+      });
+    };
+    test("does not call callbacks", () => {
+      componentInit();
+      const target = (0, import_dom_event_testing_library.createEventTarget)(ref.current);
+      (0, import_test_utils.act)(() => {
+        target.pointerover(), target.pointerout();
+      }), expect(onHoverChange).not.toBeCalled(), expect(onHoverStart).not.toBeCalled(), expect(onHoverUpdate).not.toBeCalled(), expect(onHoverEnd).not.toBeCalled();
+    });
+  }), describe("onHoverStart", () => {
+    let onHoverStart, ref;
+    const componentInit = () => {
+      onHoverStart = jest.fn(), ref = React.createRef();
+      const Component = () => ((0, import__.default)(ref, { onHoverStart }), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref }));
+      (0, import_test_utils.act)(() => {
+        root.render(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, {}));
+      });
+    };
+    test("is called for mouse pointers", () => {
+      componentInit();
+      const target = (0, import_dom_event_testing_library.createEventTarget)(ref.current);
+      (0, import_test_utils.act)(() => {
+        target.pointerover({ pointerType: "mouse" });
+      }), expect(onHoverStart).toBeCalledTimes(1);
+    }), test("is not called for touch pointers", () => {
+      componentInit();
+      const target = (0, import_dom_event_testing_library.createEventTarget)(ref.current);
+      (0, import_test_utils.act)(() => {
+        target.pointerdown({ pointerType: "touch" }), target.pointerup({ pointerType: "touch" });
+      }), expect(onHoverStart).not.toBeCalled();
+    }), test("is called if a mouse pointer is used after a touch pointer", () => {
+      componentInit();
+      const target = (0, import_dom_event_testing_library.createEventTarget)(ref.current);
+      (0, import_test_utils.act)(() => {
+        target.pointerdown({ pointerType: "touch" }), target.pointerup({ pointerType: "touch" }), target.pointerover({ pointerType: "mouse" });
+      }), expect(onHoverStart).toBeCalledTimes(1);
+    });
+  }), describe("onHoverChange", () => {
+    let onHoverChange, ref;
+    const componentInit = () => {
+      onHoverChange = jest.fn(), ref = React.createRef();
+      const Component = () => ((0, import__.default)(ref, { onHoverChange }), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref }));
+      (0, import_test_utils.act)(() => {
+        root.render(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, {}));
+      });
+    };
+    test("is called for mouse pointers", () => {
+      componentInit();
+      const target = (0, import_dom_event_testing_library.createEventTarget)(ref.current);
+      (0, import_test_utils.act)(() => {
+        target.pointerover();
+      }), expect(onHoverChange).toBeCalledTimes(1), expect(onHoverChange).toBeCalledWith(!0), (0, import_test_utils.act)(() => {
+        target.pointerout();
+      }), expect(onHoverChange).toBeCalledTimes(2), expect(onHoverChange).toBeCalledWith(!1);
+    }), test("is not called for touch pointers", () => {
+      componentInit();
+      const target = (0, import_dom_event_testing_library.createEventTarget)(ref.current);
+      (0, import_test_utils.act)(() => {
+        target.pointerdown({ pointerType: "touch" }), target.pointerup({ pointerType: "touch" });
+      }), expect(onHoverChange).not.toBeCalled();
+    });
+  }), describe("onHoverEnd", () => {
+    let onHoverEnd, ref, childRef;
+    const componentInit = () => {
+      onHoverEnd = jest.fn(), ref = React.createRef(), childRef = React.createRef();
+      const Component = () => ((0, import__.default)(ref, { onHoverEnd }), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref: childRef }) }));
+      (0, import_test_utils.act)(() => {
+        root.render(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, {}));
+      });
+    };
+    test("is called for mouse pointers", () => {
+      componentInit();
+      const target = (0, import_dom_event_testing_library.createEventTarget)(ref.current);
+      (0, import_test_utils.act)(() => {
+        target.pointerover(), target.pointerout();
+      }), expect(onHoverEnd).toBeCalledTimes(1);
+    }), test("is not called for touch pointers", () => {
+      componentInit();
+      const target = (0, import_dom_event_testing_library.createEventTarget)(ref.current);
+      (0, import_test_utils.act)(() => {
+        target.pointerdown({ pointerType: "touch" }), target.pointerup({ pointerType: "touch" });
+      }), expect(onHoverEnd).not.toBeCalled();
+    }), test("is not called when entering children of the target", () => {
+      componentInit();
+      const target = (0, import_dom_event_testing_library.createEventTarget)(ref.current), child = (0, import_dom_event_testing_library.createEventTarget)(childRef.current);
+      (0, import_test_utils.act)(() => {
+        target.pointerover(), target.pointerout({ relatedTarget: childRef.current }), child.pointerover({ relatedTarget: target.node });
+      }), expect(onHoverEnd).not.toBeCalled();
+    });
+  }), describe("onHoverUpdate", () => {
+    test('is called after the active pointer moves"', () => {
+      const onHoverUpdate = jest.fn(), ref = React.createRef(), Component = () => ((0, import__.default)(ref, { onHoverUpdate }), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref }));
+      (0, import_test_utils.act)(() => {
+        root.render(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, {}));
+      });
+      const target = (0, import_dom_event_testing_library.createEventTarget)(ref.current);
+      (0, import_test_utils.act)(() => {
+        target.pointerover(), target.pointerhover({ x: 0, y: 0 }), target.pointerhover({ x: 1, y: 1 });
+      }), expect(onHoverUpdate).toBeCalledTimes(2);
+    });
+  }), describe("repeat use", () => {
+    let onHoverChange, onHoverStart, onHoverUpdate, onHoverEnd, ref;
+    const componentInit = () => {
+      onHoverChange = jest.fn(), onHoverStart = jest.fn(), onHoverUpdate = jest.fn(), onHoverEnd = jest.fn(), ref = React.createRef();
+      const Component = () => ((0, import__.default)(ref, {
+        onHoverChange,
+        onHoverStart,
+        onHoverUpdate,
+        onHoverEnd
+      }), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref }));
+      (0, import_test_utils.act)(() => {
+        root.render(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, {}));
+      });
+    };
+    test("callbacks are called each time", () => {
+      componentInit();
+      const target = (0, import_dom_event_testing_library.createEventTarget)(ref.current);
+      (0, import_test_utils.act)(() => {
+        target.pointerover(), target.pointerhover({ x: 1, y: 1 }), target.pointerout();
+      }), expect(onHoverStart).toBeCalledTimes(1), expect(onHoverUpdate).toBeCalledTimes(1), expect(onHoverEnd).toBeCalledTimes(1), expect(onHoverChange).toBeCalledTimes(2), (0, import_test_utils.act)(() => {
+        target.pointerover(), target.pointerhover({ x: 1, y: 1 }), target.pointerout();
+      }), expect(onHoverStart).toBeCalledTimes(2), expect(onHoverUpdate).toBeCalledTimes(2), expect(onHoverEnd).toBeCalledTimes(2), expect(onHoverChange).toBeCalledTimes(4);
+    });
+  });
+});
+//# sourceMappingURL=index-test.js.map

package/dist/cjs/modules/useHover/index.js

@@ -0,0 +1,81 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__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: !0 }) : target,
+  mod
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var useHover_exports = {};
+__export(useHover_exports, {
+  default: () => useHover
+});
+module.exports = __toCommonJS(useHover_exports);
+var import_modality = require("../modality/index"), import_useEvent = __toESM(require("../useEvent/index")), import_useLayoutEffect = __toESM(require("../useLayoutEffect/index"));
+const emptyObject = {}, opts = { passive: !0 }, lockEventType = "react-gui:hover:lock", unlockEventType = "react-gui:hover:unlock", supportsPointerEvent = () => typeof window < "u" && window.PointerEvent != null;
+function dispatchCustomEvent(target, type, payload) {
+  const event = document.createEvent("CustomEvent"), { bubbles = !0, cancelable = !0, detail } = payload || emptyObject;
+  event.initCustomEvent(type, bubbles, cancelable, detail), target.dispatchEvent(event);
+}
+function getPointerType(event) {
+  const { pointerType } = event;
+  return pointerType ?? (0, import_modality.getModality)();
+}
+function useHover(targetRef, config) {
+  const { contain, disabled, onHoverStart, onHoverChange, onHoverUpdate, onHoverEnd } = config, canUsePE = supportsPointerEvent(), addMoveListener = (0, import_useEvent.default)(canUsePE ? "pointermove" : "mousemove", opts), addEnterListener = (0, import_useEvent.default)(canUsePE ? "pointerenter" : "mouseenter", opts), addLeaveListener = (0, import_useEvent.default)(canUsePE ? "pointerleave" : "mouseleave", opts), addLockListener = (0, import_useEvent.default)(lockEventType, opts), addUnlockListener = (0, import_useEvent.default)(unlockEventType, opts);
+  (0, import_useLayoutEffect.default)(() => {
+    const target = targetRef.current;
+    if (target !== null) {
+      const hoverEnd = function(e) {
+        onHoverEnd?.(e), onHoverChange?.(!1), addMoveListener(target, null), addLeaveListener(target, null);
+      }, leaveListener = function(e) {
+        const target2 = targetRef.current;
+        target2 != null && getPointerType(e) !== "touch" && (contain && dispatchCustomEvent(target2, unlockEventType), hoverEnd(e));
+      }, moveListener = function(e) {
+        getPointerType(e) !== "touch" && onHoverUpdate != null && (e.x == null && (e.x = e.clientX), e.y == null && (e.y = e.clientY), onHoverUpdate(e));
+      }, hoverStart = function(e) {
+        onHoverStart?.(e), onHoverChange?.(!0), onHoverUpdate != null && addMoveListener(target, disabled ? null : moveListener), addLeaveListener(target, disabled ? null : leaveListener);
+      };
+      addEnterListener(target, disabled ? null : function(e) {
+        const target2 = targetRef.current;
+        if (target2 != null && getPointerType(e) !== "touch") {
+          contain && dispatchCustomEvent(target2, lockEventType), hoverStart(e);
+          const lockListener = function(lockEvent) {
+            lockEvent.target !== target2 && hoverEnd(e);
+          }, unlockListener = function(lockEvent) {
+            lockEvent.target !== target2 && hoverStart(e);
+          };
+          addLockListener(target2, disabled ? null : lockListener), addUnlockListener(target2, disabled ? null : unlockListener);
+        }
+      });
+    }
+  }, [
+    addEnterListener,
+    addMoveListener,
+    addLeaveListener,
+    addLockListener,
+    addUnlockListener,
+    contain,
+    disabled,
+    onHoverStart,
+    onHoverChange,
+    onHoverUpdate,
+    onHoverEnd,
+    targetRef
+  ]);
+}
+//# sourceMappingURL=index.js.map

package/dist/cjs/modules/useLayoutEffect/index.js

@@ -0,0 +1,31 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__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: !0 }) : target,
+  mod
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var useLayoutEffect_exports = {};
+__export(useLayoutEffect_exports, {
+  default: () => useLayoutEffect_default
+});
+module.exports = __toCommonJS(useLayoutEffect_exports);
+var import_react = __toESM(require("react")), import_canUseDOM = __toESM(require("../canUseDOM"));
+const useLayoutEffectImpl = import_canUseDOM.default ? import_react.default.useLayoutEffect : import_react.default.useEffect;
+var useLayoutEffect_default = useLayoutEffectImpl;
+//# sourceMappingURL=index.js.map

package/dist/cjs/modules/useLocale/index.js

@@ -0,0 +1,54 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__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: !0 }) : target,
+  mod
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var useLocale_exports = {};
+__export(useLocale_exports, {
+  LocaleProvider: () => LocaleProvider,
+  getLocaleDirection: () => getLocaleDirection,
+  useLocaleContext: () => useLocaleContext
+});
+module.exports = __toCommonJS(useLocale_exports);
+var import_react = __toESM(require("react")), import_isLocaleRTL = require("./isLocaleRTL"), import_jsx_runtime = require("react/jsx-runtime");
+const defaultLocale = {
+  direction: "ltr",
+  locale: "en-US"
+}, LocaleContext = import_react.default.createContext(defaultLocale);
+function getLocaleDirection(locale) {
+  return (0, import_isLocaleRTL.isLocaleRTL)(locale) ? "rtl" : "ltr";
+}
+function LocaleProvider(props) {
+  const { direction, locale, children } = props;
+  return direction || locale ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    LocaleContext.Provider,
+    {
+      value: {
+        direction: locale ? getLocaleDirection(locale) : direction,
+        locale
+      },
+      children
+    }
+  ) : children;
+}
+function useLocaleContext() {
+  return import_react.default.useContext(LocaleContext);
+}
+//# sourceMappingURL=index.js.map

package/dist/cjs/modules/useLocale/isLocaleRTL.js

@@ -0,0 +1,91 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var isLocaleRTL_exports = {};
+__export(isLocaleRTL_exports, {
+  isLocaleRTL: () => isLocaleRTL
+});
+module.exports = __toCommonJS(isLocaleRTL_exports);
+const rtlScripts = /* @__PURE__ */ new Set([
+  "Arab",
+  "Syrc",
+  "Samr",
+  "Mand",
+  "Thaa",
+  "Mend",
+  "Nkoo",
+  "Adlm",
+  "Rohg",
+  "Hebr"
+]), rtlLangs = /* @__PURE__ */ new Set([
+  "ae",
+  // Avestan
+  "ar",
+  // Arabic
+  "arc",
+  // Aramaic
+  "bcc",
+  // Southern Balochi
+  "bqi",
+  // Bakthiari
+  "ckb",
+  // Sorani
+  "dv",
+  // Dhivehi
+  "fa",
+  "far",
+  // Persian
+  "glk",
+  // Gilaki
+  "he",
+  "iw",
+  // Hebrew
+  "khw",
+  // Khowar
+  "ks",
+  // Kashmiri
+  "ku",
+  // Kurdish
+  "mzn",
+  // Mazanderani
+  "nqo",
+  // N'Ko
+  "pnb",
+  // Western Punjabi
+  "ps",
+  // Pashto
+  "sd",
+  // Sindhi
+  "ug",
+  // Uyghur
+  "ur",
+  // Urdu
+  "yi"
+  // Yiddish
+]), cache = /* @__PURE__ */ new Map();
+function isLocaleRTL(locale) {
+  const cachedRTL = cache.get(locale);
+  if (cachedRTL)
+    return cachedRTL;
+  let isRTL = !1;
+  if (Intl.Locale) {
+    const script = new Intl.Locale(locale).maximize().script;
+    isRTL = rtlScripts.has(script);
+  } else {
+    const lang = locale.split("-")[0];
+    isRTL = rtlLangs.has(lang);
+  }
+  return cache.set(locale, isRTL), isRTL;
+}
+//# sourceMappingURL=isLocaleRTL.js.map

package/dist/cjs/modules/useMergeRefs/__tests__/index-test.js

@@ -0,0 +1,68 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__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: !0 }) : target,
+  mod
+));
+var import_react = require("@testing-library/react"), React = __toESM(require("react")), import_test_utils = require("react-dom/test-utils"), import__ = __toESM(require("..")), import_jsx_runtime = require("react/jsx-runtime");
+describe("modules/useMergeRefs/index.js", () => {
+  function TestComponent({ refs, ...rest }) {
+    const mergedRef = (0, import__.default)(...refs);
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref: mergedRef, ...rest });
+  }
+  afterEach(import_react.cleanup), test("handles no refs", () => {
+    (0, import_test_utils.act)(() => {
+      (0, import_react.render)(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(TestComponent, { refs: [] }));
+    });
+  }), test("merges any number of varying refs", () => {
+    const callbackRef1 = jest.fn(), callbackRef2 = jest.fn(), objectRef1 = React.createRef(), objectRef2 = React.createRef(), nullRef = null;
+    (0, import_test_utils.act)(() => {
+      (0, import_react.render)(
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+          TestComponent,
+          {
+            refs: [callbackRef1, callbackRef2, objectRef1, objectRef2, nullRef]
+          }
+        )
+      );
+    }), expect(callbackRef1).toHaveBeenCalledTimes(1), expect(callbackRef2).toHaveBeenCalledTimes(1), expect(objectRef1.current).toBeInstanceOf(HTMLDivElement), expect(objectRef2.current).toBeInstanceOf(HTMLDivElement);
+  }), test("ref is called when ref changes", () => {
+    const ref = jest.fn(), nextRef = jest.fn();
+    let rerender;
+    (0, import_test_utils.act)(() => {
+      ({ rerender } = (0, import_react.render)(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(TestComponent, { refs: [ref] })));
+    }), expect(ref).toHaveBeenCalled(), (0, import_test_utils.act)(() => {
+      rerender(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(TestComponent, { refs: [nextRef] }));
+    }), expect(nextRef).toHaveBeenCalled();
+  }), test("ref is not called for each rerender", () => {
+    const ref = jest.fn();
+    let rerender;
+    (0, import_test_utils.act)(() => {
+      ({ rerender } = (0, import_react.render)(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(TestComponent, { refs: [ref] })));
+    }), expect(ref).toHaveBeenCalledTimes(1), (0, import_test_utils.act)(() => {
+      rerender(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(TestComponent, { refs: [ref] }));
+    }), expect(ref).toHaveBeenCalledTimes(1);
+  }), test("ref is not called for props changes", () => {
+    const ref = jest.fn();
+    let rerender;
+    (0, import_test_utils.act)(() => {
+      ({ rerender } = (0, import_react.render)(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(TestComponent, { id: "foo", refs: [ref] })));
+    }), expect(ref).toHaveBeenCalledTimes(1), (0, import_test_utils.act)(() => {
+      rerender(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(TestComponent, { id: "bar", refs: [ref] }));
+    }), expect(ref).toHaveBeenCalledTimes(1);
+  });
+});
+//# sourceMappingURL=index-test.js.map

package/dist/cjs/modules/useMergeRefs/index.js

@@ -0,0 +1,36 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__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: !0 }) : target,
+  mod
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var useMergeRefs_exports = {};
+__export(useMergeRefs_exports, {
+  useMergeRefs: () => useMergeRefs
+});
+module.exports = __toCommonJS(useMergeRefs_exports);
+var React = __toESM(require("react")), import_mergeRefs = require("../mergeRefs/index");
+function useMergeRefs(...args) {
+  return React.useMemo(
+    () => (0, import_mergeRefs.mergeRefs)(...args),
+    // eslint-disable-next-line
+    [...args]
+  );
+}
+//# sourceMappingURL=index.js.map

package/dist/cjs/modules/usePlatformMethods/index.js

@@ -0,0 +1,39 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__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: !0 }) : target,
+  mod
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var usePlatformMethods_exports = {};
+__export(usePlatformMethods_exports, {
+  default: () => usePlatformMethods_default,
+  usePlatformMethods: () => usePlatformMethods
+});
+module.exports = __toCommonJS(usePlatformMethods_exports);
+var import_UIManager = __toESM(require("../UIManager/index")), import_useStable = __toESM(require("../useStable/index"));
+function usePlatformMethods({
+  pointerEvents,
+  style
+}) {
+  return (0, import_useStable.default)(() => (hostNode) => {
+    hostNode != null && (hostNode.measure = (callback) => import_UIManager.default.measure(hostNode, callback), hostNode.measureLayout = (relativeToNode, success, failure) => import_UIManager.default.measureLayout(hostNode, relativeToNode, failure, success), hostNode.measureInWindow = (callback) => import_UIManager.default.measureInWindow(hostNode, callback));
+  });
+}
+var usePlatformMethods_default = usePlatformMethods;
+//# sourceMappingURL=index.js.map