react-bounded-overlay-manager 1.0.0-beta.1

package/dist/src/context/OverlayManagerContext.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import React, { PropsWithChildren } from 'react';
+import { EventEmitter } from 'events';
+interface OverlayManagerContextType {
+    overlayManagerEventEmitter: EventEmitter;
+    boundingComponentRef: React.RefObject<HTMLElement>;
+}
+type Props = {
+    boundingComponentRef: React.RefObject<HTMLElement>;
+};
+export declare const useOverlayManagerContext: () => OverlayManagerContextType;
+export declare const OverlayManagerContextProvider: React.FC<PropsWithChildren<Props>>;
+export {};

package/dist/src/context/OverlayManagerContext.js

@@ -0,0 +1,23 @@
+import { jsx as a } from "react/jsx-runtime";
+import { createContext as s, useContext as v, useState as i, useEffect as u } from "react";
+import { e as x } from "../../events-B7I8KoZ9.js";
+const r = s(void 0), E = () => {
+  const e = v(r);
+  if (e === void 0)
+    throw new Error("useOverlayManagerContext must be used within a OverlayManagerContextProvider");
+  return e;
+}, C = ({ children: e, boundingComponentRef: n }) => {
+  const [t] = i(new x.EventEmitter());
+  u(() => () => {
+    t.removeAllListeners();
+  }, [t]);
+  const o = {
+    overlayManagerEventEmitter: t,
+    boundingComponentRef: n
+  };
+  return /* @__PURE__ */ a(r.Provider, { value: o, children: e });
+};
+export {
+  C as OverlayManagerContextProvider,
+  E as useOverlayManagerContext
+};

package/dist/src/context/test/OverlayManagerContext.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/context/test/OverlayManagerContext.test.js

@@ -0,0 +1,31 @@
+import { jsx as t, jsxs as d } from "react/jsx-runtime";
+import { c as m, a as o, s as r } from "../../../react.esm-GKFzux-6.js";
+import { OverlayManagerContextProvider as s, useOverlayManagerContext as c } from "../OverlayManagerContext.js";
+import { e as a } from "../../../events-B7I8KoZ9.js";
+const i = () => {
+  const { overlayManagerEventEmitter: e, boundingComponentRef: n } = c();
+  return /* @__PURE__ */ d("div", { children: [
+    e instanceof a.EventEmitter ? /* @__PURE__ */ t("div", { "data-testid": "eventEmitter" }) : null,
+    n.current ? /* @__PURE__ */ t("div", { "data-testid": "boundingComponentRef" }) : null
+  ] });
+};
+describe("OverlayManagerContext", () => {
+  afterEach(m), it("provides overlayManagerEventEmitter and boundingComponentRef", () => {
+    o(
+      /* @__PURE__ */ t(s, { boundingComponentRef: { current: document.createElement("div") }, children: /* @__PURE__ */ t(i, {}) })
+    ), expect(r.getByTestId("eventEmitter")).not.toBeNull(), expect(r.getByTestId("boundingComponentRef")).not.toBeNull();
+  }), it("throws error when used outside provider", () => {
+    const e = jest.spyOn(console, "error");
+    e.mockImplementation(() => {
+    });
+    const n = () => {
+      o(/* @__PURE__ */ t(i, {}));
+    };
+    expect(n).toThrow("useOverlayManagerContext must be used within a OverlayManagerContextProvider"), e.mockRestore();
+  }), it("cleans up eventEmitter listeners on unmount", () => {
+    const e = jest.spyOn(a.EventEmitter.prototype, "removeAllListeners"), { unmount: n } = o(
+      /* @__PURE__ */ t(s, { boundingComponentRef: { current: document.createElement("div") }, children: /* @__PURE__ */ t("div", { children: "Test Component" }) })
+    );
+    n(), expect(e).toHaveBeenCalled(), e.mockRestore();
+  });
+});

package/dist/src/enum/PredefinedPosition.d.ts

@@ -0,0 +1,12 @@
+declare enum PredefinedPosition {
+    TOP_LEFT = "top_left",
+    BOTTOM_CENTER = "bottom_center",
+    TOP_RIGHT = "top_right",
+    CENTER = "center",
+    BOTTOM_LEFT = "bottom_left",
+    TOP_CENTER = "top_center",
+    BOTTOM_RIGHT = "bottom_right",
+    MID_LEFT = "mid_left",
+    MID_RIGHT = "mid_right"
+}
+export default PredefinedPosition;

package/dist/src/enum/PredefinedPosition.js

@@ -0,0 +1,4 @@
+var _ = /* @__PURE__ */ ((T) => (T.TOP_LEFT = "top_left", T.BOTTOM_CENTER = "bottom_center", T.TOP_RIGHT = "top_right", T.CENTER = "center", T.BOTTOM_LEFT = "bottom_left", T.TOP_CENTER = "top_center", T.BOTTOM_RIGHT = "bottom_right", T.MID_LEFT = "mid_left", T.MID_RIGHT = "mid_right", T))(_ || {});
+export {
+  _ as default
+};

package/dist/src/hooks/test/useApiUpdateHandler.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/hooks/test/useApiUpdateHandler.test.js

@@ -0,0 +1,28 @@
+import { r, w as n } from "../../../react.esm-GKFzux-6.js";
+import d from "../useApiUpdateHandler.js";
+jest.mock("../../api/BoundedOverlayManagerApi", () => ({
+  __esModule: !0,
+  // This property is needed for mocking default exports
+  default: jest.fn(({ timedEventManager: a }) => a)
+}));
+describe("useApiUpdateHandler", () => {
+  it("should recall onApiUpdated when an api parameter changes", async () => {
+    const a = { id: "initial" }, e = jest.fn(), t = jest.fn(), { rerender: i } = r(({ timedEventManager: p }) => d({ timedEventManager: p, onApiUpdated: e, updateOverlaysContainerBoundingBox: t }), {
+      initialProps: { timedEventManager: a }
+    });
+    await n(() => {
+      expect(e).toHaveBeenCalledWith(a);
+    }), e.mockClear();
+    const o = { id: "new" };
+    i({ timedEventManager: o }), await n(() => {
+      expect(e).toHaveBeenCalledWith(o);
+    });
+  }), it("should not recall onApiUpdated when no api parameter change", async () => {
+    const a = { id: "initial" }, e = jest.fn(), t = jest.fn(), { rerender: i } = r(() => d({ timedEventManager: a, onApiUpdated: e, updateOverlaysContainerBoundingBox: t }));
+    await n(() => {
+      expect(e).toHaveBeenCalledWith(a);
+    }), e.mockClear(), i(), await n(() => {
+      expect(e).not.toHaveBeenCalled();
+    });
+  });
+});

package/dist/src/hooks/test/useForwardBoundingComponentEvents.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/hooks/test/useForwardBoundingComponentEvents.test.js

@@ -0,0 +1,62 @@
+import { r as o } from "../../../react.esm-GKFzux-6.js";
+import { useOverlayManagerContext as m } from "../../context/OverlayManagerContext.js";
+import a from "../useForwardBoundingComponentEvents.js";
+import { makeEventOnlyMockComponentRef as s } from "./util.js";
+const i = () => {
+  const e = document.createElement("div");
+  return e.className = "overlay", e;
+}, v = () => {
+  const e = i(), n = document.createElement("div");
+  e.appendChild(n);
+  const t = document.createElement("div");
+  return n.appendChild(t), t;
+}, c = (e) => {
+  expect(e.current.addEventListener).toHaveBeenCalledWith("mousemove", expect.any(Function)), expect(e.current.addEventListener).toHaveBeenCalledWith("mouseleave", expect.any(Function));
+}, l = (e) => {
+  expect(e.current.removeEventListener).toHaveBeenCalledWith("mousemove", expect.any(Function)), expect(e.current.removeEventListener).toHaveBeenCalledWith("mouseleave", expect.any(Function));
+};
+jest.mock("../../context/OverlayManagerContext");
+describe("useForwardBoundingComponentEvents", () => {
+  const e = {
+    emit: jest.fn()
+  };
+  let n;
+  beforeEach(() => {
+    n = s(), m.mockReturnValue({
+      overlayManagerEventEmitter: e,
+      boundingComponentRef: n
+    });
+  }), afterEach(() => {
+    jest.clearAllMocks();
+  }), it("sets up and tears down event listeners", () => {
+    const { unmount: t } = o(() => a());
+    c(n), t(), l(n);
+  }), it("emits mousemoveOnBoundingComponent when mousemove event occurs", () => {
+    o(() => a());
+    const t = new Event("mousemove");
+    n.current.dispatchEvent(t), expect(e.emit).toHaveBeenCalledWith("mousemoveOnBoundingComponent");
+  }), it("emits mouseleaveOnBoundingComponent when mouseleave event occurs", () => {
+    o(() => a());
+    const t = new Event("mouseleave");
+    n.current.dispatchEvent(t), expect(e.emit).toHaveBeenCalledWith("mouseleaveOnBoundingComponent");
+  }), it.each([
+    {
+      title: "does not emit mouseleaveOnBoundingComponent when related target is an overlay",
+      relatedTarget: i()
+    },
+    {
+      title: "does not emit mouseleaveOnBoundingComponent when related target is a descendant of an overlay",
+      relatedTarget: v()
+    }
+  ])("$title", ({ relatedTarget: t }) => {
+    o(() => a());
+    const r = new MouseEvent("mouseleave", { relatedTarget: t });
+    n.current.dispatchEvent(r), expect(e.emit).not.toHaveBeenCalledWith("mouseleaveOnBoundingComponent");
+  }), it("handles updates to boundingComponentRef correctly", () => {
+    const { rerender: t } = o(() => a()), r = s();
+    m.mockReturnValue({
+      overlayManagerEventEmitter: e,
+      boundingComponentRef: r
+    }), t(), l(n), c(r);
+  });
+});

package/dist/src/hooks/test/useForwardOverlayEvents.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/hooks/test/useForwardOverlayEvents.test.js

@@ -0,0 +1,43 @@
+import { r as o, w as m } from "../../../react.esm-GKFzux-6.js";
+import { useOverlayManagerContext as i } from "../../context/OverlayManagerContext.js";
+import r from "../useForwardOverlayEvents.js";
+import { makeEventOnlyMockComponentRef as s } from "./util.js";
+jest.mock("../../context/OverlayManagerContext");
+const v = (e) => {
+  expect(e.current.addEventListener).toHaveBeenCalledWith("mousemove", expect.any(Function)), expect(e.current.addEventListener).toHaveBeenCalledWith("mouseleave", expect.any(Function));
+}, c = (e) => {
+  expect(e.current.removeEventListener).toHaveBeenCalledWith("mousemove", expect.any(Function)), expect(e.current.removeEventListener).toHaveBeenCalledWith("mouseleave", expect.any(Function));
+};
+describe("useForwardOverlayEvents", () => {
+  const e = {
+    emit: jest.fn()
+  }, n = s();
+  beforeEach(() => {
+    i.mockReturnValue({
+      overlayManagerEventEmitter: e
+    });
+  }), afterEach(() => {
+    jest.clearAllMocks();
+  }), it("sets up and tears down event listeners", () => {
+    const { unmount: t } = o(() => r({ overlayRef: n }));
+    v(n), t(), c(n);
+  }), it("emits mousemoveOnOverlay when mousemove event occurs", () => {
+    o(() => r({ overlayRef: n }));
+    const t = new Event("mousemove");
+    n.current.dispatchEvent(t), expect(e.emit).toHaveBeenCalledWith("mousemoveOnOverlay");
+  }), it("emits mousemoveOnOverlay when mouseleave event occurs", () => {
+    o(() => r({ overlayRef: n }));
+    const t = new Event("mouseleave");
+    n.current.dispatchEvent(t), expect(e.emit).toHaveBeenCalledWith("mouseleaveOnOverlay", t);
+  }), it("handles updates to overlayRef correctly", async () => {
+    const { rerender: t } = o(({ overlayRef: l }) => r({ overlayRef: l }), {
+      initialProps: { overlayRef: n }
+    }), a = s();
+    t({ overlayRef: a }), await m(() => {
+      c(n), v(a);
+    });
+  }), it("does not emit any mount events when overlay element is null", () => {
+    const t = { current: null };
+    o(() => r({ overlayRef: t })), expect(e.emit).not.toHaveBeenCalled();
+  });
+});

package/dist/src/hooks/test/useFullscreenChange.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/hooks/test/useFullscreenChange.test.js

@@ -0,0 +1,33 @@
+import { r as c, w as u } from "../../../react.esm-GKFzux-6.js";
+import r from "../useFullscreenChange.js";
+describe("useFullscreenChange", () => {
+  const n = jest.fn(), l = ["fullscreenchange", "webkitfullscreenchange", "mozfullscreenchange", "MSFullscreenChange"], a = (e, t) => {
+    l.forEach((s) => {
+      expect(e).toHaveBeenCalledWith(s, t);
+    });
+  }, o = (e, t) => {
+    l.forEach((s) => {
+      expect(e).toHaveBeenCalledWith(s, t);
+    });
+  };
+  afterEach(() => {
+    jest.clearAllMocks(), jest.restoreAllMocks();
+  }), it("adds fullscreen change event listeners when mounted", () => {
+    const e = jest.spyOn(document, "addEventListener");
+    c(() => r({ handleFullscreenChange: n })), o(e, n);
+  }), it("removes fullscreen change event listeners when unmounted", () => {
+    const e = jest.spyOn(document, "removeEventListener"), { unmount: t } = c(() => r({ handleFullscreenChange: n }));
+    t(), a(e, n);
+  }), it("calls handleFullscreenChange when a fullscreen change event occurs", () => {
+    c(() => r({ handleFullscreenChange: n })), l.forEach((e) => {
+      document.dispatchEvent(new Event(e)), expect(n).toHaveBeenCalledTimes(1), n.mockClear();
+    });
+  }), it("updates event listeners when handleFullscreenChange changes", async () => {
+    const e = jest.fn(), t = jest.spyOn(document, "addEventListener"), s = jest.spyOn(document, "removeEventListener"), { rerender: h } = c(({ handleFullscreenChange: d }) => r({ handleFullscreenChange: d }), {
+      initialProps: { handleFullscreenChange: n }
+    });
+    t.mockClear(), s.mockClear(), n.mockClear(), h({ handleFullscreenChange: e }), await u(() => {
+      o(t, e), a(s, n);
+    });
+  });
+});

package/dist/src/hooks/test/useOverlayManagerEvents.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/hooks/test/useOverlayManagerEvents.test.js

@@ -0,0 +1,87 @@
+import { r as o } from "../../../react.esm-GKFzux-6.js";
+import a from "../useOverlayManagerEvents.js";
+import p from "../../timer/TimedEventManager.js";
+import { useOverlayManagerContext as O } from "../../context/OverlayManagerContext.js";
+import { e as y } from "../../../events-B7I8KoZ9.js";
+jest.mock("../../context/OverlayManagerContext");
+describe("useOverlayManagerEvents", () => {
+  let e, u, r, m;
+  const n = new y.EventEmitter(), l = jest.spyOn(n, "on"), v = jest.spyOn(n, "off"), i = () => {
+    expect(l).toHaveBeenCalledWith("mousemoveOnOverlay", expect.any(Function)), expect(l).toHaveBeenCalledWith("mousemoveOnBoundingComponent", expect.any(Function)), expect(l).toHaveBeenCalledWith("mouseleaveOnOverlay", expect.any(Function)), expect(l).toHaveBeenCalledWith("mouseleaveOnBoundingComponent", expect.any(Function));
+  }, c = () => {
+    expect(v).toHaveBeenCalledWith("mousemoveOnOverlay", expect.any(Function)), expect(v).toHaveBeenCalledWith("mousemoveOnBoundingComponent", expect.any(Function)), expect(v).toHaveBeenCalledWith("mouseleaveOnOverlay", expect.any(Function)), expect(v).toHaveBeenCalledWith("mouseleaveOnBoundingComponent", expect.any(Function));
+  };
+  beforeEach(() => {
+    m = {
+      current: document.createElement("div")
+    }, O.mockReturnValue({
+      overlayManagerEventEmitter: n,
+      boundingComponentRef: m
+    }), e = new p({
+      onStart: jest.fn(),
+      onStop: jest.fn(),
+      timeoutDuration: 1e3
+    }), u = jest.fn(), r = jest.fn(), jest.spyOn(e, "requestStart").mockImplementation(u), jest.spyOn(e, "requestStop").mockImplementation(r);
+  }), afterEach(() => {
+    jest.clearAllMocks();
+  }), it("adds events when mounted", () => {
+    o(() => a({ timedEventManager: e })), i();
+  }), it("removes events when unmounted", () => {
+    const { unmount: t } = o(() => a({ timedEventManager: e }));
+    t(), c();
+  }), it.each([
+    {
+      eventName: "mousemoveOnOverlay",
+      requestStartOnMouseMove: !0
+    },
+    {
+      eventName: "mousemoveOnBoundingComponent",
+      requestStartOnMouseMove: !0
+    },
+    {
+      eventName: "mousemoveOnOverlay",
+      requestStartOnMouseMove: !1
+    },
+    {
+      eventName: "mousemoveOnBoundingComponent",
+      requestStartOnMouseMove: !1
+    }
+  ])("calls requestStart when $eventName is emitted and requestStartOnMouseMove is $requestStartOnMouseMove", ({ eventName: t, requestStartOnMouseMove: s }) => {
+    o(() => a({ timedEventManager: e, requestStartOnMouseMove: s })), n.emit(t), expect(u).toHaveBeenCalledTimes(s ? 1 : 0);
+  }), it.each([
+    {
+      eventName: "mouseleaveOnBoundingComponent",
+      requestStopOnMouseMove: !0
+    },
+    {
+      eventName: "mouseleaveOnOverlay",
+      requestStopOnMouseMove: !1
+    },
+    {
+      eventName: "mouseleaveOnBoundingComponent",
+      requestStopOnMouseMove: !1
+    }
+  ])("calls requestStop when $eventName is emitted and requestStopOnMouseMove is $requestStopOnMouseMove", ({ eventName: t, requestStopOnMouseMove: s }) => {
+    o(() => a({ timedEventManager: e, requestStopOnMouseMove: s })), n.emit(t), expect(r).toHaveBeenCalledTimes(s ? 1 : 0);
+  }), it("calls requestStop when mouseleaveOnOverlay is emitted and the relatedTarget is not the boundingComponent or a descendant of it", () => {
+    o(() => a({ timedEventManager: e }));
+    const t = new MouseEvent("mouseleaveOnOverlay", {
+      relatedTarget: document.createElement("div")
+    });
+    n.emit("mouseleaveOnOverlay", t), expect(r).toHaveBeenCalled();
+  }), it("does not call requestStop when mouseleaveOnOverlay is emitted but the relatedTarget is the boundingComponent", () => {
+    o(() => a({ timedEventManager: e }));
+    const t = new MouseEvent("mouseleaveOnOverlay", {
+      relatedTarget: m.current
+    });
+    n.emit("mouseleaveOnOverlay", t), expect(r).not.toHaveBeenCalled();
+  }), it("does not call requestStop when mouseleaveOnOverlay is emitted but the relatedTarget is a descendant of the boundingComponent", () => {
+    o(() => a({ timedEventManager: e }));
+    const s = m.current.appendChild(document.createElement("div")).appendChild(document.createElement("div")), d = new MouseEvent("mouseleaveOnOverlay", {
+      relatedTarget: s
+    });
+    n.emit("mouseleaveOnOverlay", d), expect(r).not.toHaveBeenCalled();
+  }), it("does not register events when timedEventManager is null", () => {
+    o(() => a({ timedEventManager: null })), expect(l).not.toHaveBeenCalled();
+  });
+});

package/dist/src/hooks/test/useResizeObserver.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/hooks/test/useResizeObserver.test.js

@@ -0,0 +1,47 @@
+import { r as a, w as i } from "../../../react.esm-GKFzux-6.js";
+import o from "../useResizeObserver.js";
+jest.mock("use-debounce", () => ({
+  useDebouncedCallback: jest.fn((t) => t)
+}));
+describe("useResizeObserver", () => {
+  let t, s;
+  beforeEach(() => {
+    t = jest.fn(), s = jest.fn(), global.ResizeObserver = jest.fn().mockImplementation(() => ({
+      observe: t,
+      disconnect: s
+    }));
+  }), afterEach(() => {
+    jest.clearAllMocks();
+  });
+  const c = (e) => {
+    expect(t).toHaveBeenCalledWith(e.current);
+  }, l = () => {
+    expect(s).toHaveBeenCalled();
+  };
+  it("observes the target element", () => {
+    const e = { current: {} };
+    a(() => o(e, { handleResize: jest.fn() })), c(e);
+  }), it("disconnects the observer when unmounted", () => {
+    const e = { current: {} }, { unmount: n } = a(() => o(e, { handleResize: jest.fn() }));
+    n(), l();
+  }), it("does not update the observer when dependecies does not change", async () => {
+    const e = { current: {} }, n = () => {
+    }, { rerender: r } = a(() => o(e, { handleResize: n }));
+    t.mockClear(), r(), await i(() => {
+      expect(t).not.toHaveBeenCalled(), expect(s).not.toHaveBeenCalled();
+    });
+  }), it("updates the observer when targetElement or handleResize changes", async () => {
+    const e = { current: {} }, n = jest.fn(), { rerender: r } = a(({ targetElement: m, handleResize: u }) => o(m, { handleResize: u }), {
+      initialProps: { targetElement: e, handleResize: n }
+    });
+    jest.clearAllMocks();
+    const d = jest.fn();
+    r({ targetElement: e, handleResize: d }), await i(() => {
+      c(e), l();
+    }), jest.clearAllMocks();
+    const h = { current: {} };
+    r({ targetElement: h, handleResize: d }), await i(() => {
+      c(h), l();
+    });
+  });
+});

package/dist/src/hooks/test/useScrollOnDocument.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/hooks/test/useScrollOnDocument.test.js

@@ -0,0 +1,38 @@
+import { r as t, w as d } from "../../../react.esm-GKFzux-6.js";
+import l from "../useScrollOnDocument.js";
+jest.mock("use-debounce", () => ({
+  useDebouncedCallback: jest.fn((e) => e)
+}));
+describe("useScrollOnDocument", () => {
+  const e = jest.fn();
+  let o, c;
+  const s = (n) => {
+    expect(o).toHaveBeenCalledWith("scroll", n);
+  }, r = (n) => {
+    expect(c).toHaveBeenCalledWith("scroll", n);
+  };
+  beforeEach(() => {
+    o = jest.spyOn(document, "addEventListener"), c = jest.spyOn(document, "removeEventListener");
+  }), afterEach(() => {
+    jest.clearAllMocks();
+  }), it("adds a debounced scroll event listener", () => {
+    t(() => l({ handleScroll: e })), s(e);
+  }), it("removes the scroll event listener when unmounted", () => {
+    const { unmount: n } = t(() => l({ handleScroll: e }));
+    n(), r(e);
+  }), it("dees not update the scroll event listener when handleScroll does not change", async () => {
+    const { rerender: n } = t(() => l({ handleScroll: e }));
+    o.mockClear(), n(), await d(() => {
+      expect(o).not.toHaveBeenCalled(), expect(c).not.toHaveBeenCalled();
+    });
+  }), it("updates the scroll event listener when handleScroll changes", async () => {
+    const { rerender: n } = t(({ handleScroll: i }) => l({ handleScroll: i }), {
+      initialProps: { handleScroll: e }
+    }), a = jest.fn();
+    n({ handleScroll: a }), await d(() => {
+      r(e), s(a);
+    });
+  }), it("calls handleScroll on scroll on document", () => {
+    t(() => l({ handleScroll: e })), document.dispatchEvent(new Event("scroll")), expect(e).toHaveBeenCalled();
+  });
+});

package/dist/src/hooks/test/useTimedEventManager.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/hooks/test/useTimedEventManager.test.js

@@ -0,0 +1,41 @@
+import { r as o } from "../../../react.esm-GKFzux-6.js";
+import r from "../useTimedEventManager.js";
+import c, { NO_TIMEOUT as m } from "../../timer/TimedEventManager.js";
+const i = jest.fn();
+c.prototype.requestStop = i;
+describe("useTimedEventManager", () => {
+  let e, n;
+  beforeEach(() => {
+    e = jest.fn(), n = jest.fn();
+  }), it("should return null when returnNull is true", () => {
+    const { result: t } = o(() => r({ onStart: e, onStop: n, timeoutDuration: 1e3, returnNull: !0 }));
+    expect(t.current).toBeNull();
+  }), it("should create a new TimedEventManager instance when returnNull is false", () => {
+    const { result: t } = o(() => r({ onStart: e, onStop: n, timeoutDuration: 1e3, returnNull: !1 }));
+    expect(t.current).toBeInstanceOf(c);
+  }), it("should call requestStop on unmount", () => {
+    const { unmount: t } = o(() => r({ onStart: e, onStop: n, timeoutDuration: 1e3 }));
+    t(), expect(i).toHaveBeenCalled();
+  }), it("should reuse the same TimedEventManager instance if dependencies are unchanged", () => {
+    const { result: t, rerender: u } = o(
+      () => r({ onStart: e, onStop: n, timeoutDuration: 1e3 })
+    ), a = t.current;
+    u();
+    const s = t.current;
+    expect(a).toBe(s);
+  }), it("should create a new instance when a dependency changes", () => {
+    let t = 1e3;
+    const { result: u, rerender: a } = o(
+      ({ timeoutDuration: d }) => r({ onStart: e, onStop: n, timeoutDuration: d }),
+      {
+        initialProps: { timeoutDuration: t }
+      }
+    ), s = u.current;
+    t = 2e3, a({ timeoutDuration: t });
+    const l = u.current;
+    expect(s).not.toBe(l);
+  }), it("should handle NO_TIMEOUT case correctly", () => {
+    const { result: t } = o(() => r({ onStart: e, onStop: n, timeoutDuration: m }));
+    expect(t.current).toBeDefined(), expect(t.current).toBeInstanceOf(c);
+  });
+});

package/dist/src/hooks/test/useWindowResize.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/hooks/test/useWindowResize.test.js

@@ -0,0 +1,38 @@
+import { r as t, w as l } from "../../../react.esm-GKFzux-6.js";
+import s from "../useWindowResize.js";
+jest.mock("use-debounce", () => ({
+  useDebouncedCallback: jest.fn((e) => e)
+}));
+describe("useWindowResize", () => {
+  const e = jest.fn();
+  let i, a;
+  const o = (n) => {
+    expect(i).toHaveBeenCalledWith("resize", n);
+  }, r = (n) => {
+    expect(a).toHaveBeenCalledWith("resize", n);
+  };
+  beforeEach(() => {
+    i = jest.spyOn(window, "addEventListener"), a = jest.spyOn(window, "removeEventListener");
+  }), afterEach(() => {
+    jest.clearAllMocks();
+  }), it("adds a debounced resize event listener", () => {
+    t(() => s({ handleResize: e })), o(e);
+  }), it("removes the resize event listener when unmounted", () => {
+    const { unmount: n } = t(() => s({ handleResize: e }));
+    n(), r(e);
+  }), it("dees not update the resize event listener when handleResize does not change", async () => {
+    const { rerender: n } = t(() => s({ handleResize: e }));
+    i.mockClear(), n(), await l(() => {
+      expect(i).not.toHaveBeenCalled(), expect(a).not.toHaveBeenCalled();
+    });
+  }), it("updates the resize event listener when handleResize changes", async () => {
+    const { rerender: n } = t(({ handleResize: c }) => s({ handleResize: c }), {
+      initialProps: { handleResize: e }
+    }), d = jest.fn();
+    n({ handleResize: d }), await l(() => {
+      r(e), o(d);
+    });
+  }), it("calls handleResize on window resize", () => {
+    t(() => s({ handleResize: e })), window.dispatchEvent(new Event("resize")), expect(e).toHaveBeenCalled();
+  });
+});

package/dist/src/hooks/test/util.d.ts

@@ -0,0 +1,7 @@
+export declare const makeEventOnlyMockComponentRef: () => {
+    current: {
+        addEventListener: jest.Mock<any, any, any>;
+        removeEventListener: jest.Mock<any, any, any>;
+        dispatchEvent: jest.Mock<any, any, any>;
+    };
+};

package/dist/src/hooks/test/util.js

@@ -0,0 +1,20 @@
+import { e as o } from "../../../events-B7I8KoZ9.js";
+const r = () => {
+  const t = new o.EventEmitter();
+  return {
+    current: {
+      addEventListener: jest.fn().mockImplementation((e, n) => {
+        t.on(e, n);
+      }),
+      removeEventListener: jest.fn().mockImplementation((e, n) => {
+        t.off(e, n);
+      }),
+      dispatchEvent: jest.fn().mockImplementation((e) => {
+        t.emit(e.type, e);
+      })
+    }
+  };
+};
+export {
+  r as makeEventOnlyMockComponentRef
+};

package/dist/src/hooks/useApiUpdateHandler.d.ts

@@ -0,0 +1,6 @@
+import BoundedOverlayManagerApi, { BoundedOverlayManagerApiOptions } from "../api/BoundedOverlayManagerApi";
+type Options = BoundedOverlayManagerApiOptions & {
+    onApiUpdated?: (api: BoundedOverlayManagerApi) => void;
+};
+declare const useApiUpdateHandler: ({ timedEventManager, onApiUpdated, updateOverlaysContainerBoundingBox }: Options) => void;
+export default useApiUpdateHandler;

package/dist/src/hooks/useApiUpdateHandler.js

@@ -0,0 +1,10 @@
+import { useEffect as m } from "react";
+import s from "../api/BoundedOverlayManagerApi.js";
+const l = ({ timedEventManager: f, onApiUpdated: r, updateOverlaysContainerBoundingBox: e }) => {
+  m(() => {
+    r && r(new s({ timedEventManager: f, updateOverlaysContainerBoundingBox: e }));
+  }, [f, r, e]);
+};
+export {
+  l as default
+};

package/dist/src/hooks/useForwardBoundingComponentEvents.d.ts

@@ -0,0 +1,2 @@
+declare const useForwardBoundingComponentEvents: () => void;
+export default useForwardBoundingComponentEvents;

package/dist/src/hooks/useForwardBoundingComponentEvents.js

@@ -0,0 +1,20 @@
+import { useEffect as u } from "react";
+import { useOverlayManagerContext as v } from "../context/OverlayManagerContext.js";
+const i = () => {
+  const { overlayManagerEventEmitter: r, boundingComponentRef: e } = v(), a = () => {
+    r.emit("mousemoveOnBoundingComponent");
+  }, s = (t) => {
+    var n;
+    (n = t.relatedTarget) != null && n.closest(".overlay") || r.emit("mouseleaveOnBoundingComponent");
+  };
+  u(() => {
+    var t, o;
+    return (t = e.current) == null || t.addEventListener("mousemove", a), (o = e.current) == null || o.addEventListener("mouseleave", s), () => {
+      var n, m;
+      (n = e.current) == null || n.removeEventListener("mousemove", a), (m = e.current) == null || m.removeEventListener("mouseleave", s);
+    };
+  }, [e]);
+};
+export {
+  i as default
+};

package/dist/src/hooks/useForwardOverlayEvents.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+type Options = {
+    overlayRef: React.RefObject<HTMLElement>;
+};
+declare const useForwardOverlayEvents: ({ overlayRef }: Options) => void;
+export default useForwardOverlayEvents;