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

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;"}

package/hooks/useIsFirstRender.js

@@ -1,10 +1,9 @@
-import { useRef } from 'react';
-const useIsFirstRender = () => {
-    const renderRef = useRef(true);
-    if (renderRef.current === true) {
-        renderRef.current = false;
-        return true;
-    }
-    return renderRef.current;
+import { useRef as e } from "react";
+const u = () => {
+  const r = e(!0);
+  return r.current === !0 ? (r.current = !1, !0) : r.current;
 };
-export default useIsFirstRender;
+export {
+  u as default
+};
+//# sourceMappingURL=useIsFirstRender.js.map

package/hooks/useIsFirstRender.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useIsFirstRender.js","sources":["../../src/hooks/useIsFirstRender.ts"],"sourcesContent":["import { useRef } from 'react';\n\nconst useIsFirstRender = () => {\n    const renderRef = useRef(true);\n\n    if (renderRef.current === true) {\n        renderRef.current = false;\n        return true;\n    }\n\n    return renderRef.current;\n};\n\nexport default useIsFirstRender;\n"],"names":["useIsFirstRender","renderRef","useRef"],"mappings":";AAEA,MAAMA,IAAmB,MAAM;AAC3B,QAAMC,IAAYC,EAAO,EAAI;AAE7B,SAAID,EAAU,YAAY,MACtBA,EAAU,UAAU,IACb,MAGJA,EAAU;AACrB;"}

package/hooks/useIsFocusWithin.d.ts

@@ -27,7 +27,7 @@ type UseIsFocusWithinOptions<T extends HTMLElement> = {
  * @returns An object containing the ref and whether focus is currently within the element.
  */
 declare const useIsFocusWithin: <T extends HTMLElement>({ ref: externalRef, onFocusWithin, onBlurWithin, delay, }?: UseIsFocusWithinOptions<T>) => {
-    ref: import("react").RefObject<T>;
+    ref: import('react').RefObject<T>;
     isFocusedWithin: boolean;
 };
 export default useIsFocusWithin;

package/hooks/useIsFocusWithin.js

@@ -1,55 +1,35 @@
-import { useEffect, useRef, useState } from 'react';
-/**
- * React hook that tracks whether focus is currently within a given element or its children.
- * Provides a boolean state and a ref to attach to the tracked element.
- *
- * @param options Hook configuration including external ref, callbacks, and optional delay.
- * @returns An object containing the ref and whether focus is currently within the element.
- */
-const useIsFocusWithin = ({ ref: externalRef, onFocusWithin = () => { }, onBlurWithin = () => { }, delay = 0, } = {}) => {
-    const internalRef = useRef(null);
-    const targetRef = externalRef ?? internalRef;
-    const [isFocusedWithin, setIsFocusedWithin] = useState(false);
-    const timeoutId = useRef(null);
-    const clearTimeoutIfAny = () => {
-        if (timeoutId.current !== null) {
-            window.clearTimeout(timeoutId.current);
-            timeoutId.current = null;
-        }
+import { useRef as a, useState as E, useEffect as I } from "react";
+const F = ({
+  ref: d,
+  onFocusWithin: u = () => {
+  },
+  onBlurWithin: o = () => {
+  },
+  delay: c = 0
+} = {}) => {
+  const m = a(null), n = d ?? m, [r, i] = E(!1), t = a(null), s = () => {
+    t.current !== null && (window.clearTimeout(t.current), t.current = null);
+  };
+  return I(() => {
+    const e = n.current;
+    if (!e)
+      return;
+    const f = () => {
+      s(), r || (i(!0), u());
+    }, l = (v) => {
+      s(), t.current = window.setTimeout(() => {
+        e.contains(v.relatedTarget) || (i(!1), o()), t.current = null;
+      }, c);
     };
-    useEffect(() => {
-        const node = targetRef.current;
-        if (!node) {
-            return;
-        }
-        const handleFocusIn = () => {
-            clearTimeoutIfAny();
-            if (!isFocusedWithin) {
-                setIsFocusedWithin(true);
-                onFocusWithin();
-            }
-        };
-        const handleFocusOut = (e) => {
-            clearTimeoutIfAny();
-            timeoutId.current = window.setTimeout(() => {
-                if (!node.contains(e.relatedTarget)) {
-                    setIsFocusedWithin(false);
-                    onBlurWithin();
-                }
-                timeoutId.current = null;
-            }, delay);
-        };
-        node.addEventListener('focusin', handleFocusIn);
-        node.addEventListener('focusout', handleFocusOut);
-        return () => {
-            node.removeEventListener('focusin', handleFocusIn);
-            node.removeEventListener('focusout', handleFocusOut);
-            clearTimeoutIfAny();
-        };
-    }, [targetRef, delay, onFocusWithin, onBlurWithin, isFocusedWithin]);
-    return {
-        ref: targetRef,
-        isFocusedWithin,
+    return e.addEventListener("focusin", f), e.addEventListener("focusout", l), () => {
+      e.removeEventListener("focusin", f), e.removeEventListener("focusout", l), s();
     };
+  }, [n, c, u, o, r]), {
+    ref: n,
+    isFocusedWithin: r
+  };
 };
-export default useIsFocusWithin;
+export {
+  F as default
+};
+//# sourceMappingURL=useIsFocusWithin.js.map

package/hooks/useIsFocusWithin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useIsFocusWithin.js","sources":["../../src/hooks/useIsFocusWithin.ts"],"sourcesContent":["import { useEffect, useRef, useState } from 'react';\n\ntype UseIsFocusWithinOptions<T extends HTMLElement> = {\n    /**\n     * Optional external ref to the DOM element to track.\n     * If not provided, the hook will return its own internal ref.\n     */\n    ref?: React.RefObject<T>;\n\n    /**\n     * Optional callback triggered when focus enters the element or its children.\n     */\n    onFocusWithin?: () => void;\n\n    /**\n     * Optional callback triggered when focus leaves the element and all its children.\n     */\n    onBlurWithin?: () => void;\n\n    /**\n     * Optional delay (in ms) before calling onBlurWithin.\n     * Useful when focus might quickly shift between internal elements.\n     * @default 0\n     */\n    delay?: number;\n};\n\n/**\n * React hook that tracks whether focus is currently within a given element or its children.\n * Provides a boolean state and a ref to attach to the tracked element.\n *\n * @param options Hook configuration including external ref, callbacks, and optional delay.\n * @returns An object containing the ref and whether focus is currently within the element.\n */\nconst useIsFocusWithin = <T extends HTMLElement>({\n    ref: externalRef,\n    onFocusWithin = () => {},\n    onBlurWithin = () => {},\n    delay = 0,\n}: UseIsFocusWithinOptions<T> = {}) => {\n    const internalRef = useRef<T>(null);\n    const targetRef = externalRef ?? internalRef;\n\n    const [isFocusedWithin, setIsFocusedWithin] = useState(false);\n    const timeoutId = useRef<number | null>(null);\n\n    const clearTimeoutIfAny = () => {\n        if (timeoutId.current !== null) {\n            window.clearTimeout(timeoutId.current);\n            timeoutId.current = null;\n        }\n    };\n\n    useEffect(() => {\n        const node = targetRef.current;\n        if (!node) {\n            return;\n        }\n\n        const handleFocusIn = () => {\n            clearTimeoutIfAny();\n            if (!isFocusedWithin) {\n                setIsFocusedWithin(true);\n                onFocusWithin();\n            }\n        };\n\n        const handleFocusOut = (e: FocusEvent) => {\n            clearTimeoutIfAny();\n            timeoutId.current = window.setTimeout(() => {\n                if (!node.contains(e.relatedTarget as Node)) {\n                    setIsFocusedWithin(false);\n                    onBlurWithin();\n                }\n                timeoutId.current = null;\n            }, delay);\n        };\n\n        node.addEventListener('focusin', handleFocusIn);\n        node.addEventListener('focusout', handleFocusOut);\n\n        return () => {\n            node.removeEventListener('focusin', handleFocusIn);\n            node.removeEventListener('focusout', handleFocusOut);\n            clearTimeoutIfAny();\n        };\n    }, [targetRef, delay, onFocusWithin, onBlurWithin, isFocusedWithin]);\n\n    return {\n        ref: targetRef,\n        isFocusedWithin,\n    };\n};\n\nexport default useIsFocusWithin;\n"],"names":["useIsFocusWithin","externalRef","onFocusWithin","onBlurWithin","delay","internalRef","useRef","targetRef","isFocusedWithin","setIsFocusedWithin","useState","timeoutId","clearTimeoutIfAny","useEffect","node","handleFocusIn","handleFocusOut","e"],"mappings":";AAkCA,MAAMA,IAAmB,CAAwB;AAAA,EAC7C,KAAKC;AAAA,EACL,eAAAC,IAAgB,MAAM;AAAA,EAAC;AAAA,EACvB,cAAAC,IAAe,MAAM;AAAA,EAAC;AAAA,EACtB,OAAAC,IAAQ;AACZ,IAAgC,OAAO;AACnC,QAAMC,IAAcC,EAAU,IAAI,GAC5BC,IAAYN,KAAeI,GAE3B,CAACG,GAAiBC,CAAkB,IAAIC,EAAS,EAAK,GACtDC,IAAYL,EAAsB,IAAI,GAEtCM,IAAoB,MAAM;AAC5B,IAAID,EAAU,YAAY,SACtB,OAAO,aAAaA,EAAU,OAAO,GACrCA,EAAU,UAAU;AAAA,EAE5B;AAEA,SAAAE,EAAU,MAAM;AACZ,UAAMC,IAAOP,EAAU;AACvB,QAAI,CAACO;AACD;AAGJ,UAAMC,IAAgB,MAAM;AACxB,MAAAH,EAAA,GACKJ,MACDC,EAAmB,EAAI,GACvBP,EAAA;AAAA,IAER,GAEMc,IAAiB,CAACC,MAAkB;AACtC,MAAAL,EAAA,GACAD,EAAU,UAAU,OAAO,WAAW,MAAM;AACxC,QAAKG,EAAK,SAASG,EAAE,aAAqB,MACtCR,EAAmB,EAAK,GACxBN,EAAA,IAEJQ,EAAU,UAAU;AAAA,MACxB,GAAGP,CAAK;AAAA,IACZ;AAEA,WAAAU,EAAK,iBAAiB,WAAWC,CAAa,GAC9CD,EAAK,iBAAiB,YAAYE,CAAc,GAEzC,MAAM;AACT,MAAAF,EAAK,oBAAoB,WAAWC,CAAa,GACjDD,EAAK,oBAAoB,YAAYE,CAAc,GACnDJ,EAAA;AAAA,IACJ;AAAA,EACJ,GAAG,CAACL,GAAWH,GAAOF,GAAeC,GAAcK,CAAe,CAAC,GAE5D;AAAA,IACH,KAAKD;AAAA,IACL,iBAAAC;AAAA,EAAA;AAER;"}

package/hooks/useKey.js

@@ -1,49 +1,25 @@
-import { useEffect, useRef } from 'react';
-/**
- * Custom hook to handle keyboard events.
- *
- * @param keyOrCallback - Either a key string (e.g., 'Enter') or a callback function.
- * @param callbackOrEventTypes - If the first argument is a key, this should be the callback function.
- *                               If the first argument is a callback, this is an optional array of event types.
- * @param [eventTypesOrNode=['keydown']] - If the first argument is a key, this should be an array of event types.
- *                                         If the first argument is a callback, this is the node (defaults to document).
- * @param [node=document] - Optional DOM node to attach the event listener to (defaults to document).
- */
-const useKey = (keyOrCallback, callbackOrEventTypes, eventTypesOrNode = ['keydown'], node = document) => {
-    const callbacksRef = useRef([]);
-    useEffect(() => {
-        const isKeyMode = typeof keyOrCallback === 'string';
-        const callback = isKeyMode
-            ? callbackOrEventTypes
-            : keyOrCallback;
-        const keyHandler = (event) => {
-            if (isKeyMode) {
-                if (event.key === keyOrCallback) {
-                    callback(event);
-                }
-            }
-            else {
-                callback(event);
-            }
-        };
-        // Register the keyHandler
-        callbacksRef.current.push(keyHandler);
-        const genericHandler = (event) => {
-            for (const callBecky of callbacksRef.current) {
-                callBecky(event);
-            }
-        };
-        const eventTypes = Array.isArray(eventTypesOrNode) ? eventTypesOrNode : ['keydown'];
-        for (const eventType of eventTypes) {
-            node.addEventListener(eventType, genericHandler);
-        }
-        return () => {
-            for (const eventType of eventTypes) {
-                node.removeEventListener(eventType, genericHandler);
-            }
-            // Clean up callback reference
-            callbacksRef.current = callbacksRef.current.filter(singleCallback => singleCallback !== keyHandler);
-        };
-    }, [keyOrCallback, callbackOrEventTypes, eventTypesOrNode, node]);
+import { useRef as a, useEffect as m } from "react";
+const l = (t, s, r = ["keydown"], o = document) => {
+  const n = a([]);
+  m(() => {
+    const c = typeof t == "string", f = c ? s : t, u = (e) => {
+      c ? e.key === t && f(e) : f(e);
+    };
+    n.current.push(u);
+    const i = (e) => {
+      for (const d of n.current)
+        d(e);
+    }, y = Array.isArray(r) ? r : ["keydown"];
+    for (const e of y)
+      o.addEventListener(e, i);
+    return () => {
+      for (const e of y)
+        o.removeEventListener(e, i);
+      n.current = n.current.filter((e) => e !== u);
+    };
+  }, [t, s, r, o]);
 };
-export default useKey;
+export {
+  l as default
+};
+//# sourceMappingURL=useKey.js.map

package/hooks/useKey.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useKey.js","sources":["../../src/hooks/useKey.ts"],"sourcesContent":["import { useEffect, useRef } from 'react';\n\ntype KeyboardEventType = 'keyup' | 'keydown' | 'keypress';\n\n/**\n * Custom hook to handle keyboard events.\n *\n * @param keyOrCallback - Either a key string (e.g., 'Enter') or a callback function.\n * @param callbackOrEventTypes - If the first argument is a key, this should be the callback function.\n *                               If the first argument is a callback, this is an optional array of event types.\n * @param [eventTypesOrNode=['keydown']] - If the first argument is a key, this should be an array of event types.\n *                                         If the first argument is a callback, this is the node (defaults to document).\n * @param [node=document] - Optional DOM node to attach the event listener to (defaults to document).\n */\nconst useKey = (\n    keyOrCallback: string | ((event: KeyboardEvent) => void),\n    callbackOrEventTypes?: (event: KeyboardEvent) => void | KeyboardEventType[],\n    eventTypesOrNode: KeyboardEventType[] | Document = ['keydown'],\n    node: Document | HTMLElement = document\n) => {\n    const callbacksRef = useRef<((event: KeyboardEvent) => void)[]>([]);\n\n    useEffect(() => {\n        const isKeyMode = typeof keyOrCallback === 'string';\n\n        const callback = isKeyMode\n            ? (callbackOrEventTypes as (event: KeyboardEvent) => void)\n            : (keyOrCallback as (event: KeyboardEvent) => void);\n\n        const keyHandler = (event: KeyboardEvent) => {\n            if (isKeyMode) {\n                if (event.key === keyOrCallback) {\n                    callback(event);\n                }\n            } else {\n                callback(event);\n            }\n        };\n\n        // Register the keyHandler\n        callbacksRef.current.push(keyHandler);\n\n        const genericHandler = (event: KeyboardEvent) => {\n            for (const callBecky of callbacksRef.current) {\n                callBecky(event);\n            }\n        };\n\n        const eventTypes = Array.isArray(eventTypesOrNode) ? (eventTypesOrNode as KeyboardEventType[]) : ['keydown'];\n\n        for (const eventType of eventTypes) {\n            node.addEventListener(eventType, genericHandler as EventListener);\n        }\n\n        return () => {\n            for (const eventType of eventTypes) {\n                node.removeEventListener(eventType, genericHandler as EventListener);\n            }\n            // Clean up callback reference\n            callbacksRef.current = callbacksRef.current.filter(singleCallback => singleCallback !== keyHandler);\n        };\n    }, [keyOrCallback, callbackOrEventTypes, eventTypesOrNode, node]);\n};\n\nexport default useKey;\n"],"names":["useKey","keyOrCallback","callbackOrEventTypes","eventTypesOrNode","node","callbacksRef","useRef","useEffect","isKeyMode","callback","keyHandler","event","genericHandler","callBecky","eventTypes","eventType","singleCallback"],"mappings":";AAcA,MAAMA,IAAS,CACXC,GACAC,GACAC,IAAmD,CAAC,SAAS,GAC7DC,IAA+B,aAC9B;AACD,QAAMC,IAAeC,EAA2C,EAAE;AAElE,EAAAC,EAAU,MAAM;AACZ,UAAMC,IAAY,OAAOP,KAAkB,UAErCQ,IAAWD,IACVN,IACAD,GAEDS,IAAa,CAACC,MAAyB;AACzC,MAAIH,IACIG,EAAM,QAAQV,KACdQ,EAASE,CAAK,IAGlBF,EAASE,CAAK;AAAA,IAEtB;AAGA,IAAAN,EAAa,QAAQ,KAAKK,CAAU;AAEpC,UAAME,IAAiB,CAACD,MAAyB;AAC7C,iBAAWE,KAAaR,EAAa;AACjC,QAAAQ,EAAUF,CAAK;AAAA,IAEvB,GAEMG,IAAa,MAAM,QAAQX,CAAgB,IAAKA,IAA2C,CAAC,SAAS;AAE3G,eAAWY,KAAaD;AACpB,MAAAV,EAAK,iBAAiBW,GAAWH,CAA+B;AAGpE,WAAO,MAAM;AACT,iBAAWG,KAAaD;AACpB,QAAAV,EAAK,oBAAoBW,GAAWH,CAA+B;AAGvE,MAAAP,EAAa,UAAUA,EAAa,QAAQ,OAAO,CAAAW,MAAkBA,MAAmBN,CAAU;AAAA,IACtG;AAAA,EACJ,GAAG,CAACT,GAAeC,GAAsBC,GAAkBC,CAAI,CAAC;AACpE;"}

package/hooks/useLocationSuggestions.js

@@ -1,94 +1,50 @@
-import { useEffect, useRef, useState } from 'react';
-import { debounce } from 'es-toolkit/function';
-const DEFAULT_URL = 'https://autocomplete.search.hereapi.com/v1/autocomplete';
-const fetchLocationSuggestions = async (query, signal, options = {}) => {
-    const { apiKey, fetchUrl = DEFAULT_URL, limit = 5, ...restOptions } = options;
-    if (!query || !apiKey) {
-        return [];
+import { useState as m, useRef as h, useEffect as p } from "react";
+import { debounce as b } from "es-toolkit/function";
+const E = "https://autocomplete.search.hereapi.com/v1/autocomplete", w = async (r, e, l = {}) => {
+  const { apiKey: s, fetchUrl: u = E, limit: o = 5, ...f } = l;
+  if (!r || !s)
+    return [];
+  const a = new URLSearchParams({
+    q: r,
+    apiKey: s,
+    limit: String(o),
+    // Add any additional options dynamically
+    ...f
+  }), t = await fetch(`${u}?${a.toString()}`, { signal: e });
+  if (!t.ok)
+    throw new Error(`API request failed with status ${t.status}`);
+  const n = await t.json();
+  return Array.isArray(n?.items) ? n.items.map((c) => ({
+    id: c.id,
+    label: c.title
+  })) : [];
+}, S = 300, L = (r, e = {}) => {
+  const [l, s] = m([]), [u, o] = m(!1), [f, a] = m(null), t = h(null), n = h(
+    b(async (c, d) => {
+      t.current?.abort();
+      const g = new AbortController();
+      t.current = g, a(null);
+      try {
+        const i = await w(c, g.signal, d);
+        s(i);
+      } catch (i) {
+        i.name !== "AbortError" && a(i), s([]);
+      } finally {
+        o(!1);
+      }
+    }, S)
+  ).current;
+  return p(() => {
+    if (!r || !e.apiKey) {
+      s([]), o(!1), t.current?.abort();
+      return;
     }
-    const params = new URLSearchParams({
-        q: query,
-        apiKey,
-        limit: String(limit),
-        // Add any additional options dynamically
-        ...restOptions,
-    });
-    const response = await fetch(`${fetchUrl}?${params.toString()}`, { signal });
-    if (!response.ok) {
-        // Throw an error for bad responses (4xx, 5xx)
-        // This allows the hook's catch block to handle API errors
-        throw new Error(`API request failed with status ${response.status}`);
-    }
-    const data = await response.json();
-    // Ensure data.items exists and is an array before mapping
-    return Array.isArray(data?.items)
-        ? data.items.map((item) => ({
-            id: item.id,
-            label: item.title,
-        }))
-        : [];
+    o(!0), n(r, e);
+  }, [r, n, e.apiKey, e.fetchUrl]), p(() => () => {
+    t.current?.abort();
+  }, []), { suggestions: l, loading: u, error: f };
 };
-const FETCH_DEBOUNCE_IN_MS = 300;
-/**
- * Custom React hook for fetching location suggestions using HERE Maps Autocomplete API.
- *
- * @param query - The user input string to search for location suggestions.
- * @param options - Optional configuration:
- *   - apiKey: Your HERE Maps API key (default is 'YOUR_API_KEY').
- *   - fetchUrl: Optional override for the autocomplete endpoint URL.
- * @returns An object containing:
- *   - suggestions: Array of location suggestions with `id` and `label`.
- *   - loading: Boolean indicating whether the fetch is in progress.
- *   - error: Any error that occurred during fetching.
- */
-const useLocationSuggestions = (query, options = {}) => {
-    const [suggestions, setSuggestions] = useState([]);
-    const [loading, setLoading] = useState(false);
-    const [error, setError] = useState(null);
-    const abortRef = useRef(null);
-    // React re-renders the component every time state or props change. If we define the debounce() call
-    // directly inside the component without useRef, we'll create a new debounced function on every render,
-    // which defeats the purpose of debouncing.
-    // By wrapping it in useRef, we ensure the debounced function is created only once and persists between renders
-    const debouncedFetch = useRef(debounce(async (currentQuery, currentOptions) => {
-        // Abort any ongoing request from previous calls
-        abortRef.current?.abort();
-        const controller = new AbortController();
-        abortRef.current = controller;
-        // Reset error before a new fetch attempt
-        setError(null);
-        try {
-            const results = await fetchLocationSuggestions(currentQuery, controller.signal, currentOptions);
-            setSuggestions(results);
-        }
-        catch (fetchError) {
-            if (fetchError.name !== 'AbortError') {
-                setError(fetchError);
-            }
-            setSuggestions([]);
-        }
-        finally {
-            setLoading(false);
-        }
-    }, FETCH_DEBOUNCE_IN_MS)).current;
-    // biome-ignore lint/correctness/useExhaustiveDependencies: <explanation>
-    useEffect(() => {
-        if (!query || !options.apiKey) {
-            setSuggestions([]);
-            setLoading(false);
-            // Abort if there was an ongoing request
-            abortRef.current?.abort();
-            return;
-        }
-        setLoading(true);
-        debouncedFetch(query, options);
-    }, [query, debouncedFetch, options.apiKey, options.fetchUrl]); // `debouncedFetch` is stable due to useRef
-    // Cleanup on unmount
-    useEffect(() => {
-        return () => {
-            abortRef.current?.abort();
-        };
-    }, []);
-    return { suggestions, loading, error };
+export {
+  L as default
 };
-export default useLocationSuggestions;
+//# sourceMappingURL=useLocationSuggestions.js.map

package/hooks/useLocationSuggestions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLocationSuggestions.js","sources":["../../src/hooks/useLocationSuggestions.ts"],"sourcesContent":["import { useEffect, useRef, useState } from 'react';\nimport { debounce } from 'es-toolkit/function';\n\nexport type LocationSuggestion = {\n    id: string;\n    label: string;\n};\n\n// See API documentation - https://www.here.com/docs/bundle/geocoding-and-search-api-v7-api-reference/page/index.html#/paths/~1autocomplete/get\nexport type LocationFetchOptions = Record<string, unknown> & {\n    apiKey?: string;\n    fetchUrl?: string;\n    limit?: number; // Default by Here API is set to 5; Maximum is 20\n};\n\nconst DEFAULT_URL = 'https://autocomplete.search.hereapi.com/v1/autocomplete';\n\nconst fetchLocationSuggestions = async (\n    query: string,\n    signal: AbortSignal,\n    options: LocationFetchOptions = {}\n): Promise<LocationSuggestion[]> => {\n    const { apiKey, fetchUrl = DEFAULT_URL, limit = 5, ...restOptions } = options;\n\n    if (!query || !apiKey) {\n        return [];\n    }\n\n    const params = new URLSearchParams({\n        q: query,\n        apiKey,\n        limit: String(limit),\n\n        // Add any additional options dynamically\n        ...restOptions,\n    });\n\n    const response = await fetch(`${fetchUrl}?${params.toString()}`, { signal });\n\n    if (!response.ok) {\n        // Throw an error for bad responses (4xx, 5xx)\n        // This allows the hook's catch block to handle API errors\n        throw new Error(`API request failed with status ${response.status}`);\n    }\n\n    const data = await response.json();\n\n    // Ensure data.items exists and is an array before mapping\n    return Array.isArray(data?.items)\n        ? data.items.map((item: any) => ({\n              id: item.id,\n              label: item.title,\n          }))\n        : [];\n};\n\nconst FETCH_DEBOUNCE_IN_MS = 300;\n\n/**\n * Custom React hook for fetching location suggestions using HERE Maps Autocomplete API.\n *\n * @param query - The user input string to search for location suggestions.\n * @param options - Optional configuration:\n *   - apiKey: Your HERE Maps API key (default is 'YOUR_API_KEY').\n *   - fetchUrl: Optional override for the autocomplete endpoint URL.\n * @returns An object containing:\n *   - suggestions: Array of location suggestions with `id` and `label`.\n *   - loading: Boolean indicating whether the fetch is in progress.\n *   - error: Any error that occurred during fetching.\n */\nconst useLocationSuggestions = (query: string, options: LocationFetchOptions = {}) => {\n    const [suggestions, setSuggestions] = useState<LocationSuggestion[]>([]);\n\n    const [loading, setLoading] = useState(false);\n    const [error, setError] = useState<Error | null>(null);\n\n    const abortRef = useRef<AbortController | null>(null);\n\n    // React re-renders the component every time state or props change. If we define the debounce() call\n    // directly inside the component without useRef, we'll create a new debounced function on every render,\n    // which defeats the purpose of debouncing.\n    // By wrapping it in useRef, we ensure the debounced function is created only once and persists between renders\n    const debouncedFetch = useRef(\n        debounce(async (currentQuery: string, currentOptions: LocationFetchOptions) => {\n            // Abort any ongoing request from previous calls\n            abortRef.current?.abort();\n\n            const controller = new AbortController();\n            abortRef.current = controller;\n\n            // Reset error before a new fetch attempt\n            setError(null);\n\n            try {\n                const results = await fetchLocationSuggestions(currentQuery, controller.signal, currentOptions);\n                setSuggestions(results);\n            } catch (fetchError) {\n                if ((fetchError as any).name !== 'AbortError') {\n                    setError(fetchError as Error);\n                }\n                setSuggestions([]);\n            } finally {\n                setLoading(false);\n            }\n        }, FETCH_DEBOUNCE_IN_MS)\n    ).current;\n\n    // biome-ignore lint/correctness/useExhaustiveDependencies: <explanation>\n    useEffect(() => {\n        if (!query || !options.apiKey) {\n            setSuggestions([]);\n            setLoading(false);\n            // Abort if there was an ongoing request\n            abortRef.current?.abort();\n            return;\n        }\n\n        setLoading(true);\n        debouncedFetch(query, options);\n    }, [query, debouncedFetch, options.apiKey, options.fetchUrl]); // `debouncedFetch` is stable due to useRef\n\n    // Cleanup on unmount\n    useEffect(() => {\n        return () => {\n            abortRef.current?.abort();\n        };\n    }, []);\n\n    return { suggestions, loading, error };\n};\n\nexport default useLocationSuggestions;\n"],"names":["DEFAULT_URL","fetchLocationSuggestions","query","signal","options","apiKey","fetchUrl","limit","restOptions","params","response","data","item","FETCH_DEBOUNCE_IN_MS","useLocationSuggestions","suggestions","setSuggestions","useState","loading","setLoading","error","setError","abortRef","useRef","debouncedFetch","debounce","currentQuery","currentOptions","controller","results","fetchError","useEffect"],"mappings":";;AAeA,MAAMA,IAAc,2DAEdC,IAA2B,OAC7BC,GACAC,GACAC,IAAgC,CAAA,MACA;AAChC,QAAM,EAAE,QAAAC,GAAQ,UAAAC,IAAWN,GAAa,OAAAO,IAAQ,GAAG,GAAGC,MAAgBJ;AAEtE,MAAI,CAACF,KAAS,CAACG;AACX,WAAO,CAAA;AAGX,QAAMI,IAAS,IAAI,gBAAgB;AAAA,IAC/B,GAAGP;AAAA,IACH,QAAAG;AAAA,IACA,OAAO,OAAOE,CAAK;AAAA;AAAA,IAGnB,GAAGC;AAAA,EAAA,CACN,GAEKE,IAAW,MAAM,MAAM,GAAGJ,CAAQ,IAAIG,EAAO,SAAA,CAAU,IAAI,EAAE,QAAAN,EAAA,CAAQ;AAE3E,MAAI,CAACO,EAAS;AAGV,UAAM,IAAI,MAAM,kCAAkCA,EAAS,MAAM,EAAE;AAGvE,QAAMC,IAAO,MAAMD,EAAS,KAAA;AAG5B,SAAO,MAAM,QAAQC,GAAM,KAAK,IAC1BA,EAAK,MAAM,IAAI,CAACC,OAAe;AAAA,IAC3B,IAAIA,EAAK;AAAA,IACT,OAAOA,EAAK;AAAA,EAAA,EACd,IACF,CAAA;AACV,GAEMC,IAAuB,KAcvBC,IAAyB,CAACZ,GAAeE,IAAgC,OAAO;AAClF,QAAM,CAACW,GAAaC,CAAc,IAAIC,EAA+B,CAAA,CAAE,GAEjE,CAACC,GAASC,CAAU,IAAIF,EAAS,EAAK,GACtC,CAACG,GAAOC,CAAQ,IAAIJ,EAAuB,IAAI,GAE/CK,IAAWC,EAA+B,IAAI,GAM9CC,IAAiBD;AAAA,IACnBE,EAAS,OAAOC,GAAsBC,MAAyC;AAE3E,MAAAL,EAAS,SAAS,MAAA;AAElB,YAAMM,IAAa,IAAI,gBAAA;AACvB,MAAAN,EAAS,UAAUM,GAGnBP,EAAS,IAAI;AAEb,UAAI;AACA,cAAMQ,IAAU,MAAM5B,EAAyByB,GAAcE,EAAW,QAAQD,CAAc;AAC9F,QAAAX,EAAea,CAAO;AAAA,MAC1B,SAASC,GAAY;AACjB,QAAKA,EAAmB,SAAS,gBAC7BT,EAASS,CAAmB,GAEhCd,EAAe,CAAA,CAAE;AAAA,MACrB,UAAA;AACI,QAAAG,EAAW,EAAK;AAAA,MACpB;AAAA,IACJ,GAAGN,CAAoB;AAAA,EAAA,EACzB;AAGF,SAAAkB,EAAU,MAAM;AACZ,QAAI,CAAC7B,KAAS,CAACE,EAAQ,QAAQ;AAC3B,MAAAY,EAAe,CAAA,CAAE,GACjBG,EAAW,EAAK,GAEhBG,EAAS,SAAS,MAAA;AAClB;AAAA,IACJ;AAEA,IAAAH,EAAW,EAAI,GACfK,EAAetB,GAAOE,CAAO;AAAA,EACjC,GAAG,CAACF,GAAOsB,GAAgBpB,EAAQ,QAAQA,EAAQ,QAAQ,CAAC,GAG5D2B,EAAU,MACC,MAAM;AACT,IAAAT,EAAS,SAAS,MAAA;AAAA,EACtB,GACD,CAAA,CAAE,GAEE,EAAE,aAAAP,GAAa,SAAAG,GAAS,OAAAE,EAAA;AACnC;"}

package/hooks/useMax.js

@@ -1,24 +1,16 @@
-import { useMemo } from 'react';
-import { parseNumberFromValue, getValueByPath } from "../utils/formatUtils.js";
-/**
- * Finds the maximum numeric value from a list of objects.
- * Values are extracted using a dot-separated path and parsed with locale awareness.
- *
- * @param items - The list of objects to evaluate.
- * @param path - Dot-separated path to the value in each object.
- * @param options - Optional configuration (e.g. locale for number parsing).
- * @returns The largest of all valid values, or 0 if none are valid.
- */
-const useMax = (items, path, options = {}) => {
-    const { locale = 'en-GB' } = options;
-    return useMemo(() => {
-        const values = items
-            .map(item => {
-            const valueFromPath = getValueByPath(item, path);
-            return parseNumberFromValue(valueFromPath, locale);
-        })
-            .filter(num => !Number.isNaN(num));
-        return values.length > 0 ? Math.max(...values) : 0;
-    }, [items, path, locale]);
+import { useMemo as l } from "react";
+import { getValueByPath as n, parseNumberFromValue as s } from "../utils/formatUtils.js";
+const p = (r, t, u = {}) => {
+  const { locale: a = "en-GB" } = u;
+  return l(() => {
+    const o = r.map((e) => {
+      const m = n(e, t);
+      return s(m, a);
+    }).filter((e) => !Number.isNaN(e));
+    return o.length > 0 ? Math.max(...o) : 0;
+  }, [r, t, a]);
 };
-export default useMax;
+export {
+  p as default
+};
+//# sourceMappingURL=useMax.js.map

package/hooks/useMax.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMax.js","sources":["../../src/hooks/useMax.ts"],"sourcesContent":["import { useMemo } from 'react';\n\nimport { parseNumberFromValue, getValueByPath } from '../utils/formatUtils';\n\nexport type UseMaxOptions = {\n    /**\n     * The locale used to parse localized number formats (e.g. \"de-DE\", \"en-GB\").\n     * @default \"en-GB\".\n     */\n    locale?: string;\n};\n\n/**\n * Finds the maximum numeric value from a list of objects.\n * Values are extracted using a dot-separated path and parsed with locale awareness.\n *\n * @param items - The list of objects to evaluate.\n * @param path - Dot-separated path to the value in each object.\n * @param options - Optional configuration (e.g. locale for number parsing).\n * @returns The largest of all valid values, or 0 if none are valid.\n */\nconst useMax = (items: unknown[], path: string, options: UseMaxOptions = {}): number => {\n    const { locale = 'en-GB' } = options;\n\n    return useMemo(() => {\n        const values = items\n            .map(item => {\n                const valueFromPath = getValueByPath(item, path);\n                return parseNumberFromValue(valueFromPath, locale);\n            })\n            .filter(num => !Number.isNaN(num));\n\n        return values.length > 0 ? Math.max(...values) : 0;\n    }, [items, path, locale]);\n};\n\nexport default useMax;\n"],"names":["useMax","items","path","options","locale","useMemo","values","item","valueFromPath","getValueByPath","parseNumberFromValue","num"],"mappings":";;AAqBA,MAAMA,IAAS,CAACC,GAAkBC,GAAcC,IAAyB,CAAA,MAAe;AACpF,QAAM,EAAE,QAAAC,IAAS,QAAA,IAAYD;AAE7B,SAAOE,EAAQ,MAAM;AACjB,UAAMC,IAASL,EACV,IAAI,CAAAM,MAAQ;AACT,YAAMC,IAAgBC,EAAeF,GAAML,CAAI;AAC/C,aAAOQ,EAAqBF,GAAeJ,CAAM;AAAA,IACrD,CAAC,EACA,OAAO,CAAAO,MAAO,CAAC,OAAO,MAAMA,CAAG,CAAC;AAErC,WAAOL,EAAO,SAAS,IAAI,KAAK,IAAI,GAAGA,CAAM,IAAI;AAAA,EACrD,GAAG,CAACL,GAAOC,GAAME,CAAM,CAAC;AAC5B;"}

package/hooks/useMergeRefs.d.ts

@@ -1,4 +1,4 @@
-import type React from 'react';
+import { default as React } from 'react';
 export type ReactRef<T> = React.RefCallback<T> | React.MutableRefObject<T>;
 /**
  * Custom hook to merge multiple React references into a single callback ref.

package/hooks/useMergeRefs.js

@@ -1,46 +1,22 @@
-// forked from https://github.com/chakra-ui/chakra-ui/blob/main/packages/hooks/use-merge-refs/src/index.ts
-import { useMemo } from 'react';
-/**
- * Assigns a value to a React reference.
- *
- * @param ref - The React reference to assign the value to.
- * @param value - The value to assign to the reference.
- */
-const assignRef = (ref, value) => {
-    if (ref == null) {
-        return;
-    }
-    if (typeof ref === 'function') {
-        ref(value);
-        return;
+import { useMemo as e } from "react";
+const o = (r, t) => {
+  if (r != null) {
+    if (typeof r == "function") {
+      r(t);
+      return;
     }
     try {
-        ref.current = value;
-    }
-    catch (error) {
-        throw new Error(`Cannot assign value '${value}' to ref '${ref}'`);
+      r.current = t;
+    } catch {
+      throw new Error(`Cannot assign value '${t}' to ref '${r}'`);
     }
+  }
+}, s = (...r) => (t) => {
+  r.forEach((n) => {
+    o(n, t);
+  });
+}, c = (...r) => e(() => s(...r), r);
+export {
+  c as default
 };
-/**
- * Merges multiple React references into a single callback ref.
- *
- * @param refs - The React references to merge.
- * @returns A callback function to assign the merged references to a node.
- */
-const mergeRefs = (...refs) => {
-    return (node) => {
-        refs.forEach(ref => {
-            assignRef(ref, node);
-        });
-    };
-};
-/**
- * Custom hook to merge multiple React references into a single callback ref.
- *
- * @param refs - The React references to merge.
- * @returns A memoized callback function to assign the merged references to a node.
- */
-const useMergeRefs = (...refs) => {
-    return useMemo(() => mergeRefs(...refs), refs);
-};
-export default useMergeRefs;
+//# sourceMappingURL=useMergeRefs.js.map

package/hooks/useMergeRefs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMergeRefs.js","sources":["../../src/hooks/useMergeRefs.ts"],"sourcesContent":["// forked from https://github.com/chakra-ui/chakra-ui/blob/main/packages/hooks/use-merge-refs/src/index.ts\n\nimport type React from 'react';\nimport { useMemo } from 'react';\n\nexport type ReactRef<T> = React.RefCallback<T> | React.MutableRefObject<T>;\n\n/**\n * Assigns a value to a React reference.\n *\n * @param ref - The React reference to assign the value to.\n * @param value - The value to assign to the reference.\n */\nconst assignRef = <T = any>(ref: ReactRef<T> | null | undefined, value: T) => {\n    if (ref == null) {\n        return;\n    }\n\n    if (typeof ref === 'function') {\n        ref(value);\n        return;\n    }\n\n    try {\n        ref.current = value;\n    } catch (error) {\n        throw new Error(`Cannot assign value '${value}' to ref '${ref}'`);\n    }\n};\n\n/**\n * Merges multiple React references into a single callback ref.\n *\n * @param refs - The React references to merge.\n * @returns A callback function to assign the merged references to a node.\n */\nconst mergeRefs = <T>(...refs: (ReactRef<T> | null | undefined)[]) => {\n    return (node: T | null) => {\n        refs.forEach(ref => {\n            assignRef(ref, node);\n        });\n    };\n};\n\n/**\n * Custom hook to merge multiple React references into a single callback ref.\n *\n * @param refs - The React references to merge.\n * @returns A memoized callback function to assign the merged references to a node.\n */\nconst useMergeRefs = <T>(...refs: (ReactRef<T> | null | undefined)[]) => {\n    return useMemo(() => mergeRefs(...refs), refs);\n};\n\nexport default useMergeRefs;\n"],"names":["assignRef","ref","value","mergeRefs","refs","node","useMergeRefs","useMemo"],"mappings":";AAaA,MAAMA,IAAY,CAAUC,GAAqCC,MAAa;AAC1E,MAAID,KAAO,MAIX;AAAA,QAAI,OAAOA,KAAQ,YAAY;AAC3B,MAAAA,EAAIC,CAAK;AACT;AAAA,IACJ;AAEA,QAAI;AACA,MAAAD,EAAI,UAAUC;AAAA,IAClB,QAAgB;AACZ,YAAM,IAAI,MAAM,wBAAwBA,CAAK,aAAaD,CAAG,GAAG;AAAA,IACpE;AAAA;AACJ,GAQME,IAAY,IAAOC,MACd,CAACC,MAAmB;AACvB,EAAAD,EAAK,QAAQ,CAAAH,MAAO;AAChB,IAAAD,EAAUC,GAAKI,CAAI;AAAA,EACvB,CAAC;AACL,GASEC,IAAe,IAAOF,MACjBG,EAAQ,MAAMJ,EAAU,GAAGC,CAAI,GAAGA,CAAI;"}

package/hooks/useMin.js

@@ -1,24 +1,16 @@
-import { useMemo } from 'react';
-import { parseNumberFromValue, getValueByPath } from "../utils/formatUtils.js";
-/**
- * Finds the minimum numeric value from a list of objects.
- * Values are extracted using a dot-separated path and parsed with locale awareness.
- *
- * @param items - The list of objects to evaluate.
- * @param path - Dot-separated path to the value in each object.
- * @param options - Optional configuration (e.g. locale for number parsing).
- * @returns The smallest of all valid values, or 0 if none are valid.
- */
-const useMin = (items, path, options = {}) => {
-    const { locale = 'en-GB' } = options;
-    return useMemo(() => {
-        const values = items
-            .map(item => {
-            const valueFromPath = getValueByPath(item, path);
-            return parseNumberFromValue(valueFromPath, locale);
-        })
-            .filter(num => !Number.isNaN(num));
-        return values.length > 0 ? Math.min(...values) : 0;
-    }, [items, path, locale]);
+import { useMemo as m } from "react";
+import { getValueByPath as l, parseNumberFromValue as s } from "../utils/formatUtils.js";
+const f = (r, t, u = {}) => {
+  const { locale: o = "en-GB" } = u;
+  return m(() => {
+    const a = r.map((e) => {
+      const n = l(e, t);
+      return s(n, o);
+    }).filter((e) => !Number.isNaN(e));
+    return a.length > 0 ? Math.min(...a) : 0;
+  }, [r, t, o]);
 };
-export default useMin;
+export {
+  f as default
+};
+//# sourceMappingURL=useMin.js.map

package/hooks/useMin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMin.js","sources":["../../src/hooks/useMin.ts"],"sourcesContent":["import { useMemo } from 'react';\n\nimport { parseNumberFromValue, getValueByPath } from '../utils/formatUtils';\n\nexport type UseMinOptions = {\n    /**\n     * The locale used to parse localized number formats (e.g. \"de-DE\", \"en-GB\").\n     * @default \"en-GB\".\n     */\n    locale?: string;\n};\n\n/**\n * Finds the minimum numeric value from a list of objects.\n * Values are extracted using a dot-separated path and parsed with locale awareness.\n *\n * @param items - The list of objects to evaluate.\n * @param path - Dot-separated path to the value in each object.\n * @param options - Optional configuration (e.g. locale for number parsing).\n * @returns The smallest of all valid values, or 0 if none are valid.\n */\nconst useMin = (items: unknown[], path: string, options: UseMinOptions = {}): number => {\n    const { locale = 'en-GB' } = options;\n\n    return useMemo(() => {\n        const values = items\n            .map(item => {\n                const valueFromPath = getValueByPath(item, path);\n                return parseNumberFromValue(valueFromPath, locale);\n            })\n            .filter(num => !Number.isNaN(num));\n\n        return values.length > 0 ? Math.min(...values) : 0;\n    }, [items, path, locale]);\n};\n\nexport default useMin;\n"],"names":["useMin","items","path","options","locale","useMemo","values","item","valueFromPath","getValueByPath","parseNumberFromValue","num"],"mappings":";;AAqBA,MAAMA,IAAS,CAACC,GAAkBC,GAAcC,IAAyB,CAAA,MAAe;AACpF,QAAM,EAAE,QAAAC,IAAS,QAAA,IAAYD;AAE7B,SAAOE,EAAQ,MAAM;AACjB,UAAMC,IAASL,EACV,IAAI,CAAAM,MAAQ;AACT,YAAMC,IAAgBC,EAAeF,GAAML,CAAI;AAC/C,aAAOQ,EAAqBF,GAAeJ,CAAM;AAAA,IACrD,CAAC,EACA,OAAO,CAAAO,MAAO,CAAC,OAAO,MAAMA,CAAG,CAAC;AAErC,WAAOL,EAAO,SAAS,IAAI,KAAK,IAAI,GAAGA,CAAM,IAAI;AAAA,EACrD,GAAG,CAACL,GAAOC,GAAME,CAAM,CAAC;AAC5B;"}

package/hooks/useMutationObserver.d.ts

@@ -1,4 +1,4 @@
-import { type MutableRefObject } from 'react';
+import { MutableRefObject } from 'react';
 export type Options = {
     attributes?: boolean;
     childList?: boolean;