@rio-cloud/rio-uikit 2.0.0-beta.1 → 2.0.0-beta.2

package/hooks/useEventListenerCount.js

@@ -1,42 +1,28 @@
-import { useState, useEffect } from 'react';
-import { throttle } from 'es-toolkit/function';
-const useEventListenerCount = () => {
-    const [listenerCounts, setListenerCounts] = useState({});
-    const [totalCount, setTotalCount] = useState(0);
-    useEffect(() => {
-        console.log('init useEventListener interceptor');
-        const eventListeners = new Set();
-        const originalAddEventListener = EventTarget.prototype.addEventListener;
-        const originalRemoveEventListener = EventTarget.prototype.removeEventListener;
-        const updateListeners = throttle(() => {
-            const counts = Array.from(eventListeners).reduce((acc, { type }) => {
-                acc[type] = (acc[type] || 0) + 1;
-                return acc;
-            }, {});
-            setListenerCounts(counts);
-            setTotalCount(eventListeners.size);
-        }, 1000);
-        EventTarget.prototype.addEventListener = function (type, listener, options) {
-            if (listener) {
-                eventListeners.add({ type, listener });
-                updateListeners();
-            }
-            originalAddEventListener.call(this, type, listener, options);
-        };
-        EventTarget.prototype.removeEventListener = function (type, listener, options) {
-            eventListeners.forEach(item => {
-                if (item.type === type && item.listener === listener) {
-                    eventListeners.delete(item);
-                }
-            });
-            updateListeners();
-            originalRemoveEventListener.call(this, type, listener, options);
-        };
-        return () => {
-            EventTarget.prototype.addEventListener = originalAddEventListener;
-            EventTarget.prototype.removeEventListener = originalRemoveEventListener;
-        };
-    }, []);
-    return { counts: listenerCounts, total: totalCount };
+import { useState as v, useEffect as d } from "react";
+import { throttle as l } from "es-toolkit/function";
+const g = () => {
+  const [u, E] = v({}), [c, p] = v(0);
+  return d(() => {
+    console.log("init useEventListener interceptor");
+    const o = /* @__PURE__ */ new Set(), s = EventTarget.prototype.addEventListener, i = EventTarget.prototype.removeEventListener, a = l(() => {
+      const e = Array.from(o).reduce(
+        (t, { type: n }) => (t[n] = (t[n] || 0) + 1, t),
+        {}
+      );
+      E(e), p(o.size);
+    }, 1e3);
+    return EventTarget.prototype.addEventListener = function(e, t, n) {
+      t && (o.add({ type: e, listener: t }), a()), s.call(this, e, t, n);
+    }, EventTarget.prototype.removeEventListener = function(e, t, n) {
+      o.forEach((r) => {
+        r.type === e && r.listener === t && o.delete(r);
+      }), a(), i.call(this, e, t, n);
+    }, () => {
+      EventTarget.prototype.addEventListener = s, EventTarget.prototype.removeEventListener = i;
+    };
+  }, []), { counts: u, total: c };
 };
-export default useEventListenerCount;
+export {
+  g as default
+};
+//# sourceMappingURL=useEventListenerCount.js.map

package/hooks/useEventListenerCount.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEventListenerCount.js","sources":["../../src/hooks/useEventListenerCount.ts"],"sourcesContent":["import { useState, useEffect } from 'react';\nimport { throttle } from 'es-toolkit/function';\n\nconst useEventListenerCount = () => {\n    const [listenerCounts, setListenerCounts] = useState<Record<string, number>>({});\n    const [totalCount, setTotalCount] = useState(0);\n\n    useEffect(() => {\n        console.log('init useEventListener interceptor');\n\n        const eventListeners = new Set<{ type: string; listener: EventListenerOrEventListenerObject }>();\n\n        const originalAddEventListener = EventTarget.prototype.addEventListener;\n        const originalRemoveEventListener = EventTarget.prototype.removeEventListener;\n\n        const updateListeners = throttle(() => {\n            const counts = Array.from(eventListeners).reduce(\n                (acc, { type }) => {\n                    acc[type] = (acc[type] || 0) + 1;\n                    return acc;\n                },\n                {} as Record<string, number>\n            );\n\n            setListenerCounts(counts);\n            setTotalCount(eventListeners.size);\n        }, 1000);\n\n        EventTarget.prototype.addEventListener = function (type, listener, options) {\n            if (listener) {\n                eventListeners.add({ type, listener });\n                updateListeners();\n            }\n            originalAddEventListener.call(this, type, listener, options);\n        };\n\n        EventTarget.prototype.removeEventListener = function (type, listener, options) {\n            eventListeners.forEach(item => {\n                if (item.type === type && item.listener === listener) {\n                    eventListeners.delete(item);\n                }\n            });\n            updateListeners();\n            originalRemoveEventListener.call(this, type, listener, options);\n        };\n\n        return () => {\n            EventTarget.prototype.addEventListener = originalAddEventListener;\n            EventTarget.prototype.removeEventListener = originalRemoveEventListener;\n        };\n    }, []);\n\n    return { counts: listenerCounts, total: totalCount };\n};\n\nexport default useEventListenerCount;\n"],"names":["useEventListenerCount","listenerCounts","setListenerCounts","useState","totalCount","setTotalCount","useEffect","eventListeners","originalAddEventListener","originalRemoveEventListener","updateListeners","throttle","counts","acc","type","listener","options","item"],"mappings":";;AAGA,MAAMA,IAAwB,MAAM;AAChC,QAAM,CAACC,GAAgBC,CAAiB,IAAIC,EAAiC,CAAA,CAAE,GACzE,CAACC,GAAYC,CAAa,IAAIF,EAAS,CAAC;AAE9C,SAAAG,EAAU,MAAM;AACZ,YAAQ,IAAI,mCAAmC;AAE/C,UAAMC,wBAAqB,IAAA,GAErBC,IAA2B,YAAY,UAAU,kBACjDC,IAA8B,YAAY,UAAU,qBAEpDC,IAAkBC,EAAS,MAAM;AACnC,YAAMC,IAAS,MAAM,KAAKL,CAAc,EAAE;AAAA,QACtC,CAACM,GAAK,EAAE,MAAAC,SACJD,EAAIC,CAAI,KAAKD,EAAIC,CAAI,KAAK,KAAK,GACxBD;AAAA,QAEX,CAAA;AAAA,MAAC;AAGL,MAAAX,EAAkBU,CAAM,GACxBP,EAAcE,EAAe,IAAI;AAAA,IACrC,GAAG,GAAI;AAEP,uBAAY,UAAU,mBAAmB,SAAUO,GAAMC,GAAUC,GAAS;AACxE,MAAID,MACAR,EAAe,IAAI,EAAE,MAAAO,GAAM,UAAAC,EAAA,CAAU,GACrCL,EAAA,IAEJF,EAAyB,KAAK,MAAMM,GAAMC,GAAUC,CAAO;AAAA,IAC/D,GAEA,YAAY,UAAU,sBAAsB,SAAUF,GAAMC,GAAUC,GAAS;AAC3E,MAAAT,EAAe,QAAQ,CAAAU,MAAQ;AAC3B,QAAIA,EAAK,SAASH,KAAQG,EAAK,aAAaF,KACxCR,EAAe,OAAOU,CAAI;AAAA,MAElC,CAAC,GACDP,EAAA,GACAD,EAA4B,KAAK,MAAMK,GAAMC,GAAUC,CAAO;AAAA,IAClE,GAEO,MAAM;AACT,kBAAY,UAAU,mBAAmBR,GACzC,YAAY,UAAU,sBAAsBC;AAAA,IAChD;AAAA,EACJ,GAAG,CAAA,CAAE,GAEE,EAAE,QAAQR,GAAgB,OAAOG,EAAA;AAC5C;"}

package/hooks/useFocusTrap.d.ts

@@ -1,4 +1,4 @@
-import type React from 'react';
+import { default as React } from 'react';
 /**
  * This custom hook allows to keep the focus inside a defined wrapper element.
  * This might be a dialog or a custom overlay.

package/hooks/useFocusTrap.js

@@ -1,62 +1,34 @@
-import { useEffect, useRef } from 'react';
-/**
- * This custom hook allows to keep the focus inside a defined wrapper element.
- * This might be a dialog or a custom overlay.
- *
- * This hook can be used in two ways:
- * - When you have a external component that will be re-rendered after the overlay opens, you can use
- *   the built-in ref. This ref will be returned from this hook and can be set on the respective wrapper element.
- * - When you have an element that does not re-render, use a state setter function to set as the ref.
- *   This element can then be passed as a parameter to this hook and it will be used instead of the built-in ref.
- *
- * @param element Optional parameter to pass in the existing DOM reference. Use this instead of the built-in ref.
- * @returns
- */
-const useFocusTrap = (element) => {
-    const ref = useRef(null);
-    const handleFocus = (event) => {
-        const wrapper = element ?? ref.current;
-        const focusableElements = wrapper?.querySelectorAll([
-            'a[href]',
-            'button',
-            'textarea',
-            'input',
-            'input[type="text"]',
-            'input[type="radio"]',
-            'input[type="checkbox"]',
-            'select',
-        ].join(', '));
-        const firstFocusableEl = focusableElements?.[0];
-        const lastFocusableEl = focusableElements?.[focusableElements.length - 1];
-        const isTabPressed = event.key === 'Tab';
-        if (!isTabPressed) {
-            return;
-        }
-        // Handle: shift + tab
-        if (event.shiftKey) {
-            if (document.activeElement === firstFocusableEl) {
-                lastFocusableEl?.focus();
-                event.preventDefault();
-            }
-            return;
-        }
-        // Handle: tab
-        if (document.activeElement === lastFocusableEl) {
-            firstFocusableEl?.focus();
-            event.preventDefault();
-        }
+import { useRef as c, useEffect as a } from "react";
+const p = (r) => {
+  const t = c(null), s = (e) => {
+    const n = (r ?? t.current)?.querySelectorAll(
+      [
+        "a[href]",
+        "button",
+        "textarea",
+        "input",
+        'input[type="text"]',
+        'input[type="radio"]',
+        'input[type="checkbox"]',
+        "select"
+      ].join(", ")
+    ), o = n?.[0], u = n?.[n.length - 1];
+    if (e.key === "Tab") {
+      if (e.shiftKey) {
+        document.activeElement === o && (u?.focus(), e.preventDefault());
+        return;
+      }
+      document.activeElement === u && (o?.focus(), e.preventDefault());
+    }
+  };
+  return a(() => {
+    const e = r ?? t.current;
+    return e && e.addEventListener("keydown", s), () => {
+      e && e.removeEventListener("keydown", s);
     };
-    useEffect(() => {
-        const wrapper = element ?? ref.current;
-        if (wrapper) {
-            wrapper.addEventListener('keydown', handleFocus);
-        }
-        return () => {
-            if (wrapper) {
-                wrapper.removeEventListener('keydown', handleFocus);
-            }
-        };
-    }, [ref.current, element]);
-    return ref;
+  }, [t.current, r]), t;
 };
-export default useFocusTrap;
+export {
+  p as default
+};
+//# sourceMappingURL=useFocusTrap.js.map

package/hooks/useFocusTrap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFocusTrap.js","sources":["../../src/hooks/useFocusTrap.ts"],"sourcesContent":["import type React from 'react';\nimport { useEffect, useRef } from 'react';\n\n/**\n * This custom hook allows to keep the focus inside a defined wrapper element.\n * This might be a dialog or a custom overlay.\n *\n * This hook can be used in two ways:\n * - When you have a external component that will be re-rendered after the overlay opens, you can use\n *   the built-in ref. This ref will be returned from this hook and can be set on the respective wrapper element.\n * - When you have an element that does not re-render, use a state setter function to set as the ref.\n *   This element can then be passed as a parameter to this hook and it will be used instead of the built-in ref.\n *\n * @param element Optional parameter to pass in the existing DOM reference. Use this instead of the built-in ref.\n * @returns\n */\nconst useFocusTrap = <T extends HTMLElement>(element?: HTMLDivElement | null) => {\n    const ref = useRef<HTMLDivElement>(null);\n\n    const handleFocus = (event: React.KeyboardEvent<T>) => {\n        const wrapper = element ?? ref.current;\n        const focusableElements = wrapper?.querySelectorAll(\n            [\n                'a[href]',\n                'button',\n                'textarea',\n                'input',\n                'input[type=\"text\"]',\n                'input[type=\"radio\"]',\n                'input[type=\"checkbox\"]',\n                'select',\n            ].join(', ')\n        );\n\n        const firstFocusableEl = focusableElements?.[0] as HTMLElement | undefined;\n        const lastFocusableEl = focusableElements?.[focusableElements.length - 1] as HTMLElement | undefined;\n\n        const isTabPressed = event.key === 'Tab';\n\n        if (!isTabPressed) {\n            return;\n        }\n\n        // Handle: shift + tab\n        if (event.shiftKey) {\n            if (document.activeElement === firstFocusableEl) {\n                lastFocusableEl?.focus();\n                event.preventDefault();\n            }\n            return;\n        }\n\n        // Handle: tab\n        if (document.activeElement === lastFocusableEl) {\n            firstFocusableEl?.focus();\n            event.preventDefault();\n        }\n    };\n\n    useEffect(() => {\n        const wrapper = element ?? ref.current;\n\n        if (wrapper) {\n            wrapper.addEventListener('keydown', handleFocus as unknown as EventListener);\n        }\n\n        return () => {\n            if (wrapper) {\n                wrapper.removeEventListener('keydown', handleFocus as unknown as EventListener);\n            }\n        };\n    }, [ref.current, element]);\n\n    return ref;\n};\n\nexport default useFocusTrap;\n"],"names":["useFocusTrap","element","ref","useRef","handleFocus","event","focusableElements","firstFocusableEl","lastFocusableEl","useEffect","wrapper"],"mappings":";AAgBA,MAAMA,IAAe,CAAwBC,MAAoC;AAC7E,QAAMC,IAAMC,EAAuB,IAAI,GAEjCC,IAAc,CAACC,MAAkC;AAEnD,UAAMC,KADUL,KAAWC,EAAI,UACI;AAAA,MAC/B;AAAA,QACI;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MAAA,EACF,KAAK,IAAI;AAAA,IAAA,GAGTK,IAAmBD,IAAoB,CAAC,GACxCE,IAAkBF,IAAoBA,EAAkB,SAAS,CAAC;AAIxE,QAFqBD,EAAM,QAAQ,OAOnC;AAAA,UAAIA,EAAM,UAAU;AAChB,QAAI,SAAS,kBAAkBE,MAC3BC,GAAiB,MAAA,GACjBH,EAAM,eAAA;AAEV;AAAA,MACJ;AAGA,MAAI,SAAS,kBAAkBG,MAC3BD,GAAkB,MAAA,GAClBF,EAAM,eAAA;AAAA;AAAA,EAEd;AAEA,SAAAI,EAAU,MAAM;AACZ,UAAMC,IAAUT,KAAWC,EAAI;AAE/B,WAAIQ,KACAA,EAAQ,iBAAiB,WAAWN,CAAuC,GAGxE,MAAM;AACT,MAAIM,KACAA,EAAQ,oBAAoB,WAAWN,CAAuC;AAAA,IAEtF;AAAA,EACJ,GAAG,CAACF,EAAI,SAASD,CAAO,CAAC,GAElBC;AACX;"}

package/hooks/useFreezePiiData.js

@@ -1,22 +1,14 @@
-import { useEffect } from 'react';
-const useFreezePiiData = () => {
-    useEffect(() => {
-        // Für alle Elemente mit data-pii='visible'
-        const elems = document.querySelectorAll("[data-pii='visible']");
-        for (const el of elems) {
-            let currentValue = null;
-            if ('value' in el && el.value) {
-                currentValue = el.value;
-                el.setAttribute('data-frozen-pii-data', currentValue);
-                el.value = currentValue;
-            }
-            else if (el.textContent) {
-                currentValue = el.textContent;
-                el.setAttribute('data-frozen-pii-data', currentValue);
-                // biome-ignore lint/correctness/noSelfAssign: <explanation>
-                el.textContent = currentValue;
-            }
-        }
-    }, []);
+import { useEffect as i } from "react";
+const n = () => {
+  i(() => {
+    const a = document.querySelectorAll("[data-pii='visible']");
+    for (const e of a) {
+      let t = null;
+      "value" in e && e.value ? (t = e.value, e.setAttribute("data-frozen-pii-data", t), e.value = t) : e.textContent && (t = e.textContent, e.setAttribute("data-frozen-pii-data", t), e.textContent = t);
+    }
+  }, []);
 };
-export default useFreezePiiData;
+export {
+  n as default
+};
+//# sourceMappingURL=useFreezePiiData.js.map

package/hooks/useFreezePiiData.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFreezePiiData.js","sources":["../../src/hooks/useFreezePiiData.ts"],"sourcesContent":["import { useEffect } from 'react';\n\nconst useFreezePiiData = () => {\n    useEffect(() => {\n        // Für alle Elemente mit data-pii='visible'\n        const elems = document.querySelectorAll<HTMLElement>(\"[data-pii='visible']\");\n        for (const el of elems) {\n            let currentValue: string | null = null;\n            if ('value' in el && (el as HTMLInputElement).value) {\n                currentValue = (el as HTMLInputElement).value;\n                el.setAttribute('data-frozen-pii-data', currentValue);\n                (el as HTMLInputElement).value = currentValue;\n            } else if (el.textContent) {\n                currentValue = el.textContent;\n                el.setAttribute('data-frozen-pii-data', currentValue);\n                // biome-ignore lint/correctness/noSelfAssign: <explanation>\n                el.textContent = currentValue;\n            }\n        }\n    }, []);\n};\n\nexport default useFreezePiiData;\n"],"names":["useFreezePiiData","useEffect","elems","el","currentValue"],"mappings":";AAEA,MAAMA,IAAmB,MAAM;AAC3B,EAAAC,EAAU,MAAM;AAEZ,UAAMC,IAAQ,SAAS,iBAA8B,sBAAsB;AAC3E,eAAWC,KAAMD,GAAO;AACpB,UAAIE,IAA8B;AAClC,MAAI,WAAWD,KAAOA,EAAwB,SAC1CC,IAAgBD,EAAwB,OACxCA,EAAG,aAAa,wBAAwBC,CAAY,GACnDD,EAAwB,QAAQC,KAC1BD,EAAG,gBACVC,IAAeD,EAAG,aAClBA,EAAG,aAAa,wBAAwBC,CAAY,GAEpDD,EAAG,cAAcC;AAAA,IAEzB;AAAA,EACJ,GAAG,CAAA,CAAE;AACT;"}

package/hooks/useFullscreen.js

@@ -1,135 +1,71 @@
-// inspired by https://github.com/imbhargav5/rooks/blob/main/src/hooks/useFullscreen.ts
-import { useState, useCallback } from 'react';
-import { noop } from 'es-toolkit/compat';
-import useEvent from "./useEvent.js";
-const defaultValue = {
-    requestFullscreen: noop,
-    exitFullscreen: noop,
-    toggleFullscreen: noop,
-    isFullscreen: false,
-    isEnabled: false,
-};
-const requestFunctions = [
-    'requestFullscreen',
-    'webkitRequestFullscreen',
-    'webkitRequestFullScreen',
-    'mozRequestFullScreen',
-];
-const exitFunctions = ['exitFullscreen', 'webkitExitFullscreen', 'webkitCancelFullScreen', 'mozCancelFullScreen'];
-const fullscreenElementFunctions = [
-    'fullscreenElement',
-    'webkitFullscreenElement',
-    'webkitCurrentFullScreenElement',
-    'mozFullScreenElement',
-];
-const isFullscreenEnabledFunctions = [
-    'fullscreenElement',
-    'webkitFullscreenEnabled',
-    'webkitCurrentFullScreenElement',
-    'mozFullScreenEnabled',
-];
-const getFnName = (fnMap, targetElement) => fnMap.find(fnName => {
-    if (fnName in targetElement) {
-        return true;
+import { useState as h, useCallback as m } from "react";
+import { noop as F } from "es-toolkit/compat";
+import t from "./useEvent.js";
+const z = {
+  requestFullscreen: F,
+  exitFullscreen: F,
+  toggleFullscreen: F,
+  isFullscreen: !1,
+  isEnabled: !1
+}, v = [
+  "requestFullscreen",
+  "webkitRequestFullscreen",
+  "webkitRequestFullScreen",
+  "mozRequestFullScreen"
+], R = ["exitFullscreen", "webkitExitFullscreen", "webkitCancelFullScreen", "mozCancelFullScreen"], B = [
+  "fullscreenElement",
+  "webkitFullscreenElement",
+  "webkitCurrentFullScreenElement",
+  "mozFullScreenElement"
+], H = [
+  "fullscreenElement",
+  "webkitFullscreenEnabled",
+  "webkitCurrentFullScreenElement",
+  "mozFullScreenEnabled"
+], u = (n, l) => n.find((o) => o in l), I = (n = document) => u(v, n), L = () => u(R, document), k = () => {
+  const n = u(B, document);
+  return n ? document[n] : null;
+}, M = () => u(H, document), A = (n = {}) => {
+  if (typeof window > "u")
+    return console.warn("useFullscreen: window is undefined."), z;
+  const { element: l, onChange: o, onError: S, requestFullscreenOptions: N = {} } = n, p = !l || !(l instanceof HTMLElement) ? document.querySelector("html") : l, f = k(), [x, d] = h(!!f), [c, E] = h(f), w = m(async (e) => {
+    const s = e instanceof HTMLElement;
+    try {
+      const r = e && s ? e : p, q = I(r);
+      if (q)
+        return await r[q](N);
+      throw new Error("Request function not found");
+    } catch (r) {
+      console.log(r);
     }
-    return false;
-});
-// Element centered fullscreen functions
-const getRequestFunctionName = (targetElement = document) => getFnName(requestFunctions, targetElement);
-// Document fullscreen functions
-const getExitFunctionName = () => getFnName(exitFunctions, document);
-const getFullscreenElementFunctionName = () => {
-    const fullscreenFunctionName = getFnName(fullscreenElementFunctions, document);
-    const initialFullscreenElement = fullscreenFunctionName
-        ? document[fullscreenFunctionName]
-        : null;
-    return initialFullscreenElement;
-};
-const getIsFullscreenEnabledFunctionName = () => getFnName(isFullscreenEnabledFunctions, document);
-/**
- * Custom hook to manage fullscreen functionality.
- *
- * @param options - Options for managing fullscreen behavior.
- */
-const useFullscreen = (options = {}) => {
-    if (typeof window === 'undefined') {
-        console.warn('useFullscreen: window is undefined.');
-        return defaultValue;
+  }, []), b = m(async () => {
+    try {
+      const e = L();
+      if (c && e)
+        return await document[e]();
+    } catch (e) {
+      console.warn(e);
     }
-    const { element, onChange, onError, requestFullscreenOptions = {} } = options;
-    // use either a defined target or when document is set, use the html element as in Chrome the
-    // document does not have a request function. It needs to be an element.
-    const defaultFullscreenElement = !element || !(element instanceof HTMLElement) ? document.querySelector('html') : element;
-    const initialFullscreenElement = getFullscreenElementFunctionName();
-    const [isFullscreen, setIsFullscreen] = useState(Boolean(initialFullscreenElement));
-    const [fullscreenElement, setFullscreenElement] = useState(initialFullscreenElement);
-    // Request
-    const requestFullscreen = useCallback(async (newTargetElement) => {
-        // check whether the new target element is a real DOM node or just a function
-        const isHtmlElement = newTargetElement instanceof HTMLElement;
-        try {
-            const target = newTargetElement && isHtmlElement ? newTargetElement : defaultFullscreenElement;
-            const requestFunctionName = getRequestFunctionName(target);
-            if (requestFunctionName) {
-                return await target[requestFunctionName](requestFullscreenOptions);
-            }
-            throw new Error('Request function not found');
-        }
-        catch (error) {
-            console.log(error);
-        }
-    }, []);
-    // Exit
-    const exitFullscreen = useCallback(async () => {
-        try {
-            const exitFunctionName = getExitFunctionName();
-            if (fullscreenElement && exitFunctionName) {
-                return await document[exitFunctionName]();
-            }
-        }
-        catch (error) {
-            console.warn(error);
-        }
-    }, [fullscreenElement]);
-    // Toggle
-    const toggleFullscreen = useCallback((newTargetElement) => {
-        if (fullscreenElement) {
-            exitFullscreen();
-        }
-        else {
-            requestFullscreen(newTargetElement);
-        }
-    }, [fullscreenElement]);
-    const handleChangeEvent = () => {
-        const currentFullscreenElement = getFullscreenElementFunctionName();
-        const isOpen = Boolean(currentFullscreenElement);
-        if (isOpen) {
-            // fullscreen was enabled
-            setIsFullscreen(true);
-            setFullscreenElement(currentFullscreenElement);
-        }
-        else {
-            // fullscreen was disabled
-            setIsFullscreen(false);
-            setFullscreenElement(null);
-        }
-        onChange?.call(document, event || new Event('default'), isOpen);
-    };
-    const handleErrorEvent = () => (event) => onError?.call(document, event);
-    useEvent('fullscreenchange', handleChangeEvent);
-    useEvent('webkitfullscreenchange', handleChangeEvent);
-    useEvent('mozfullscreenchange', handleChangeEvent);
-    useEvent('fullscreenerror', handleErrorEvent);
-    useEvent('webkitfullscreenerror', handleErrorEvent);
-    useEvent('mozfullscreenerror', handleErrorEvent);
-    const enabledFunctionName = getIsFullscreenEnabledFunctionName();
-    const isEnabled = enabledFunctionName ? Boolean(document[enabledFunctionName]) : false;
-    return {
-        requestFullscreen,
-        exitFullscreen,
-        toggleFullscreen,
-        isFullscreen,
-        isEnabled,
-    };
+  }, [c]), C = m(
+    (e) => {
+      c ? b() : w(e);
+    },
+    [c]
+  ), i = () => {
+    const e = k(), s = !!e;
+    s ? (d(!0), E(e)) : (d(!1), E(null)), o?.call(document, event || new Event("default"), s);
+  }, a = () => (e) => S?.call(document, e);
+  t("fullscreenchange", i), t("webkitfullscreenchange", i), t("mozfullscreenchange", i), t("fullscreenerror", a), t("webkitfullscreenerror", a), t("mozfullscreenerror", a);
+  const g = M(), y = g ? !!document[g] : !1;
+  return {
+    requestFullscreen: w,
+    exitFullscreen: b,
+    toggleFullscreen: C,
+    isFullscreen: x,
+    isEnabled: y
+  };
+};
+export {
+  A as default
 };
-export default useFullscreen;
+//# sourceMappingURL=useFullscreen.js.map

package/hooks/useFullscreen.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFullscreen.js","sources":["../../src/hooks/useFullscreen.ts"],"sourcesContent":["// inspired by https://github.com/imbhargav5/rooks/blob/main/src/hooks/useFullscreen.ts\n\nimport { useState, useCallback } from 'react';\nimport { noop } from 'es-toolkit/compat';\n\nimport useEvent from './useEvent';\n\ntype EventCallback = (this: Document, event_: Event) => void;\n\ntype OnChangeEventCallback = (this: Document, event_: Event, isOpen: boolean) => void;\n\ntype RequestFullscreenOptions = {\n    // string will help to ease type casting\n    navigationUI?: string | 'auto' | 'hide' | 'show';\n};\n\ntype FullScreenOptions = {\n    element?: HTMLElement;\n    onChange?: OnChangeEventCallback;\n    onError?: EventCallback;\n    requestFullscreenOptions?: RequestFullscreenOptions;\n};\n\ntype FullscreenApi = {\n    requestFullscreen: VoidFunction | ((element?: HTMLElement | null) => Promise<unknown>);\n    exitFullscreen: VoidFunction | (() => Promise<unknown>);\n    toggleFullscreen: VoidFunction | ((element?: HTMLElement) => Promise<unknown>);\n    isEnabled: boolean;\n    isFullscreen: boolean;\n};\n\nconst defaultValue: FullscreenApi = {\n    requestFullscreen: noop,\n    exitFullscreen: noop,\n    toggleFullscreen: noop,\n    isFullscreen: false,\n    isEnabled: false,\n};\n\ntype FullscreenDocument = Document & {\n    fullscreenElement?: Element;\n    webkitFullscreenElement?: Element;\n    webkitCurrentFullScreenElement?: Element;\n    mozFullScreenElement?: Element;\n};\n\ntype FullscreenElement = HTMLElement & {\n    requestFullscreen?: Element['requestFullscreen'];\n    webkitRequestFullscreen?: Element['requestFullscreen'];\n    webkitRequestFullScreen?: Element['requestFullscreen'];\n    mozRequestFullScreen?: Element['requestFullscreen'];\n    msRequestFullscreen?: Element['requestFullscreen'];\n};\n\nconst requestFunctions = [\n    'requestFullscreen',\n    'webkitRequestFullscreen',\n    'webkitRequestFullScreen',\n    'mozRequestFullScreen',\n];\n\nconst exitFunctions = ['exitFullscreen', 'webkitExitFullscreen', 'webkitCancelFullScreen', 'mozCancelFullScreen'];\n\nconst fullscreenElementFunctions = [\n    'fullscreenElement',\n    'webkitFullscreenElement',\n    'webkitCurrentFullScreenElement',\n    'mozFullScreenElement',\n];\n\nconst isFullscreenEnabledFunctions = [\n    'fullscreenElement',\n    'webkitFullscreenEnabled',\n    'webkitCurrentFullScreenElement',\n    'mozFullScreenEnabled',\n];\n\nconst getFnName = (fnMap: string[], targetElement: Element | Document) =>\n    fnMap.find(fnName => {\n        if (fnName in targetElement) {\n            return true;\n        }\n        return false;\n    });\n\n// Element centered fullscreen functions\nconst getRequestFunctionName = (targetElement: Element | Document = document) =>\n    getFnName(requestFunctions, targetElement);\n\n// Document fullscreen functions\nconst getExitFunctionName = () => getFnName(exitFunctions, document);\n\nconst getFullscreenElementFunctionName = () => {\n    const fullscreenFunctionName = getFnName(fullscreenElementFunctions, document);\n    const initialFullscreenElement = fullscreenFunctionName\n        ? (document as FullscreenDocument)[fullscreenFunctionName as keyof FullscreenDocument]\n        : null;\n    return initialFullscreenElement;\n};\n\nconst getIsFullscreenEnabledFunctionName = () => getFnName(isFullscreenEnabledFunctions, document);\n\n/**\n * Custom hook to manage fullscreen functionality.\n *\n * @param options - Options for managing fullscreen behavior.\n */\nconst useFullscreen = (options: FullScreenOptions = {}) => {\n    if (typeof window === 'undefined') {\n        console.warn('useFullscreen: window is undefined.');\n        return defaultValue;\n    }\n    const { element, onChange, onError, requestFullscreenOptions = {} } = options;\n\n    // use either a defined target or when document is set, use the html element as in Chrome the\n    // document does not have a request function. It needs to be an element.\n    const defaultFullscreenElement =\n        !element || !(element instanceof HTMLElement) ? (document.querySelector('html') as HTMLElement) : element;\n\n    const initialFullscreenElement = getFullscreenElementFunctionName();\n\n    const [isFullscreen, setIsFullscreen] = useState(Boolean(initialFullscreenElement));\n    const [fullscreenElement, setFullscreenElement] = useState(initialFullscreenElement);\n\n    // Request\n    const requestFullscreen = useCallback(async (newTargetElement: any) => {\n        // check whether the new target element is a real DOM node or just a function\n        const isHtmlElement = newTargetElement instanceof HTMLElement;\n        try {\n            const target = newTargetElement && isHtmlElement ? newTargetElement : defaultFullscreenElement;\n            const requestFunctionName = getRequestFunctionName(target);\n            if (requestFunctionName) {\n                return await (target as any)[requestFunctionName](requestFullscreenOptions);\n            }\n            throw new Error('Request function not found');\n        } catch (error) {\n            console.log(error);\n        }\n    }, []);\n\n    // Exit\n    const exitFullscreen = useCallback(async () => {\n        try {\n            const exitFunctionName = getExitFunctionName();\n            if (fullscreenElement && exitFunctionName) {\n                return await (document as any)[exitFunctionName]();\n            }\n        } catch (error) {\n            console.warn(error);\n        }\n    }, [fullscreenElement]);\n\n    // Toggle\n    const toggleFullscreen = useCallback(\n        (newTargetElement: any) => {\n            if (fullscreenElement) {\n                exitFullscreen();\n            } else {\n                requestFullscreen(newTargetElement);\n            }\n        },\n        [fullscreenElement]\n    );\n\n    const handleChangeEvent = () => {\n        const currentFullscreenElement = getFullscreenElementFunctionName();\n\n        const isOpen = Boolean(currentFullscreenElement);\n\n        if (isOpen) {\n            // fullscreen was enabled\n            setIsFullscreen(true);\n            setFullscreenElement(currentFullscreenElement);\n        } else {\n            // fullscreen was disabled\n            setIsFullscreen(false);\n            setFullscreenElement(null);\n        }\n        onChange?.call(document, event || new Event('default'), isOpen);\n    };\n\n    const handleErrorEvent = () => (event: Event) => onError?.call(document, event);\n\n    useEvent('fullscreenchange', handleChangeEvent);\n    useEvent('webkitfullscreenchange', handleChangeEvent);\n    useEvent('mozfullscreenchange', handleChangeEvent);\n\n    useEvent('fullscreenerror', handleErrorEvent);\n    useEvent('webkitfullscreenerror', handleErrorEvent);\n    useEvent('mozfullscreenerror', handleErrorEvent);\n\n    const enabledFunctionName = getIsFullscreenEnabledFunctionName();\n    const isEnabled = enabledFunctionName ? Boolean((document as any)[enabledFunctionName]) : false;\n\n    return {\n        requestFullscreen,\n        exitFullscreen,\n        toggleFullscreen,\n        isFullscreen,\n        isEnabled,\n    };\n};\n\nexport default useFullscreen;\n"],"names":["defaultValue","noop","requestFunctions","exitFunctions","fullscreenElementFunctions","isFullscreenEnabledFunctions","getFnName","fnMap","targetElement","fnName","getRequestFunctionName","getExitFunctionName","getFullscreenElementFunctionName","fullscreenFunctionName","getIsFullscreenEnabledFunctionName","useFullscreen","options","element","onChange","onError","requestFullscreenOptions","defaultFullscreenElement","initialFullscreenElement","isFullscreen","setIsFullscreen","useState","fullscreenElement","setFullscreenElement","requestFullscreen","useCallback","newTargetElement","isHtmlElement","target","requestFunctionName","error","exitFullscreen","exitFunctionName","toggleFullscreen","handleChangeEvent","currentFullscreenElement","isOpen","handleErrorEvent","event","useEvent","enabledFunctionName","isEnabled"],"mappings":"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"}

package/hooks/useHover.d.ts

@@ -1,4 +1,4 @@
-import { type RefObject } from 'react';
+import { RefObject } from 'react';
 /**
  * Custom hook to detect hover state for a given HTML element.
  *

package/hooks/useHover.js

@@ -1,34 +1,13 @@
-import { useEffect, useState } from 'react';
-/**
- * Custom hook to detect hover state for a given HTML element.
- *
- * @param elementRef - The reference to the HTML element.
- * @returns A boolean value representing whether the element is being hovered over or not.
- */
-const useHover = (elementRef) => {
-    const [value, setValue] = useState(false);
-    const handleMouseEnter = () => setValue(true);
-    const handleMouseLeave = () => setValue(false);
-    useEffect(() => {
-        if (elementRef.current) {
-            elementRef.current.addEventListener('mouseenter', handleMouseEnter);
-        }
-        return () => {
-            if (elementRef.current) {
-                elementRef.current.removeEventListener('mouseenter', handleMouseEnter);
-            }
-        };
-    }, [elementRef.current]);
-    useEffect(() => {
-        if (elementRef.current) {
-            elementRef.current.addEventListener('mouseleave', handleMouseLeave);
-        }
-        return () => {
-            if (elementRef.current) {
-                elementRef.current.removeEventListener('mouseleave', handleMouseLeave);
-            }
-        };
-    }, [elementRef.current]);
-    return value;
+import { useState as o, useEffect as n } from "react";
+const a = (r) => {
+  const [s, t] = o(!1), e = () => t(!0), u = () => t(!1);
+  return n(() => (r.current && r.current.addEventListener("mouseenter", e), () => {
+    r.current && r.current.removeEventListener("mouseenter", e);
+  }), [r.current]), n(() => (r.current && r.current.addEventListener("mouseleave", u), () => {
+    r.current && r.current.removeEventListener("mouseleave", u);
+  }), [r.current]), s;
 };
-export default useHover;
+export {
+  a as default
+};
+//# sourceMappingURL=useHover.js.map

package/hooks/useHover.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useHover.js","sources":["../../src/hooks/useHover.ts"],"sourcesContent":["import { type RefObject, useEffect, useState } from 'react';\n\n/**\n * Custom hook to detect hover state for a given HTML element.\n *\n * @param elementRef - The reference to the HTML element.\n * @returns A boolean value representing whether the element is being hovered over or not.\n */\nconst useHover = <T extends HTMLElement = HTMLElement>(elementRef: RefObject<T>): boolean => {\n    const [value, setValue] = useState<boolean>(false);\n\n    const handleMouseEnter = () => setValue(true);\n    const handleMouseLeave = () => setValue(false);\n\n    useEffect(() => {\n        if (elementRef.current) {\n            elementRef.current.addEventListener('mouseenter', handleMouseEnter);\n        }\n        return () => {\n            if (elementRef.current) {\n                elementRef.current.removeEventListener('mouseenter', handleMouseEnter);\n            }\n        };\n    }, [elementRef.current]);\n\n    useEffect(() => {\n        if (elementRef.current) {\n            elementRef.current.addEventListener('mouseleave', handleMouseLeave);\n        }\n        return () => {\n            if (elementRef.current) {\n                elementRef.current.removeEventListener('mouseleave', handleMouseLeave);\n            }\n        };\n    }, [elementRef.current]);\n\n    return value;\n};\n\nexport default useHover;\n"],"names":["useHover","elementRef","value","setValue","useState","handleMouseEnter","handleMouseLeave","useEffect"],"mappings":";AAQA,MAAMA,IAAW,CAAsCC,MAAsC;AACzF,QAAM,CAACC,GAAOC,CAAQ,IAAIC,EAAkB,EAAK,GAE3CC,IAAmB,MAAMF,EAAS,EAAI,GACtCG,IAAmB,MAAMH,EAAS,EAAK;AAE7C,SAAAI,EAAU,OACFN,EAAW,WACXA,EAAW,QAAQ,iBAAiB,cAAcI,CAAgB,GAE/D,MAAM;AACT,IAAIJ,EAAW,WACXA,EAAW,QAAQ,oBAAoB,cAAcI,CAAgB;AAAA,EAE7E,IACD,CAACJ,EAAW,OAAO,CAAC,GAEvBM,EAAU,OACFN,EAAW,WACXA,EAAW,QAAQ,iBAAiB,cAAcK,CAAgB,GAE/D,MAAM;AACT,IAAIL,EAAW,WACXA,EAAW,QAAQ,oBAAoB,cAAcK,CAAgB;AAAA,EAE7E,IACD,CAACL,EAAW,OAAO,CAAC,GAEhBC;AACX;"}

package/hooks/useIncomingPostMessages.d.ts

@@ -0,0 +1,49 @@
+type MessageHandler = (event: MessageEvent<unknown>) => void;
+type OriginFilteredMessageHandler = {
+    origin: string;
+    handler: MessageHandler;
+};
+type ActionMessageHandler = (payload: any) => void;
+type ActionMessageHandlerDeclaration = {
+    origin?: string;
+    handlers: Record<string, ActionMessageHandler>;
+};
+type IncomingPostMessageOption = MessageHandler | OriginFilteredMessageHandler | ActionMessageHandlerDeclaration;
+/**
+ * A hook for handling incoming postMessage events.
+ *
+ * Can be used in three ways, based on your requirements:
+ * 1. Raw handler: Direct access to MessageEvent
+ * 2. Origin-filtered handler: Only handle messages from specific origin
+ * 3. Action-based handlers: Route messages by type and extract payloads
+ *
+ * The idea behind action-based handlers is that you can declaratively define listeners that only react to specific
+ * events that belong to a specific `type` of message event when the event looks like a {@link ActionMessage}.
+ *
+ * @param option Configuration object or function defining how to handle messages
+ *
+ * @example
+ * // Raw handler
+ * useIncomingPostMessages((event) => {
+ *   console.log('Received:', event.data);
+ * });
+ *
+ * @example
+ * // Origin-filtered handler
+ * useIncomingPostMessages({
+ *   origin: 'https://trusted-domain.com',
+ *   handler: (event) => console.log('From trusted origin:', event.data)
+ * });
+ *
+ * @example
+ * // Action-based handlers
+ * useIncomingPostMessages({
+ *   origin: 'https://widget-domain.com', // optional, defaults to '*'
+ *   handlers: {
+ *     'WIDGET_READY': () => setWidgetReady(true), // actions without payload are possible, too
+ *     'WIDGET_DATA': (payload) => setData(payload), // utilizing the payload
+ *   }
+ * });
+ */
+export declare const useIncomingPostMessages: (option: IncomingPostMessageOption) => void;
+export {};

package/hooks/useInterval.js

@@ -1,26 +1,15 @@
-import { useEffect, useRef } from 'react';
-// See https://overreacted.io/making-setinterval-declarative-with-react-hooks/
-/**
- * Custom hook to execute a callback function at specified intervals.
- *
- * @param callback - The callback function to be executed.
- * @param delay - The interval duration in milliseconds. Set to null to stop the interval.
- *
- * @returns A mutable ref object that holds the interval ID.
- */
-const useInterval = (callback, delay) => {
-    const intervalRef = useRef(null);
-    const savedCallback = useRef(callback);
-    useEffect(() => {
-        savedCallback.current = callback;
-    }, [callback]);
-    useEffect(() => {
-        const tick = () => savedCallback.current();
-        if (typeof delay === 'number') {
-            intervalRef.current = window.setInterval(tick, delay);
-            return () => window.clearInterval(intervalRef.current ?? undefined);
-        }
-    }, [delay]);
-    return intervalRef;
+import { useRef as u, useEffect as o } from "react";
+const f = (e, r) => {
+  const t = u(null), n = u(e);
+  return o(() => {
+    n.current = e;
+  }, [e]), o(() => {
+    const s = () => n.current();
+    if (typeof r == "number")
+      return t.current = window.setInterval(s, r), () => window.clearInterval(t.current ?? void 0);
+  }, [r]), t;
 };
-export default useInterval;
+export {
+  f as default
+};
+//# sourceMappingURL=useInterval.js.map

package/hooks/useInterval.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useInterval.js","sources":["../../src/hooks/useInterval.ts"],"sourcesContent":["import { useEffect, useRef } from 'react';\n\n// See https://overreacted.io/making-setinterval-declarative-with-react-hooks/\n\n/**\n * Custom hook to execute a callback function at specified intervals.\n *\n * @param callback - The callback function to be executed.\n * @param delay - The interval duration in milliseconds. Set to null to stop the interval.\n *\n * @returns A mutable ref object that holds the interval ID.\n */\nconst useInterval = (callback: () => void, delay: number | null): React.MutableRefObject<number | null> => {\n    const intervalRef = useRef<number | null>(null);\n    const savedCallback = useRef<() => void>(callback);\n\n    useEffect(() => {\n        savedCallback.current = callback;\n    }, [callback]);\n\n    useEffect(() => {\n        const tick = () => savedCallback.current();\n\n        if (typeof delay === 'number') {\n            intervalRef.current = window.setInterval(tick, delay);\n            return () => window.clearInterval(intervalRef.current ?? undefined);\n        }\n    }, [delay]);\n\n    return intervalRef;\n};\n\nexport default useInterval;\n"],"names":["useInterval","callback","delay","intervalRef","useRef","savedCallback","useEffect","tick"],"mappings":";AAYA,MAAMA,IAAc,CAACC,GAAsBC,MAAgE;AACvG,QAAMC,IAAcC,EAAsB,IAAI,GACxCC,IAAgBD,EAAmBH,CAAQ;AAEjD,SAAAK,EAAU,MAAM;AACZ,IAAAD,EAAc,UAAUJ;AAAA,EAC5B,GAAG,CAACA,CAAQ,CAAC,GAEbK,EAAU,MAAM;AACZ,UAAMC,IAAO,MAAMF,EAAc,QAAA;AAEjC,QAAI,OAAOH,KAAU;AACjB,aAAAC,EAAY,UAAU,OAAO,YAAYI,GAAML,CAAK,GAC7C,MAAM,OAAO,cAAcC,EAAY,WAAW,MAAS;AAAA,EAE1E,GAAG,CAACD,CAAK,CAAC,GAEHC;AACX;"}