react-simplikit 0.0.35 → 0.0.37

package/esm/index.js

@@ -1,3 +1,6 @@
+// src/components/ImpressionArea/ImpressionArea.tsx
+import { forwardRef } from "react";
+
 // src/hooks/useImpressionRef/useImpressionRef.ts
 import { useRef as useRef4 } from "react";
 
@@ -241,16 +244,8 @@ function mergeRefs(...refs) {
 
 // src/components/ImpressionArea/ImpressionArea.tsx
 import { jsx } from "react/jsx-runtime";
-function ImpressionArea({
-  as,
-  rootMargin,
-  areaThreshold,
-  timeThreshold,
-  onImpressionStart,
-  onImpressionEnd,
-  ref,
-  ...props
-}) {
+var ImpressionArea = forwardRef(ImpressionAreaImpl);
+function ImpressionAreaImpl({ as, rootMargin, areaThreshold, timeThreshold, onImpressionStart, onImpressionEnd, ...props }, ref) {
   const Component = as ?? "div";
   const impressionRef = useImpressionRef({
     onImpressionStart,
@@ -261,6 +256,9 @@ function ImpressionArea({
   });
   return /* @__PURE__ */ jsx(Component, { ref: mergeRefs(ref, impressionRef), ...props });
 }
+Object.assign(ImpressionArea, {
+  displayName: "ImpressionArea"
+});
 
 // src/components/Separated/Separated.tsx
 import { Children, Fragment, isValidElement } from "react";
@@ -325,9 +323,36 @@ function useCallbackOncePerRender(callback, deps) {
   });
 }
 
-// src/hooks/useCounter/useCounter.ts
+// src/hooks/useControlledState/useControlledState.ts
 import { useCallback as useCallback6, useState as useState2 } from "react";
-function useCounter({ initialValue = 0, min, max, step = 1 } = {}) {
+function useControlledState({
+  value: valueProp,
+  defaultValue,
+  onChange,
+  equalityFn = Object.is
+}) {
+  const [uncontrolledState, setUncontrolledState] = useState2(defaultValue);
+  const controlled = valueProp !== void 0;
+  const value = controlled ? valueProp : uncontrolledState;
+  const setValue = useCallback6(
+    (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
+import { useCallback as useCallback7, useState as useState3 } from "react";
+function useCounter(initialValue = 0, { min, max, step = 1 } = {}) {
   const validateValue = (value) => {
     let validatedValue = value;
     if (min !== void 0 && validatedValue < min) {
@@ -338,9 +363,9 @@ function useCounter({ initialValue = 0, min, max, step = 1 } = {}) {
     }
     return validatedValue;
   };
-  const [count, setCountState] = useState2(() => validateValue(initialValue));
-  const validateValueMemoized = useCallback6(validateValue, [min, max]);
-  const setCount = useCallback6(
+  const [count, setCountState] = useState3(() => validateValue(initialValue));
+  const validateValueMemoized = useCallback7(validateValue, [min, max]);
+  const setCount = useCallback7(
     (value) => {
       setCountState((prev) => {
         const nextValue = typeof value === "function" ? value(prev) : value;
@@ -349,13 +374,13 @@ function useCounter({ initialValue = 0, min, max, step = 1 } = {}) {
     },
     [validateValueMemoized]
   );
-  const increment = useCallback6(() => {
+  const increment = useCallback7(() => {
     setCount((prev) => prev + step);
   }, [setCount, step]);
-  const decrement = useCallback6(() => {
+  const decrement = useCallback7(() => {
     setCount((prev) => prev - step);
   }, [setCount, step]);
-  const reset = useCallback6(() => {
+  const reset = useCallback7(() => {
     setCount(initialValue);
   }, [setCount, initialValue]);
   return {
@@ -394,11 +419,167 @@ function useDebounce(callback, wait, options = {}) {
   return debounced;
 }
 
+// src/hooks/useDoubleClick/useDoubleClick.ts
+import { useCallback as useCallback8, useEffect as useEffect7, useRef as useRef6 } from "react";
+function useDoubleClick({
+  delay = 250,
+  click,
+  doubleClick
+}) {
+  const clickTimeout = useRef6(null);
+  const clearClickTimeout = usePreservedCallback(() => {
+    if (clickTimeout.current != null) {
+      window.clearTimeout(clickTimeout.current);
+      clickTimeout.current = null;
+    }
+  });
+  useEffect7(() => () => clearClickTimeout(), [clearClickTimeout]);
+  const handleEvent = useCallback8(
+    (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
+import { useCallback as useCallback9, useEffect as useEffect8, useRef as useRef7, useState as useState4 } from "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] = useState4({
+    loading: !!options?.mountBehavior,
+    error: null,
+    data: null
+  });
+  const [isTracking, setIsTracking] = useState4(false);
+  const watchIdRef = useRef7(null);
+  const checkGeolocationSupport = useCallback9(() => {
+    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 = useCallback9((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 = useCallback9((error) => {
+    const { code, message } = error;
+    setState((prev) => ({
+      ...prev,
+      loading: false,
+      error: new CustomGeoLocationError({ code, message })
+    }));
+  }, []);
+  const getGeolocationOptions = useCallback9(
+    () => ({
+      enableHighAccuracy: options?.enableHighAccuracy,
+      maximumAge: options?.maximumAge,
+      timeout: options?.timeout
+    }),
+    [options?.enableHighAccuracy, options?.maximumAge, options?.timeout]
+  );
+  const getCurrentPosition = useCallback9(() => {
+    if (!checkGeolocationSupport()) {
+      return;
+    }
+    setState((prev) => ({ ...prev, loading: true }));
+    navigator.geolocation.getCurrentPosition(handleSuccess, handleError, getGeolocationOptions());
+  }, [handleSuccess, handleError, getGeolocationOptions, checkGeolocationSupport]);
+  const startTracking = useCallback9(() => {
+    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 = useCallback9(() => {
+    if (watchIdRef.current === null) {
+      return;
+    }
+    navigator.geolocation.clearWatch(watchIdRef.current);
+    watchIdRef.current = null;
+    setIsTracking(false);
+  }, []);
+  useEffect8(() => {
+    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
-import { useCallback as useCallback7, useState as useState3 } from "react";
+import { useCallback as useCallback10, useState as useState5 } from "react";
 function useInputState(initialValue = "", transformValue = echo) {
-  const [value, setValue] = useState3(initialValue);
-  const handleValueChange = useCallback7(
+  const [value, setValue] = useState5(initialValue);
+  const handleValueChange = useCallback10(
     ({ target: { value: value2 } }) => {
       setValue(transformValue(value2));
     },
@@ -411,18 +592,18 @@ function echo(v) {
 }
 
 // src/hooks/useInterval/useInterval.ts
-import { useEffect as useEffect7 } from "react";
+import { useEffect as useEffect9 } from "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);
-  useEffect7(() => {
+  useEffect9(() => {
     if (immediate === true && enabled) {
       preservedCallback();
     }
   }, [immediate, preservedCallback, enabled]);
-  useEffect7(() => {
+  useEffect9(() => {
     if (!enabled) {
       return;
     }
@@ -431,12 +612,17 @@ function useInterval(callback, options) {
   }, [delay, preservedCallback, enabled]);
 }
 
+// src/hooks/useIsomorphicLayoutEffect/useIsomorphicLayoutEffect.ts
+import { useEffect as useEffect10, useLayoutEffect } from "react";
+var isServer = typeof window === "undefined";
+var useIsomorphicLayoutEffect = isServer ? useEffect10 : useLayoutEffect;
+
 // src/hooks/useLoading/useLoading.ts
-import { useCallback as useCallback8, useEffect as useEffect8, useMemo as useMemo4, useRef as useRef6, useState as useState4 } from "react";
+import { useCallback as useCallback11, useEffect as useEffect11, useMemo as useMemo4, useRef as useRef8, useState as useState6 } from "react";
 function useLoading() {
-  const [loading, setLoading] = useState4(false);
+  const [loading, setLoading] = useState6(false);
   const ref = useIsMountedRef();
-  const startTransition = useCallback8(
+  const startTransition = useCallback11(
     async (promise) => {
       try {
         setLoading(true);
@@ -453,8 +639,8 @@ function useLoading() {
   return useMemo4(() => [loading, startTransition], [loading, startTransition]);
 }
 function useIsMountedRef() {
-  const ref = useRef6({ isMounted: true }).current;
-  useEffect8(() => {
+  const ref = useRef8({ isMounted: true }).current;
+  useEffect11(() => {
     ref.isMounted = true;
     return () => {
       ref.isMounted = false;
@@ -463,10 +649,138 @@ function useIsMountedRef() {
   return ref;
 }
 
+// src/hooks/useLongPress/useLongPress.ts
+import { useCallback as useCallback12, useRef as useRef9 } from "react";
+function useLongPress(onLongPress, { delay = 500, moveThreshold, onClick, onLongPressEnd } = {}) {
+  const timeoutRef = useRef9(null);
+  const isLongPressActiveRef = useRef9(false);
+  const initialPositionRef = useRef9({ 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 = useCallback12((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 = useCallback12(
+    (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 = useCallback12(() => {
+    if (timeoutRef.current !== null) {
+      window.clearTimeout(timeoutRef.current);
+      timeoutRef.current = null;
+    }
+  }, []);
+  const handlePressStart = useCallback12(
+    (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 = useCallback12(
+    (event) => {
+      if (isLongPressActiveRef.current) {
+        preservedOnLongPressEnd(event);
+      } else if (timeoutRef.current !== null) {
+        preservedOnClick(event);
+      }
+      cancelLongPress();
+      isLongPressActiveRef.current = false;
+    },
+    [cancelLongPress, preservedOnClick, preservedOnLongPressEnd]
+  );
+  const handlePressMove = useCallback12(
+    (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
+import { useCallback as useCallback13, useMemo as useMemo6, useState as useState7 } from "react";
+
+// src/hooks/usePreservedReference/usePreservedReference.ts
+import { useMemo as useMemo5, useRef as useRef10 } from "react";
+function usePreservedReference(value, areValuesEqual = areDeeplyEqual) {
+  const ref = useRef10(value);
+  return useMemo5(() => {
+    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] = useState7(() => new Map(initialState));
+  const preservedInitialState = usePreservedReference(initialState);
+  const set = useCallback13((key, value) => {
+    setMap((prev) => {
+      const nextMap = new Map(prev);
+      nextMap.set(key, value);
+      return nextMap;
+    });
+  }, []);
+  const setAll = useCallback13((entries) => {
+    setMap(() => new Map(entries));
+  }, []);
+  const remove = useCallback13((key) => {
+    setMap((prev) => {
+      const nextMap = new Map(prev);
+      nextMap.delete(key);
+      return nextMap;
+    });
+  }, []);
+  const reset = useCallback13(() => {
+    setMap(() => new Map(preservedInitialState));
+  }, [preservedInitialState]);
+  const actions = useMemo6(() => {
+    return { set, setAll, remove, reset };
+  }, [set, setAll, remove, reset]);
+  return [map, actions];
+}
+
 // src/hooks/useOutsideClickEffect/useOutsideClickEffect.ts
-import { useEffect as useEffect9, useRef as useRef7 } from "react";
+import { useEffect as useEffect12, useRef as useRef11 } from "react";
 function useOutsideClickEffect(container, callback) {
-  const containers = useRef7([]);
+  const containers = useRef11([]);
   const handleDocumentClick = usePreservedCallback(({ target }) => {
     if (target === null) {
       return;
@@ -479,10 +793,10 @@ function useOutsideClickEffect(container, callback) {
     }
     callback();
   });
-  useEffect9(() => {
+  useEffect12(() => {
     containers.current = [container].flat(1).filter((item) => item != null);
   }, [container]);
-  useEffect9(() => {
+  useEffect12(() => {
     document.addEventListener("click", handleDocumentClick);
     return () => {
       document.removeEventListener("click", handleDocumentClick);
@@ -490,28 +804,13 @@ function useOutsideClickEffect(container, callback) {
   }, [handleDocumentClick]);
 }
 
-// src/hooks/usePreservedReference/usePreservedReference.ts
-import { useMemo as useMemo5, useRef as useRef8 } from "react";
-function usePreservedReference(value, areValuesEqual = areDeeplyEqual) {
-  const ref = useRef8(value);
-  return useMemo5(() => {
-    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
-import { useRef as useRef9 } from "react";
+import { useRef as useRef12 } from "react";
 var strictEquals = (prev, next) => prev === next;
 function usePrevious(state, compare = strictEquals) {
-  const prevRef = useRef9(state);
-  const currentRef = useRef9(state);
-  const isFirstRender = useRef9(true);
+  const prevRef = useRef12(state);
+  const currentRef = useRef12(state);
+  const isFirstRender = useRef12(true);
   if (isFirstRender.current) {
     isFirstRender.current = false;
     return prevRef.current;
@@ -524,7 +823,7 @@ function usePrevious(state, compare = strictEquals) {
 }
 
 // src/hooks/useStorageState/useStorageState.ts
-import { useCallback as useCallback9, useRef as useRef10, useSyncExternalStore } from "react";
+import { useCallback as useCallback14, useRef as useRef13, useSyncExternalStore } from "react";
 
 // src/hooks/useStorageState/storage.ts
 var MemoStorage = class {
@@ -636,11 +935,11 @@ function useStorageState(key, {
   ...options
 } = {}) {
   const serializedDefaultValue = defaultValue;
-  const cache = useRef10({
+  const cache = useRef13({
     data: null,
     parsed: serializedDefaultValue
   });
-  const getSnapshot = useCallback9(() => {
+  const getSnapshot = useCallback14(() => {
     const deserializer = "deserializer" in options ? options.deserializer : JSON.parse;
     const data = storage.get(key);
     if (data !== cache.current.data) {
@@ -670,7 +969,7 @@ function useStorageState(key, {
     () => getSnapshot(),
     () => serializedDefaultValue
   );
-  const setStorageState = useCallback9(
+  const setStorageState = useCallback14(
     (value) => {
       const serializer = "serializer" in options ? options.serializer : JSON.stringify;
       const nextValue = typeof value === "function" ? value(getSnapshot()) : value;
@@ -683,14 +982,14 @@ function useStorageState(key, {
     },
     [getSnapshot, key, storage]
   );
-  const refreshStorageState = useCallback9(() => {
+  const refreshStorageState = useCallback14(() => {
     setStorageState(getSnapshot());
   }, [storage, getSnapshot, setStorageState]);
   return ensureSerializable([storageState, setStorageState, refreshStorageState]);
 }
 
 // src/hooks/useThrottle/useThrottle.ts
-import { useEffect as useEffect10, useMemo as useMemo6 } from "react";
+import { useEffect as useEffect13, useMemo as useMemo7 } from "react";
 
 // src/hooks/useThrottle/throttle.ts
 function throttle(func, throttleMs, { edges = ["leading", "trailing"] } = {}) {
@@ -715,11 +1014,11 @@ function throttle(func, throttleMs, { edges = ["leading", "trailing"] } = {}) {
 function useThrottle(callback, wait, options) {
   const preservedCallback = usePreservedCallback(callback);
   const preservedOptions = usePreservedReference(options ?? {});
-  const throttledCallback = useMemo6(
+  const throttledCallback = useMemo7(
     () => throttle(preservedCallback, wait, preservedOptions),
     [preservedOptions, preservedCallback, wait]
   );
-  useEffect10(() => {
+  useEffect13(() => {
     return () => {
       throttledCallback.cancel();
     };
@@ -728,10 +1027,10 @@ function useThrottle(callback, wait, options) {
 }
 
 // src/hooks/useTimeout/useTimeout.ts
-import { useEffect as useEffect11 } from "react";
+import { useEffect as useEffect14 } from "react";
 function useTimeout(callback, delay = 0) {
   const preservedCallback = usePreservedCallback(callback);
-  useEffect11(() => {
+  useEffect14(() => {
     const timeoutId = window.setTimeout(preservedCallback, delay);
     return () => window.clearTimeout(timeoutId);
   }, [delay, preservedCallback]);
@@ -745,12 +1044,12 @@ function useToggle(initialValue = false) {
 var toggle = (state) => !state;
 
 // src/utils/buildContext/buildContext.tsx
-import { createContext, useContext, useMemo as useMemo7 } from "react";
+import { createContext, useContext, useMemo as useMemo8 } from "react";
 import { jsx as jsx3 } from "react/jsx-runtime";
 function buildContext(contextName, defaultContextValues) {
   const Context = createContext(defaultContextValues ?? void 0);
   function Provider({ children, ...contextValues }) {
-    const value = useMemo7(
+    const value = useMemo8(
       () => Object.keys(contextValues).length > 0 ? contextValues : null,
       // eslint-disable-next-line react-hooks/exhaustive-deps
       [...Object.values(contextValues)]
@@ -769,22 +1068,71 @@ 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);
+    };
+  }
+}
 export {
   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,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-simplikit",
-  "version": "0.0.35",
+  "version": "0.0.37",
   "main": "./dist/index.cjs",
   "type": "module",
   "sideEffects": false,