@hanzogui/react-native-web-internals 2.0.0

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

@@ -0,0 +1,273 @@
+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"), 1),
+  ReactDOM = __toESM(require("react-dom"), 1),
+  import_test_utils = require("react-dom/test-utils"),
+  import_modality = require("../../modality/index.cjs"),
+  import__ = __toESM(require("../index.cjs"), 1),
+  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);
+    });
+  });
+});

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

@@ -0,0 +1,97 @@
+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 useHover_exports = {};
+__export(useHover_exports, {
+  useHover: () => useHover
+});
+module.exports = __toCommonJS(useHover_exports);
+var import_modality = require("../modality/index.cjs"),
+  import_useEvent = require("../useEvent/index.cjs"),
+  import_useLayoutEffect = require("../useLayoutEffect/index.cjs");
+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.useEvent)(canUsePE ? "pointermove" : "mousemove", opts),
+    addEnterListener = (0, import_useEvent.useEvent)(canUsePE ? "pointerenter" : "mouseenter", opts),
+    addLeaveListener = (0, import_useEvent.useEvent)(canUsePE ? "pointerleave" : "mouseleave", opts),
+    addLockListener = (0, import_useEvent.useEvent)(lockEventType, opts),
+    addUnlockListener = (0, import_useEvent.useEvent)(unlockEventType, opts);
+  (0, import_useLayoutEffect.useLayoutEffectImpl)(() => {
+    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]);
+}

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

@@ -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 useLayoutEffect_exports = {};
+__export(useLayoutEffect_exports, {
+  useLayoutEffectImpl: () => useLayoutEffectImpl
+});
+module.exports = __toCommonJS(useLayoutEffect_exports);
+var import_react = __toESM(require("react"), 1),
+  import_canUseDOM = require("../canUseDOM.cjs");
+const useLayoutEffectImpl = import_canUseDOM.canUseDOM ? import_react.default.useLayoutEffect : import_react.default.useEffect;

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

@@ -0,0 +1,66 @@
+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"), 1),
+  import_isLocaleRTL = require("./isLocaleRTL.cjs"),
+  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);
+}

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

@@ -0,0 +1,83 @@
+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;
+}

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

@@ -0,0 +1,102 @@
+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"), 1),
+  import_test_utils = require("react-dom/test-utils"),
+  import__ = __toESM(require("../index.cjs"), 1),
+  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);
+  });
+});