react-simplikit 0.0.34 → 0.0.36

package/dist/index.cjs

@@ -24,17 +24,25 @@ __export(index_exports, {
   Separated: () => Separated,
   SwitchCase: () => SwitchCase,
   buildContext: () => buildContext,
+  mergeProps: () => mergeProps,
   mergeRefs: () => mergeRefs,
   useAsyncEffect: () => useAsyncEffect,
   useBooleanState: () => useBooleanState,
   useCallbackOncePerRender: () => useCallbackOncePerRender,
+  useControlledState: () => useControlledState,
   useCounter: () => useCounter,
   useDebounce: () => useDebounce,
+  useDebouncedCallback: () => useDebouncedCallback,
+  useDoubleClick: () => useDoubleClick,
+  useGeolocation: () => useGeolocation,
   useImpressionRef: () => useImpressionRef,
   useInputState: () => useInputState,
   useIntersectionObserver: () => useIntersectionObserver,
   useInterval: () => useInterval,
+  useIsomorphicLayoutEffect: () => useIsomorphicLayoutEffect,
   useLoading: () => useLoading,
+  useLongPress: () => useLongPress,
+  useMap: () => useMap,
   useOutsideClickEffect: () => useOutsideClickEffect,
   usePreservedCallback: () => usePreservedCallback,
   usePreservedReference: () => usePreservedReference,
@@ -48,6 +56,9 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/components/ImpressionArea/ImpressionArea.tsx
+var import_react7 = require("react");
+
 // src/hooks/useImpressionRef/useImpressionRef.ts
 var import_react6 = require("react");
 
@@ -291,33 +302,27 @@ function mergeRefs(...refs) {
 
 // src/components/ImpressionArea/ImpressionArea.tsx
 var import_jsx_runtime = require("react/jsx-runtime");
-function ImpressionArea({
-  as,
-  rootMargin,
-  areaThreshold,
-  timeThreshold,
-  onImpressionStart,
-  onImpressionEnd,
-  ref,
-  ...props
-}) {
-  const Component = as ?? "div";
-  const impressionRef = useImpressionRef({
-    onImpressionStart,
-    onImpressionEnd,
-    areaThreshold,
-    timeThreshold,
-    rootMargin
-  });
-  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, { ref: mergeRefs(ref, impressionRef), ...props });
-}
+var ImpressionArea = (0, import_react7.forwardRef)(
+  ({ as, rootMargin, areaThreshold, timeThreshold, onImpressionStart, onImpressionEnd, ...props }, ref) => {
+    const Component = as ?? "div";
+    const impressionRef = useImpressionRef({
+      onImpressionStart,
+      onImpressionEnd,
+      areaThreshold,
+      timeThreshold,
+      rootMargin
+    });
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, { ref: mergeRefs(ref, impressionRef), ...props });
+  }
+);
+ImpressionArea.displayName = "ImpressionArea";
 
 // src/components/Separated/Separated.tsx
-var import_react7 = require("react");
+var import_react8 = require("react");
 var import_jsx_runtime2 = require("react/jsx-runtime");
 function Separated({ children, by: separator }) {
-  const childrenArray = import_react7.Children.toArray(children).filter(import_react7.isValidElement);
-  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_jsx_runtime2.Fragment, { children: childrenArray.map((child, i, { length }) => /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react7.Fragment, { children: [
+  const childrenArray = import_react8.Children.toArray(children).filter(import_react8.isValidElement);
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_jsx_runtime2.Fragment, { children: childrenArray.map((child, i, { length }) => /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react8.Fragment, { children: [
     child,
     i + 1 !== length && separator
   ] }, i)) });
@@ -330,9 +335,9 @@ function SwitchCase({ value, caseBy, defaultComponent = () => null }) {
 }
 
 // src/hooks/useAsyncEffect/useAsyncEffect.ts
-var import_react8 = require("react");
+var import_react9 = require("react");
 function useAsyncEffect(effect, deps) {
-  (0, import_react8.useEffect)(() => {
+  (0, import_react9.useEffect)(() => {
     let cleanup;
     effect().then((result) => {
       cleanup = result;
@@ -344,26 +349,26 @@ function useAsyncEffect(effect, deps) {
 }
 
 // src/hooks/useBooleanState/useBooleanState.ts
-var import_react9 = require("react");
+var import_react10 = require("react");
 function useBooleanState(defaultValue = false) {
-  const [bool, setBool] = (0, import_react9.useState)(defaultValue);
-  const setTrue = (0, import_react9.useCallback)(() => {
+  const [bool, setBool] = (0, import_react10.useState)(defaultValue);
+  const setTrue = (0, import_react10.useCallback)(() => {
     setBool(true);
   }, []);
-  const setFalse = (0, import_react9.useCallback)(() => {
+  const setFalse = (0, import_react10.useCallback)(() => {
     setBool(false);
   }, []);
-  const toggle2 = (0, import_react9.useCallback)(() => {
+  const toggle2 = (0, import_react10.useCallback)(() => {
     setBool((prevBool) => !prevBool);
   }, []);
   return [bool, setTrue, setFalse, toggle2];
 }
 
 // src/hooks/useCallbackOncePerRender/useCallbackOncePerRender.ts
-var import_react10 = require("react");
+var import_react11 = require("react");
 function useCallbackOncePerRender(callback, deps) {
-  const hasFired = (0, import_react10.useRef)(false);
-  (0, import_react10.useEffect)(() => {
+  const hasFired = (0, import_react11.useRef)(false);
+  (0, import_react11.useEffect)(() => {
     hasFired.current = false;
   }, deps);
   return usePreservedCallback((...args) => {
@@ -375,9 +380,36 @@ function useCallbackOncePerRender(callback, deps) {
   });
 }
 
+// src/hooks/useControlledState/useControlledState.ts
+var import_react12 = require("react");
+function useControlledState({
+  value: valueProp,
+  defaultValue,
+  onChange,
+  equalityFn = Object.is
+}) {
+  const [uncontrolledState, setUncontrolledState] = (0, import_react12.useState)(defaultValue);
+  const controlled = valueProp !== void 0;
+  const value = controlled ? valueProp : uncontrolledState;
+  const setValue = (0, import_react12.useCallback)(
+    (next) => {
+      const nextValue = isSetStateAction(next) ? next(value) : next;
+      if (equalityFn(value, nextValue) === true) return;
+      if (controlled === false) setUncontrolledState(nextValue);
+      if (controlled === true && nextValue === void 0) setUncontrolledState(nextValue);
+      onChange?.(nextValue);
+    },
+    [controlled, onChange, equalityFn, value]
+  );
+  return [value, setValue];
+}
+function isSetStateAction(next) {
+  return typeof next === "function";
+}
+
 // src/hooks/useCounter/useCounter.ts
-var import_react11 = require("react");
-function useCounter({ initialValue = 0, min, max, step = 1 } = {}) {
+var import_react13 = require("react");
+function useCounter(initialValue = 0, { min, max, step = 1 } = {}) {
   const validateValue = (value) => {
     let validatedValue = value;
     if (min !== void 0 && validatedValue < min) {
@@ -388,9 +420,9 @@ function useCounter({ initialValue = 0, min, max, step = 1 } = {}) {
     }
     return validatedValue;
   };
-  const [count, setCountState] = (0, import_react11.useState)(() => validateValue(initialValue));
-  const validateValueMemoized = (0, import_react11.useCallback)(validateValue, [min, max]);
-  const setCount = (0, import_react11.useCallback)(
+  const [count, setCountState] = (0, import_react13.useState)(() => validateValue(initialValue));
+  const validateValueMemoized = (0, import_react13.useCallback)(validateValue, [min, max]);
+  const setCount = (0, import_react13.useCallback)(
     (value) => {
       setCountState((prev) => {
         const nextValue = typeof value === "function" ? value(prev) : value;
@@ -399,13 +431,13 @@ function useCounter({ initialValue = 0, min, max, step = 1 } = {}) {
     },
     [validateValueMemoized]
   );
-  const increment = (0, import_react11.useCallback)(() => {
+  const increment = (0, import_react13.useCallback)(() => {
     setCount((prev) => prev + step);
   }, [setCount, step]);
-  const decrement = (0, import_react11.useCallback)(() => {
+  const decrement = (0, import_react13.useCallback)(() => {
     setCount((prev) => prev - step);
   }, [setCount, step]);
-  const reset = (0, import_react11.useCallback)(() => {
+  const reset = (0, import_react13.useCallback)(() => {
     setCount(initialValue);
   }, [setCount, initialValue]);
   return {
@@ -418,12 +450,12 @@ function useCounter({ initialValue = 0, min, max, step = 1 } = {}) {
 }
 
 // src/hooks/useDebounce/useDebounce.ts
-var import_react12 = require("react");
-var import_react13 = require("react");
+var import_react14 = require("react");
+var import_react15 = require("react");
 function useDebounce(callback, wait, options = {}) {
   const preservedCallback = usePreservedCallback(callback);
   const { leading = false, trailing = true } = options;
-  const edges = (0, import_react13.useMemo)(() => {
+  const edges = (0, import_react15.useMemo)(() => {
     const _edges = [];
     if (leading) {
       _edges.push("leading");
@@ -433,10 +465,10 @@ function useDebounce(callback, wait, options = {}) {
     }
     return _edges;
   }, [leading, trailing]);
-  const debounced = (0, import_react13.useMemo)(() => {
+  const debounced = (0, import_react15.useMemo)(() => {
     return debounce(preservedCallback, wait, { edges });
   }, [preservedCallback, wait, edges]);
-  (0, import_react12.useEffect)(() => {
+  (0, import_react14.useEffect)(() => {
     return () => {
       debounced.cancel();
     };
@@ -444,11 +476,167 @@ function useDebounce(callback, wait, options = {}) {
   return debounced;
 }
 
+// src/hooks/useDoubleClick/useDoubleClick.ts
+var import_react16 = require("react");
+function useDoubleClick({
+  delay = 250,
+  click,
+  doubleClick
+}) {
+  const clickTimeout = (0, import_react16.useRef)(null);
+  const clearClickTimeout = usePreservedCallback(() => {
+    if (clickTimeout.current != null) {
+      window.clearTimeout(clickTimeout.current);
+      clickTimeout.current = null;
+    }
+  });
+  (0, import_react16.useEffect)(() => () => clearClickTimeout(), [clearClickTimeout]);
+  const handleEvent = (0, import_react16.useCallback)(
+    (event) => {
+      clearClickTimeout();
+      if (click && event.detail === 1) {
+        clickTimeout.current = window.setTimeout(() => {
+          click(event);
+        }, delay);
+      }
+      if (event.detail === 2) {
+        doubleClick(event);
+      }
+    },
+    [click, doubleClick, delay, clearClickTimeout]
+  );
+  return handleEvent;
+}
+
+// src/hooks/useGeolocation/useGeolocation.ts
+var import_react17 = require("react");
+var CustomGeoLocationError = class extends Error {
+  code;
+  constructor({ code, message }) {
+    super(message);
+    this.name = "CustomGeoLocationError";
+    this.code = code;
+  }
+};
+var GeolocationMountBehavior = {
+  GET: "get",
+  WATCH: "watch"
+};
+function useGeolocation(options) {
+  const [state, setState] = (0, import_react17.useState)({
+    loading: !!options?.mountBehavior,
+    error: null,
+    data: null
+  });
+  const [isTracking, setIsTracking] = (0, import_react17.useState)(false);
+  const watchIdRef = (0, import_react17.useRef)(null);
+  const checkGeolocationSupport = (0, import_react17.useCallback)(() => {
+    if (typeof window === "undefined" || navigator.geolocation === void 0) {
+      setState((prev) => ({
+        ...prev,
+        loading: false,
+        error: new CustomGeoLocationError({
+          code: 0,
+          message: "Geolocation is not supported by this environment."
+        })
+      }));
+      return false;
+    }
+    return true;
+  }, []);
+  const handleSuccess = (0, import_react17.useCallback)((position) => {
+    const { coords } = position;
+    setState((prev) => ({
+      ...prev,
+      loading: false,
+      error: null,
+      data: {
+        latitude: coords.latitude,
+        longitude: coords.longitude,
+        accuracy: coords.accuracy,
+        altitude: coords.altitude,
+        altitudeAccuracy: coords.altitudeAccuracy,
+        heading: coords.heading,
+        speed: coords.speed,
+        timestamp: position.timestamp
+      }
+    }));
+  }, []);
+  const handleError = (0, import_react17.useCallback)((error) => {
+    const { code, message } = error;
+    setState((prev) => ({
+      ...prev,
+      loading: false,
+      error: new CustomGeoLocationError({ code, message })
+    }));
+  }, []);
+  const getGeolocationOptions = (0, import_react17.useCallback)(
+    () => ({
+      enableHighAccuracy: options?.enableHighAccuracy,
+      maximumAge: options?.maximumAge,
+      timeout: options?.timeout
+    }),
+    [options?.enableHighAccuracy, options?.maximumAge, options?.timeout]
+  );
+  const getCurrentPosition = (0, import_react17.useCallback)(() => {
+    if (!checkGeolocationSupport()) {
+      return;
+    }
+    setState((prev) => ({ ...prev, loading: true }));
+    navigator.geolocation.getCurrentPosition(handleSuccess, handleError, getGeolocationOptions());
+  }, [handleSuccess, handleError, getGeolocationOptions, checkGeolocationSupport]);
+  const startTracking = (0, import_react17.useCallback)(() => {
+    if (!checkGeolocationSupport()) {
+      return;
+    }
+    if (watchIdRef.current !== null) {
+      navigator.geolocation.clearWatch(watchIdRef.current);
+    }
+    setState((prev) => ({ ...prev, loading: true }));
+    watchIdRef.current = navigator.geolocation.watchPosition(
+      (position) => {
+        setIsTracking(true);
+        handleSuccess(position);
+      },
+      handleError,
+      getGeolocationOptions()
+    );
+  }, [handleSuccess, handleError, getGeolocationOptions, checkGeolocationSupport]);
+  const stopTracking = (0, import_react17.useCallback)(() => {
+    if (watchIdRef.current === null) {
+      return;
+    }
+    navigator.geolocation.clearWatch(watchIdRef.current);
+    watchIdRef.current = null;
+    setIsTracking(false);
+  }, []);
+  (0, import_react17.useEffect)(() => {
+    if (options?.mountBehavior === GeolocationMountBehavior.WATCH) {
+      startTracking();
+    } else if (options?.mountBehavior === GeolocationMountBehavior.GET) {
+      getCurrentPosition();
+    }
+    return () => {
+      if (watchIdRef.current !== null) {
+        navigator.geolocation.clearWatch(watchIdRef.current);
+        watchIdRef.current = null;
+      }
+    };
+  }, [options?.mountBehavior, getCurrentPosition, startTracking]);
+  return {
+    ...state,
+    getCurrentPosition,
+    startTracking,
+    stopTracking,
+    isTracking
+  };
+}
+
 // src/hooks/useInputState/useInputState.ts
-var import_react14 = require("react");
+var import_react18 = require("react");
 function useInputState(initialValue = "", transformValue = echo) {
-  const [value, setValue] = (0, import_react14.useState)(initialValue);
-  const handleValueChange = (0, import_react14.useCallback)(
+  const [value, setValue] = (0, import_react18.useState)(initialValue);
+  const handleValueChange = (0, import_react18.useCallback)(
     ({ target: { value: value2 } }) => {
       setValue(transformValue(value2));
     },
@@ -461,18 +649,18 @@ function echo(v) {
 }
 
 // src/hooks/useInterval/useInterval.ts
-var import_react15 = require("react");
+var import_react19 = require("react");
 function useInterval(callback, options) {
   const delay = typeof options === "number" ? options : options.delay;
   const immediate = typeof options === "number" ? false : options.immediate;
   const enabled = typeof options === "number" ? true : options.enabled ?? true;
   const preservedCallback = usePreservedCallback(callback);
-  (0, import_react15.useEffect)(() => {
+  (0, import_react19.useEffect)(() => {
     if (immediate === true && enabled) {
       preservedCallback();
     }
   }, [immediate, preservedCallback, enabled]);
-  (0, import_react15.useEffect)(() => {
+  (0, import_react19.useEffect)(() => {
     if (!enabled) {
       return;
     }
@@ -481,12 +669,17 @@ function useInterval(callback, options) {
   }, [delay, preservedCallback, enabled]);
 }
 
+// src/hooks/useIsomorphicLayoutEffect/useIsomorphicLayoutEffect.ts
+var import_react20 = require("react");
+var isServer = typeof window === "undefined";
+var useIsomorphicLayoutEffect = isServer ? import_react20.useEffect : import_react20.useLayoutEffect;
+
 // src/hooks/useLoading/useLoading.ts
-var import_react16 = require("react");
+var import_react21 = require("react");
 function useLoading() {
-  const [loading, setLoading] = (0, import_react16.useState)(false);
+  const [loading, setLoading] = (0, import_react21.useState)(false);
   const ref = useIsMountedRef();
-  const startTransition = (0, import_react16.useCallback)(
+  const startTransition = (0, import_react21.useCallback)(
     async (promise) => {
       try {
         setLoading(true);
@@ -500,11 +693,11 @@ function useLoading() {
     },
     [ref.isMounted]
   );
-  return (0, import_react16.useMemo)(() => [loading, startTransition], [loading, startTransition]);
+  return (0, import_react21.useMemo)(() => [loading, startTransition], [loading, startTransition]);
 }
 function useIsMountedRef() {
-  const ref = (0, import_react16.useRef)({ isMounted: true }).current;
-  (0, import_react16.useEffect)(() => {
+  const ref = (0, import_react21.useRef)({ isMounted: true }).current;
+  (0, import_react21.useEffect)(() => {
     ref.isMounted = true;
     return () => {
       ref.isMounted = false;
@@ -513,10 +706,138 @@ function useIsMountedRef() {
   return ref;
 }
 
+// src/hooks/useLongPress/useLongPress.ts
+var import_react22 = require("react");
+function useLongPress(onLongPress, { delay = 500, moveThreshold, onClick, onLongPressEnd } = {}) {
+  const timeoutRef = (0, import_react22.useRef)(null);
+  const isLongPressActiveRef = (0, import_react22.useRef)(false);
+  const initialPositionRef = (0, import_react22.useRef)({ x: 0, y: 0 });
+  const preservedOnLongPress = usePreservedCallback(onLongPress);
+  const preservedOnClick = usePreservedCallback(onClick || (() => {
+  }));
+  const preservedOnLongPressEnd = usePreservedCallback(onLongPressEnd || (() => {
+  }));
+  const hasThreshold = moveThreshold?.x !== void 0 || moveThreshold?.y !== void 0;
+  const getClientPosition = (0, import_react22.useCallback)((event) => {
+    if ("touches" in event.nativeEvent) {
+      const touch = event.nativeEvent.touches[0];
+      return { x: touch.clientX, y: touch.clientY };
+    }
+    return {
+      x: event.nativeEvent.clientX,
+      y: event.nativeEvent.clientY
+    };
+  }, []);
+  const isMovedBeyondThreshold = (0, import_react22.useCallback)(
+    (event) => {
+      const { x, y } = getClientPosition(event);
+      const deltaX = Math.abs(x - initialPositionRef.current.x);
+      const deltaY = Math.abs(y - initialPositionRef.current.y);
+      return moveThreshold?.x !== void 0 && deltaX > moveThreshold.x || moveThreshold?.y !== void 0 && deltaY > moveThreshold.y;
+    },
+    [getClientPosition, moveThreshold]
+  );
+  const cancelLongPress = (0, import_react22.useCallback)(() => {
+    if (timeoutRef.current !== null) {
+      window.clearTimeout(timeoutRef.current);
+      timeoutRef.current = null;
+    }
+  }, []);
+  const handlePressStart = (0, import_react22.useCallback)(
+    (event) => {
+      cancelLongPress();
+      const position = getClientPosition(event);
+      initialPositionRef.current = position;
+      isLongPressActiveRef.current = false;
+      timeoutRef.current = window.setTimeout(() => {
+        isLongPressActiveRef.current = true;
+        preservedOnLongPress(event);
+      }, delay);
+    },
+    [cancelLongPress, delay, getClientPosition, preservedOnLongPress]
+  );
+  const handlePressEnd = (0, import_react22.useCallback)(
+    (event) => {
+      if (isLongPressActiveRef.current) {
+        preservedOnLongPressEnd(event);
+      } else if (timeoutRef.current !== null) {
+        preservedOnClick(event);
+      }
+      cancelLongPress();
+      isLongPressActiveRef.current = false;
+    },
+    [cancelLongPress, preservedOnClick, preservedOnLongPressEnd]
+  );
+  const handlePressMove = (0, import_react22.useCallback)(
+    (event) => {
+      if (timeoutRef.current !== null && isMovedBeyondThreshold(event)) {
+        cancelLongPress();
+      }
+    },
+    [cancelLongPress, isMovedBeyondThreshold]
+  );
+  return {
+    onMouseDown: handlePressStart,
+    onMouseUp: handlePressEnd,
+    onMouseLeave: cancelLongPress,
+    onTouchStart: handlePressStart,
+    onTouchEnd: handlePressEnd,
+    ...hasThreshold ? { onTouchMove: handlePressMove, onMouseMove: handlePressMove } : {}
+  };
+}
+
+// src/hooks/useMap/useMap.ts
+var import_react24 = require("react");
+
+// src/hooks/usePreservedReference/usePreservedReference.ts
+var import_react23 = require("react");
+function usePreservedReference(value, areValuesEqual = areDeeplyEqual) {
+  const ref = (0, import_react23.useRef)(value);
+  return (0, import_react23.useMemo)(() => {
+    if (!areValuesEqual(ref.current, value)) {
+      ref.current = value;
+    }
+    return ref.current;
+  }, [areValuesEqual, value]);
+}
+function areDeeplyEqual(x, y) {
+  return JSON.stringify(x) === JSON.stringify(y);
+}
+
+// src/hooks/useMap/useMap.ts
+function useMap(initialState = /* @__PURE__ */ new Map()) {
+  const [map, setMap] = (0, import_react24.useState)(() => new Map(initialState));
+  const preservedInitialState = usePreservedReference(initialState);
+  const set = (0, import_react24.useCallback)((key, value) => {
+    setMap((prev) => {
+      const nextMap = new Map(prev);
+      nextMap.set(key, value);
+      return nextMap;
+    });
+  }, []);
+  const setAll = (0, import_react24.useCallback)((entries) => {
+    setMap(() => new Map(entries));
+  }, []);
+  const remove = (0, import_react24.useCallback)((key) => {
+    setMap((prev) => {
+      const nextMap = new Map(prev);
+      nextMap.delete(key);
+      return nextMap;
+    });
+  }, []);
+  const reset = (0, import_react24.useCallback)(() => {
+    setMap(() => new Map(preservedInitialState));
+  }, [preservedInitialState]);
+  const actions = (0, import_react24.useMemo)(() => {
+    return { set, setAll, remove, reset };
+  }, [set, setAll, remove, reset]);
+  return [map, actions];
+}
+
 // src/hooks/useOutsideClickEffect/useOutsideClickEffect.ts
-var import_react17 = require("react");
+var import_react25 = require("react");
 function useOutsideClickEffect(container, callback) {
-  const containers = (0, import_react17.useRef)([]);
+  const containers = (0, import_react25.useRef)([]);
   const handleDocumentClick = usePreservedCallback(({ target }) => {
     if (target === null) {
       return;
@@ -529,10 +850,10 @@ function useOutsideClickEffect(container, callback) {
     }
     callback();
   });
-  (0, import_react17.useEffect)(() => {
+  (0, import_react25.useEffect)(() => {
     containers.current = [container].flat(1).filter((item) => item != null);
   }, [container]);
-  (0, import_react17.useEffect)(() => {
+  (0, import_react25.useEffect)(() => {
     document.addEventListener("click", handleDocumentClick);
     return () => {
       document.removeEventListener("click", handleDocumentClick);
@@ -540,28 +861,13 @@ function useOutsideClickEffect(container, callback) {
   }, [handleDocumentClick]);
 }
 
-// src/hooks/usePreservedReference/usePreservedReference.ts
-var import_react18 = require("react");
-function usePreservedReference(value, areValuesEqual = areDeeplyEqual) {
-  const ref = (0, import_react18.useRef)(value);
-  return (0, import_react18.useMemo)(() => {
-    if (!areValuesEqual(ref.current, value)) {
-      ref.current = value;
-    }
-    return ref.current;
-  }, [areValuesEqual, value]);
-}
-function areDeeplyEqual(x, y) {
-  return JSON.stringify(x) === JSON.stringify(y);
-}
-
 // src/hooks/usePrevious/usePrevious.ts
-var import_react19 = require("react");
+var import_react26 = require("react");
 var strictEquals = (prev, next) => prev === next;
 function usePrevious(state, compare = strictEquals) {
-  const prevRef = (0, import_react19.useRef)(state);
-  const currentRef = (0, import_react19.useRef)(state);
-  const isFirstRender = (0, import_react19.useRef)(true);
+  const prevRef = (0, import_react26.useRef)(state);
+  const currentRef = (0, import_react26.useRef)(state);
+  const isFirstRender = (0, import_react26.useRef)(true);
   if (isFirstRender.current) {
     isFirstRender.current = false;
     return prevRef.current;
@@ -574,7 +880,7 @@ function usePrevious(state, compare = strictEquals) {
 }
 
 // src/hooks/useStorageState/useStorageState.ts
-var import_react20 = require("react");
+var import_react27 = require("react");
 
 // src/hooks/useStorageState/storage.ts
 var MemoStorage = class {
@@ -686,11 +992,11 @@ function useStorageState(key, {
   ...options
 } = {}) {
   const serializedDefaultValue = defaultValue;
-  const cache = (0, import_react20.useRef)({
+  const cache = (0, import_react27.useRef)({
     data: null,
     parsed: serializedDefaultValue
   });
-  const getSnapshot = (0, import_react20.useCallback)(() => {
+  const getSnapshot = (0, import_react27.useCallback)(() => {
     const deserializer = "deserializer" in options ? options.deserializer : JSON.parse;
     const data = storage.get(key);
     if (data !== cache.current.data) {
@@ -703,7 +1009,7 @@ function useStorageState(key, {
     }
     return cache.current.parsed;
   }, [defaultValue, key, storage]);
-  const storageState = (0, import_react20.useSyncExternalStore)(
+  const storageState = (0, import_react27.useSyncExternalStore)(
     (onStoreChange) => {
       listeners.add(onStoreChange);
       const handler = (event) => {
@@ -720,7 +1026,7 @@ function useStorageState(key, {
     () => getSnapshot(),
     () => serializedDefaultValue
   );
-  const setStorageState = (0, import_react20.useCallback)(
+  const setStorageState = (0, import_react27.useCallback)(
     (value) => {
       const serializer = "serializer" in options ? options.serializer : JSON.stringify;
       const nextValue = typeof value === "function" ? value(getSnapshot()) : value;
@@ -733,14 +1039,14 @@ function useStorageState(key, {
     },
     [getSnapshot, key, storage]
   );
-  const refreshStorageState = (0, import_react20.useCallback)(() => {
+  const refreshStorageState = (0, import_react27.useCallback)(() => {
     setStorageState(getSnapshot());
   }, [storage, getSnapshot, setStorageState]);
   return ensureSerializable([storageState, setStorageState, refreshStorageState]);
 }
 
 // src/hooks/useThrottle/useThrottle.ts
-var import_react21 = require("react");
+var import_react28 = require("react");
 
 // src/hooks/useThrottle/throttle.ts
 function throttle(func, throttleMs, { edges = ["leading", "trailing"] } = {}) {
@@ -765,11 +1071,11 @@ function throttle(func, throttleMs, { edges = ["leading", "trailing"] } = {}) {
 function useThrottle(callback, wait, options) {
   const preservedCallback = usePreservedCallback(callback);
   const preservedOptions = usePreservedReference(options ?? {});
-  const throttledCallback = (0, import_react21.useMemo)(
+  const throttledCallback = (0, import_react28.useMemo)(
     () => throttle(preservedCallback, wait, preservedOptions),
     [preservedOptions, preservedCallback, wait]
   );
-  (0, import_react21.useEffect)(() => {
+  (0, import_react28.useEffect)(() => {
     return () => {
       throttledCallback.cancel();
     };
@@ -778,29 +1084,29 @@ function useThrottle(callback, wait, options) {
 }
 
 // src/hooks/useTimeout/useTimeout.ts
-var import_react22 = require("react");
+var import_react29 = require("react");
 function useTimeout(callback, delay = 0) {
   const preservedCallback = usePreservedCallback(callback);
-  (0, import_react22.useEffect)(() => {
+  (0, import_react29.useEffect)(() => {
     const timeoutId = window.setTimeout(preservedCallback, delay);
     return () => window.clearTimeout(timeoutId);
   }, [delay, preservedCallback]);
 }
 
 // src/hooks/useToggle/useToggle.ts
-var import_react23 = require("react");
+var import_react30 = require("react");
 function useToggle(initialValue = false) {
-  return (0, import_react23.useReducer)(toggle, initialValue);
+  return (0, import_react30.useReducer)(toggle, initialValue);
 }
 var toggle = (state) => !state;
 
 // src/utils/buildContext/buildContext.tsx
-var import_react24 = require("react");
+var import_react31 = require("react");
 var import_jsx_runtime3 = require("react/jsx-runtime");
 function buildContext(contextName, defaultContextValues) {
-  const Context = (0, import_react24.createContext)(defaultContextValues ?? void 0);
+  const Context = (0, import_react31.createContext)(defaultContextValues ?? void 0);
   function Provider({ children, ...contextValues }) {
-    const value = (0, import_react24.useMemo)(
+    const value = (0, import_react31.useMemo)(
       () => Object.keys(contextValues).length > 0 ? contextValues : null,
       // eslint-disable-next-line react-hooks/exhaustive-deps
       [...Object.values(contextValues)]
@@ -808,7 +1114,7 @@ function buildContext(contextName, defaultContextValues) {
     return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(Context.Provider, { value, children });
   }
   function useInnerContext() {
-    const context = (0, import_react24.useContext)(Context);
+    const context = (0, import_react31.useContext)(Context);
     if (context != null) {
       return context;
     }
@@ -819,23 +1125,72 @@ function buildContext(contextName, defaultContextValues) {
   }
   return [Provider, useInnerContext];
 }
+
+// src/utils/mergeProps/mergeProps.ts
+function mergeProps(...props) {
+  return props.reduce(pushProp, {});
+}
+function pushProp(prev, curr) {
+  for (const key in curr) {
+    if (curr[key] === void 0) continue;
+    switch (key) {
+      case "className": {
+        prev[key] = [prev[key], curr[key]].join(" ").trim();
+        break;
+      }
+      case "style": {
+        prev[key] = mergeStyle(prev[key], curr[key]);
+        break;
+      }
+      default: {
+        const mergedFunction = mergeFunction(prev[key], curr[key]);
+        if (mergedFunction) {
+          prev[key] = mergedFunction;
+        } else if (curr[key] !== void 0) {
+          prev[key] = curr[key];
+        }
+      }
+    }
+  }
+  return prev;
+}
+function mergeStyle(a, b) {
+  if (a == null) return b;
+  return { ...a, ...b };
+}
+function mergeFunction(a, b) {
+  if (typeof a === "function" && typeof b === "function") {
+    return (...args) => {
+      a(...args);
+      b(...args);
+    };
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ImpressionArea,
   Separated,
   SwitchCase,
   buildContext,
+  mergeProps,
   mergeRefs,
   useAsyncEffect,
   useBooleanState,
   useCallbackOncePerRender,
+  useControlledState,
   useCounter,
   useDebounce,
+  useDebouncedCallback,
+  useDoubleClick,
+  useGeolocation,
   useImpressionRef,
   useInputState,
   useIntersectionObserver,
   useInterval,
+  useIsomorphicLayoutEffect,
   useLoading,
+  useLongPress,
+  useMap,
   useOutsideClickEffect,
   usePreservedCallback,
   usePreservedReference,