@hanzogui/react-native-web-internals 2.0.0

package/dist/cjs/modules/setValueForStyles/index.cjs

@@ -0,0 +1,35 @@
+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 setValueForStyles_exports = {};
+__export(setValueForStyles_exports, {
+  setValueForStyles: () => setValueForStyles
+});
+module.exports = __toCommonJS(setValueForStyles_exports);
+var import_dangerousStyleValue = require("./dangerousStyleValue.cjs");
+function setValueForStyles(node, styles) {
+  const style = node.style;
+  for (let styleName in styles) {
+    if (!styles.hasOwnProperty(styleName)) continue;
+    const isCustomProperty = styleName.indexOf("--") === 0,
+      styleValue = (0, import_dangerousStyleValue.dangerousStyleValue)(styleName, styles[styleName], isCustomProperty);
+    styleName === "float" && (styleName = "cssFloat"), isCustomProperty ? style.setProperty(styleName, styleValue) : style[styleName] = styleValue;
+  }
+}

package/dist/cjs/modules/unitlessNumbers/index.cjs

@@ -0,0 +1,85 @@
+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 unitlessNumbers_exports = {};
+__export(unitlessNumbers_exports, {
+  unitlessNumbers: () => unitlessNumbers
+});
+module.exports = __toCommonJS(unitlessNumbers_exports);
+const unitlessNumbers = {
+    animationIterationCount: !0,
+    aspectRatio: !0,
+    borderImageOutset: !0,
+    borderImageSlice: !0,
+    borderImageWidth: !0,
+    boxFlex: !0,
+    boxFlexGroup: !0,
+    boxOrdinalGroup: !0,
+    columnCount: !0,
+    flex: !0,
+    flexGrow: !0,
+    flexOrder: !0,
+    flexPositive: !0,
+    flexShrink: !0,
+    flexNegative: !0,
+    fontWeight: !0,
+    gap: !0,
+    columnGap: !0,
+    rowGap: !0,
+    gridRow: !0,
+    gridRowEnd: !0,
+    gridRowGap: !0,
+    gridRowStart: !0,
+    gridColumn: !0,
+    gridColumnEnd: !0,
+    gridColumnGap: !0,
+    gridColumnStart: !0,
+    lineClamp: !0,
+    opacity: !0,
+    order: !0,
+    orphans: !0,
+    tabSize: !0,
+    widows: !0,
+    zIndex: !0,
+    zoom: !0,
+    // SVG-related
+    fillOpacity: !0,
+    floodOpacity: !0,
+    stopOpacity: !0,
+    strokeDasharray: !0,
+    strokeDashoffset: !0,
+    strokeMiterlimit: !0,
+    strokeOpacity: !0,
+    strokeWidth: !0,
+    // transform types
+    scale: !0,
+    scaleX: !0,
+    scaleY: !0,
+    scaleZ: !0,
+    // RN properties
+    shadowOpacity: !0
+  },
+  prefixes = ["ms", "Moz", "O", "Webkit"],
+  prefixKey = (prefix, key) => prefix + key.charAt(0).toUpperCase() + key.substring(1);
+Object.keys(unitlessNumbers).forEach(prop => {
+  prefixes.forEach(prefix => {
+    unitlessNumbers[prefixKey(prefix, prop)] = unitlessNumbers[prop];
+  });
+});

package/dist/cjs/modules/useElementLayout/index.cjs

@@ -0,0 +1,39 @@
+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 useElementLayout_exports = {};
+__export(useElementLayout_exports, {
+  useElementLayout: () => useElementLayout
+});
+module.exports = __toCommonJS(useElementLayout_exports);
+var import_use_element_layout = require("@hanzogui/use-element-layout"),
+  import_react = require("react");
+function useElementLayout(ref, onLayout) {
+  const wrappedRef = (0, import_react.useMemo)(() => ({
+    current: {
+      get host() {
+        return ref.current;
+      }
+    }
+  }), [ref]);
+  return (0, import_react.useEffect)(() => {
+    (0, import_use_element_layout.enable)();
+  }, []), (0, import_use_element_layout.useElementLayout)(wrappedRef, onLayout);
+}

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

@@ -0,0 +1,408 @@
+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__ = __toESM(require("../index.cjs"), 1),
+  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);
+    });
+  });
+});

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

@@ -0,0 +1,45 @@
+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 useEvent_exports = {};
+__export(useEvent_exports, {
+  useEvent: () => useEvent
+});
+module.exports = __toCommonJS(useEvent_exports);
+var import_createEventHandle = require("../createEventHandle/index.cjs"),
+  import_useLayoutEffect = require("../useLayoutEffect/index.cjs"),
+  import_useStable = require("../useStable/index.cjs");
+function useEvent(event, options) {
+  const targetListeners = (0, import_useStable.useStable)(() => /* @__PURE__ */new Map()),
+    addListener = (0, import_useStable.useStable)(() => {
+      const addEventListener = (0, import_createEventHandle.createEventHandle)(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.useLayoutEffectImpl)(() => () => {
+    targetListeners.forEach(removeListener => {
+      removeListener();
+    }), targetListeners.clear();
+  }, [targetListeners]), addListener;
+}