@tamagui/react-native-web-internals 1.116.0 → 1.116.2

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

@@ -0,0 +1,289 @@
+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__ = __toESM(require("..")), import_jsx_runtime = require("react/jsx-runtime");
+function createRoot(rootNode) {
+  return {
+    render(element) {
+      ReactDOM.render(element, rootNode);
+    }
+  };
+}
+describe("use-event", () => {
+  let root, rootNode;
+  beforeEach(() => {
+    rootNode = document.createElement("div"), document.body.appendChild(rootNode), root = createRoot(rootNode);
+  }), afterEach(() => {
+    root.render(null), document.body.removeChild(rootNode), rootNode = null, root = null;
+  }), describe("setListener()", () => {
+    test("event dispatched on target", () => {
+      const listener = jest.fn(), targetRef = React.createRef();
+      function Component() {
+        const addClickListener = (0, import__.default)("click");
+        return React.useEffect(() => {
+          addClickListener(targetRef.current, listener);
+        }), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref: targetRef });
+      }
+      (0, import_test_utils.act)(() => {
+        root.render(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, {}));
+      });
+      const target = (0, import_dom_event_testing_library.createEventTarget)(targetRef.current);
+      (0, import_test_utils.act)(() => {
+        target.click();
+      }), expect(listener).toBeCalledTimes(1);
+    }), test("event dispatched on parent", () => {
+      const listener = jest.fn(), listenerCapture = jest.fn(), targetRef = React.createRef(), parentRef = React.createRef();
+      function Component() {
+        const addClickListener = (0, import__.default)("click"), addClickCaptureListener = (0, import__.default)("click", { capture: !0 });
+        return React.useEffect(() => {
+          addClickListener(targetRef.current, listener), addClickCaptureListener(targetRef.current, listenerCapture);
+        }), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref: parentRef, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref: targetRef }) });
+      }
+      (0, import_test_utils.act)(() => {
+        root.render(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, {}));
+      });
+      const parent = (0, import_dom_event_testing_library.createEventTarget)(parentRef.current);
+      (0, import_test_utils.act)(() => {
+        parent.click();
+      }), expect(listener).toBeCalledTimes(0), expect(listenerCapture).toBeCalledTimes(0);
+    }), test("event dispatched on child", () => {
+      const log = [], listener = jest.fn(() => {
+        log.push("bubble");
+      }), listenerCapture = jest.fn(() => {
+        log.push("capture");
+      }), targetRef = React.createRef(), childRef = React.createRef();
+      function Component() {
+        const addClickListener = (0, import__.default)("click"), addClickCaptureListener = (0, import__.default)("click", { capture: !0 });
+        return React.useEffect(() => {
+          addClickListener(targetRef.current, listener), addClickCaptureListener(targetRef.current, listenerCapture);
+        }), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref: targetRef, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref: childRef }) });
+      }
+      (0, import_test_utils.act)(() => {
+        root.render(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, {}));
+      });
+      const child = (0, import_dom_event_testing_library.createEventTarget)(childRef.current);
+      (0, import_test_utils.act)(() => {
+        child.click();
+      }), expect(listenerCapture).toBeCalledTimes(1), expect(listener).toBeCalledTimes(1), expect(log).toEqual(["capture", "bubble"]);
+    }), test("event dispatched on text node", () => {
+      const listener = jest.fn(), targetRef = React.createRef(), childRef = React.createRef();
+      function Component() {
+        const addClickListener = (0, import__.default)("click");
+        return React.useEffect(() => {
+          addClickListener(targetRef.current, listener);
+        }), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref: targetRef, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref: childRef, children: "text" }) });
+      }
+      (0, import_test_utils.act)(() => {
+        root.render(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, {}));
+      });
+      const text = (0, import_dom_event_testing_library.createEventTarget)(childRef.current.firstChild);
+      (0, import_test_utils.act)(() => {
+        text.click();
+      }), expect(listener).toBeCalledTimes(1);
+    }), test("listener can be attached to document ", () => {
+      const listener = jest.fn(), targetRef = React.createRef();
+      function Component({ target: target2 }) {
+        const addClickListener = (0, import__.default)("click");
+        return React.useEffect(() => {
+          addClickListener(target2, listener);
+        }), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref: targetRef });
+      }
+      (0, import_test_utils.act)(() => {
+        root.render(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, { target: document }));
+      });
+      const target = (0, import_dom_event_testing_library.createEventTarget)(targetRef.current);
+      (0, import_test_utils.act)(() => {
+        target.click();
+      }), expect(listener).toBeCalledTimes(1);
+    }), test("listener can be attached to window ", () => {
+      const listener = jest.fn(), targetRef = React.createRef();
+      function Component({ target: target2 }) {
+        const addClickListener = (0, import__.default)("click");
+        return React.useEffect(() => {
+          addClickListener(target2, listener);
+        }), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref: targetRef });
+      }
+      (0, import_test_utils.act)(() => {
+        root.render(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, { target: window }));
+      });
+      const target = (0, import_dom_event_testing_library.createEventTarget)(targetRef.current);
+      (0, import_test_utils.act)(() => {
+        target.click();
+      }), expect(listener).toBeCalledTimes(1);
+    }), test("listener is replaceable", () => {
+      const listener = jest.fn(), listenerAlt = jest.fn(), targetRef = React.createRef();
+      function Component({ onClick }) {
+        const addClickListener = (0, import__.default)("click");
+        return React.useEffect(() => {
+          addClickListener(targetRef.current, onClick);
+        }), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref: targetRef });
+      }
+      (0, import_test_utils.act)(() => {
+        root.render(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, { onClick: listener }));
+      });
+      const target = (0, import_dom_event_testing_library.createEventTarget)(targetRef.current);
+      (0, import_test_utils.act)(() => {
+        target.click();
+      }), expect(listener).toBeCalledTimes(1), (0, import_test_utils.act)(() => {
+        root.render(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, { onClick: listenerAlt }));
+      }), (0, import_test_utils.act)(() => {
+        target.click();
+      }), expect(listener).toBeCalledTimes(1), expect(listenerAlt).toBeCalledTimes(1);
+    }), test("listener is removed when value is null", () => {
+      const listener = jest.fn(), targetRef = React.createRef();
+      function Component({ off }) {
+        const addClickListener = (0, import__.default)("click");
+        return React.useEffect(() => {
+          addClickListener(targetRef.current, off ? null : listener);
+        }), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref: targetRef });
+      }
+      (0, import_test_utils.act)(() => {
+        root.render(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, { off: !1 }));
+      });
+      const target = (0, import_dom_event_testing_library.createEventTarget)(targetRef.current);
+      (0, import_test_utils.act)(() => {
+        target.click();
+      }), expect(listener).toBeCalledTimes(1), (0, import_test_utils.act)(() => {
+        root.render(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, { off: !0 }));
+      }), listener.mockClear(), (0, import_test_utils.act)(() => {
+        target.click();
+      }), expect(listener).toBeCalledTimes(0);
+    }), test("custom event dispatched on target", () => {
+      const listener = jest.fn(), targetRef = React.createRef();
+      function Component() {
+        const addMagicEventListener = (0, import__.default)("magic-event");
+        return React.useEffect(() => {
+          addMagicEventListener(targetRef.current, listener);
+        }), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref: targetRef });
+      }
+      (0, import_test_utils.act)(() => {
+        root.render(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, {}));
+      }), (0, import_test_utils.act)(() => {
+        const event = new CustomEvent("magic-event", { bubbles: !0 });
+        targetRef.current.dispatchEvent(event);
+      }), expect(listener).toBeCalledTimes(1);
+    }), test("listeners can be set on multiple targets simultaneously", () => {
+      const log = [], targetRef = React.createRef(), parentRef = React.createRef(), childRef = React.createRef(), listener = jest.fn((e) => {
+        log.push(["bubble", e.currentTarget.id]);
+      }), listenerCapture = jest.fn((e) => {
+        log.push(["capture", e.currentTarget.id]);
+      });
+      function Component() {
+        const addClickListener = (0, import__.default)("click"), addClickCaptureListener = (0, import__.default)("click", { capture: !0 });
+        return React.useEffect(() => {
+          addClickListener(targetRef.current, listener), addClickListener(parentRef.current, listener), addClickCaptureListener(targetRef.current, listenerCapture), addClickCaptureListener(parentRef.current, listenerCapture);
+        }), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { id: "parent", ref: parentRef, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { id: "target", ref: targetRef, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref: childRef }) }) });
+      }
+      (0, import_test_utils.act)(() => {
+        root.render(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, {}));
+      });
+      const child = (0, import_dom_event_testing_library.createEventTarget)(childRef.current);
+      (0, import_test_utils.act)(() => {
+        child.click();
+      }), expect(listenerCapture).toBeCalledTimes(2), expect(listener).toBeCalledTimes(2), expect(log).toEqual([
+        ["capture", "parent"],
+        ["capture", "target"],
+        ["bubble", "target"],
+        ["bubble", "parent"]
+      ]);
+    }), test("listeners are specific to each event handle", () => {
+      const log = [], targetRef = React.createRef(), childRef = React.createRef(), listener = jest.fn((e) => {
+        log.push(["bubble", "target"]);
+      }), listenerAlt = jest.fn((e) => {
+        log.push(["bubble", "target-alt"]);
+      }), listenerCapture = jest.fn((e) => {
+        log.push(["capture", "target"]);
+      }), listenerCaptureAlt = jest.fn((e) => {
+        log.push(["capture", "target-alt"]);
+      });
+      function Component() {
+        const addClickListener = (0, import__.default)("click"), addClickAltListener = (0, import__.default)("click"), addClickCaptureListener = (0, import__.default)("click", { capture: !0 }), addClickCaptureAltListener = (0, import__.default)("click", { capture: !0 });
+        return React.useEffect(() => {
+          addClickListener(targetRef.current, listener), addClickAltListener(targetRef.current, listenerAlt), addClickCaptureListener(targetRef.current, listenerCapture), addClickCaptureAltListener(targetRef.current, listenerCaptureAlt);
+        }), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { id: "target", ref: targetRef, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref: childRef }) });
+      }
+      (0, import_test_utils.act)(() => {
+        root.render(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, {}));
+      });
+      const child = (0, import_dom_event_testing_library.createEventTarget)(childRef.current);
+      (0, import_test_utils.act)(() => {
+        child.click();
+      }), expect(listenerCapture).toBeCalledTimes(1), expect(listenerCaptureAlt).toBeCalledTimes(1), expect(listener).toBeCalledTimes(1), expect(listenerAlt).toBeCalledTimes(1), expect(log).toEqual([
+        ["capture", "target"],
+        ["capture", "target-alt"],
+        ["bubble", "target"],
+        ["bubble", "target-alt"]
+      ]);
+    });
+  }), describe("cleanup", () => {
+    test("removes all listeners for given event type from targets", () => {
+      const clickListener = jest.fn();
+      function Component() {
+        const addClickListener = (0, import__.default)("click");
+        return React.useEffect(() => {
+          addClickListener(document, clickListener);
+        }), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", {});
+      }
+      (0, import_test_utils.act)(() => {
+        root.render(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, {})), root.render(null);
+      });
+      const target = (0, import_dom_event_testing_library.createEventTarget)(document);
+      (0, import_test_utils.act)(() => {
+        target.click();
+      }), expect(clickListener).toBeCalledTimes(0);
+    });
+  }), describe("stopPropagation and stopImmediatePropagation", () => {
+    test("stopPropagation works as expected", () => {
+      const childListener = jest.fn((e) => {
+        e.stopPropagation();
+      }), targetListener = jest.fn(), targetRef = React.createRef(), childRef = React.createRef();
+      function Component() {
+        const addClickListener = (0, import__.default)("click");
+        return React.useEffect(() => {
+          addClickListener(childRef.current, childListener), addClickListener(targetRef.current, targetListener);
+        }), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref: targetRef, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref: childRef }) });
+      }
+      (0, import_test_utils.act)(() => {
+        root.render(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, {}));
+      });
+      const child = (0, import_dom_event_testing_library.createEventTarget)(childRef.current);
+      (0, import_test_utils.act)(() => {
+        child.click();
+      }), expect(childListener).toBeCalledTimes(1), expect(targetListener).toBeCalledTimes(0);
+    }), test("stopImmediatePropagation works as expected", () => {
+      const firstListener = jest.fn((e) => {
+        e.stopImmediatePropagation();
+      }), secondListener = jest.fn(), targetRef = React.createRef();
+      function Component() {
+        const addFirstClickListener = (0, import__.default)("click"), addSecondClickListener = (0, import__.default)("click");
+        return React.useEffect(() => {
+          addFirstClickListener(targetRef.current, firstListener), addSecondClickListener(targetRef.current, secondListener);
+        }), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref: targetRef });
+      }
+      (0, import_test_utils.act)(() => {
+        root.render(/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, {}));
+      });
+      const target = (0, import_dom_event_testing_library.createEventTarget)(targetRef.current);
+      (0, import_test_utils.act)(() => {
+        target.click();
+      }), expect(firstListener).toBeCalledTimes(1), expect(secondListener).toBeCalledTimes(0);
+    });
+  });
+});
+//# sourceMappingURL=index-test.js.map

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

@@ -0,0 +1,45 @@
+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 useEvent_exports = {};
+__export(useEvent_exports, {
+  default: () => useEvent
+});
+module.exports = __toCommonJS(useEvent_exports);
+var import_createEventHandle = __toESM(require("../createEventHandle/index")), import_useLayoutEffect = __toESM(require("../useLayoutEffect/index")), import_useStable = __toESM(require("../useStable/index"));
+function useEvent(event, options) {
+  const targetListeners = (0, import_useStable.default)(() => /* @__PURE__ */ new Map()), addListener = (0, import_useStable.default)(() => {
+    const addEventListener = (0, import_createEventHandle.default)(event, options);
+    return (target, callback) => {
+      const removeTargetListener = targetListeners.get(target);
+      removeTargetListener?.(), callback == null && targetListeners.delete(target);
+      const removeEventListener = addEventListener(target, callback);
+      return targetListeners.set(target, removeEventListener), removeEventListener;
+    };
+  });
+  return (0, import_useLayoutEffect.default)(() => () => {
+    targetListeners.forEach((removeListener) => {
+      removeListener();
+    }), targetListeners.clear();
+  }, [targetListeners]), addListener;
+}
+//# sourceMappingURL=index.js.map

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