react-simplikit 0.0.35 → 0.0.37

package/README.md

@@ -1,6 +1,6 @@
 ![react-simplikit](./src/public/images/og.png)
 
-# react-simplikit · [![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/toss/slash/blob/main/LICENSE) [![codecov](https://codecov.io/gh/toss/react-simplikit/graph/badge.svg?token=RHVOZ3J3TU)](https://codecov.io/gh/toss/react-simplikit)
+# react-simplikit · [![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/toss/slash/blob/main/LICENSE) [![codecov](https://codecov.io/gh/toss/react-simplikit/graph/badge.svg?token=RHVOZ3J3TU)](https://codecov.io/gh/toss/react-simplikit) [![Discord Badge](https://discord.com/api/guilds/1281071127052943361/widget.png?style=shield)](https://discord.gg/vGXbVjP2nY)
 
 English | [Korean](./README-ko_kr.md)
 

package/dist/components/ImpressionArea/index.cjs

@@ -24,6 +24,9 @@ __export(ImpressionArea_exports, {
 });
 module.exports = __toCommonJS(ImpressionArea_exports);
 
+// src/components/ImpressionArea/ImpressionArea.tsx
+var import_react7 = require("react");
+
 // src/hooks/useImpressionRef/useImpressionRef.ts
 var import_react6 = require("react");
 
@@ -267,16 +270,8 @@ 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
-}) {
+var ImpressionArea = (0, import_react7.forwardRef)(ImpressionAreaImpl);
+function ImpressionAreaImpl({ as, rootMargin, areaThreshold, timeThreshold, onImpressionStart, onImpressionEnd, ...props }, ref) {
   const Component = as ?? "div";
   const impressionRef = useImpressionRef({
     onImpressionStart,
@@ -287,6 +282,9 @@ function ImpressionArea({
   });
   return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, { ref: mergeRefs(ref, impressionRef), ...props });
 }
+Object.assign(ImpressionArea, {
+  displayName: "ImpressionArea"
+});
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ImpressionArea

package/dist/components/ImpressionArea/index.d.cts

@@ -1,10 +1,9 @@
-import * as react_jsx_runtime from 'react/jsx-runtime';
-import { ElementType, Ref, ReactNode } from 'react';
+import { ElementType, ReactNode, Ref } from 'react';
 import { UseImpressionRefOptions } from '../../hooks/useImpressionRef/index.cjs';
 
+type Element<T extends ElementType, InstrinsicElements = T extends keyof React.JSX.IntrinsicElements ? React.JSX.IntrinsicElements[T] : HTMLElement> = InstrinsicElements extends React.ClassAttributes<infer E extends HTMLElement> ? E : HTMLElement;
 type Props<Tag extends ElementType> = React.ComponentPropsWithoutRef<Tag> & UseImpressionRefOptions & {
     as?: Tag;
-    ref?: Ref<HTMLElement>;
     children?: ReactNode;
     className?: string;
 };
@@ -14,13 +13,14 @@ type Props<Tag extends ElementType> = React.ComponentPropsWithoutRef<Tag> & UseI
  * and executes callbacks when the element enters or exits the viewport. This component uses the `useImpressionRef`
  * hook to track the element's visibility.
  *
- * @param {ElementType} [as='div'] - The HTML tag to render. Defaults to `div`.
+ * @template {ElementType} T - The HTML tag to render. Defaults to `div`.
+ * @param {T} [as='div'] - The HTML tag to render. Defaults to `div`.
  * @param {string} [rootMargin] - Margin to adjust the detection area.
  * @param {number} [areaThreshold] - Minimum ratio of the element that must be visible (0 to 1).
  * @param {number} [timeThreshold] - Minimum time the element must be visible (in milliseconds).
  * @param {() => void} [onImpressionStart] - Callback function executed when the element enters the view.
  * @param {() => void} [onImpressionEnd] - Callback function executed when the element exits the view.
- * @param {Ref<HTMLElement>} [ref] - Reference to the element.
+ * @param {Ref<Element<T>>} [ref] - Reference to the element.
  * @param {React.ReactNode} [children] - Child elements to be rendered inside the component.
  * @param {string} [className] - Additional class names for styling.
  *
@@ -40,6 +40,8 @@ type Props<Tag extends ElementType> = React.ComponentPropsWithoutRef<Tag> & UseI
  *   );
  * }
  */
-declare function ImpressionArea<T extends ElementType = 'div'>({ as, rootMargin, areaThreshold, timeThreshold, onImpressionStart, onImpressionEnd, ref, ...props }: Props<T>): react_jsx_runtime.JSX.Element;
+declare const ImpressionArea: <T extends ElementType = "div">(props: Props<T> & {
+    ref?: Ref<Element<T>>;
+}) => React.ReactNode;
 
 export { ImpressionArea };

package/dist/hooks/useAsyncEffect/index.d.cts

@@ -2,7 +2,7 @@ import { DependencyList } from 'react';
 
 /**
  * @description
- * `useAsyncEffect` is a custom hook for handling asynchronous side effects in React components.
+ * `useAsyncEffect` is a React hook for handling asynchronous side effects in React components.
  * It follows the same cleanup pattern as `useEffect` while ensuring async operations are handled safely.
  *
  * @param {() => Promise<void | (() => void)>} [effect] - An asynchronous function executed in the `useEffect` pattern.

package/dist/hooks/useCallbackOncePerRender/index.d.cts

@@ -2,9 +2,8 @@ import { DependencyList } from 'react';
 
 /**
  * @description
- * A React hook that ensures a callback function is executed only once, regardless of
- * how many times it's called. This is useful for one-time operations that should not
- * be repeated, even if the component re-renders.
+ * `useCallbackOncePerRender` is a React hook that ensures a callback function is executed only once, regardless of how many times it's called.
+ *  This is useful for one-time operations that should not be repeated, even if the component re-renders.
  *
  * @param {() => void} callback - The callback function to be executed once.
  * @param {DependencyList} deps - Dependencies array that will trigger a new one-time execution when changed.

package/dist/hooks/useControlledState/index.d.cts

@@ -13,7 +13,7 @@ type UseControlledStateProps<T> = ControlledState<T> & {
 };
 /**
  * @description
- * `useControlledState` is a hook that allows you to control both controlled and uncontrolled states.
+ * `useControlledState` is a React hook that allows you to control both controlled and uncontrolled states.
  * If you pass the state to `value`, it will be a controlled state, and if you pass the state to `defaultValue`, it will be an uncontrolled state.
  * If both `value` and `defaultValue` are passed, `value` will take precedence.
  *

package/dist/hooks/useCounter/index.cjs

@@ -26,7 +26,7 @@ module.exports = __toCommonJS(useCounter_exports);
 
 // src/hooks/useCounter/useCounter.ts
 var import_react = require("react");
-function useCounter({ initialValue = 0, min, max, step = 1 } = {}) {
+function useCounter(initialValue = 0, { min, max, step = 1 } = {}) {
   const validateValue = (value) => {
     let validatedValue = value;
     if (min !== void 0 && validatedValue < min) {

package/dist/hooks/useCounter/index.d.cts

@@ -1,5 +1,4 @@
 type UseCounterOptions = {
-    initialValue?: number;
     min?: number;
     max?: number;
     step?: number;
@@ -16,8 +15,8 @@ type UseCounterReturn = {
  * `useCounter` is a React hook that manages a numeric counter state with increment, decrement, and reset capabilities.
  * Optionally, you can provide minimum and maximum values to constrain the counter's range.
  *
+ * @param {number} [initialValue=0] - Initial value for the counter. Defaults to 0.
  * @param {UseCounterOptions} options - The options for the counter.
- * @param {number} [options.initialValue=0] - Initial value for the counter. Defaults to 0.
  * @param {number} [options.min] - Minimum value the counter can reach. If not provided, there is no lower limit.
  * @param {number} [options.max] - Maximum value the counter can reach. If not provided, there is no upper limit.
  * @param {number} [options.step=1] - Value to increment or decrement by. Defaults to 1.
@@ -33,8 +32,7 @@ type UseCounterReturn = {
  * import { useCounter } from 'react-simplikit';
  *
  * function ShoppingCart() {
- *   const { count, increment, decrement, reset } = useCounter({
- *     initialValue: 1,
+ *   const { count, increment, decrement, reset } = useCounter(1, {
  *     min: 1,
  *     max: 10,
  *   });
@@ -49,6 +47,6 @@ type UseCounterReturn = {
  *   );
  * }
  */
-declare function useCounter({ initialValue, min, max, step }?: UseCounterOptions): UseCounterReturn;
+declare function useCounter(initialValue?: number, { min, max, step }?: UseCounterOptions): UseCounterReturn;
 
 export { useCounter };

package/dist/hooks/useDebouncedCallback/index.cjs

@@ -0,0 +1,144 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/hooks/useDebouncedCallback/index.ts
+var useDebouncedCallback_exports = {};
+__export(useDebouncedCallback_exports, {
+  useDebouncedCallback: () => useDebouncedCallback
+});
+module.exports = __toCommonJS(useDebouncedCallback_exports);
+
+// src/hooks/useDebouncedCallback/useDebouncedCallback.ts
+var import_react2 = require("react");
+
+// src/hooks/useDebounce/debounce.ts
+function debounce(func, debounceMs, { edges = ["leading", "trailing"] } = {}) {
+  let pendingThis = void 0;
+  let pendingArgs = null;
+  const leading = edges != null && edges.includes("leading");
+  const trailing = edges == null || edges.includes("trailing");
+  const invoke = () => {
+    if (pendingArgs !== null) {
+      func.apply(pendingThis, pendingArgs);
+      pendingThis = void 0;
+      pendingArgs = null;
+    }
+  };
+  const onTimerEnd = () => {
+    if (trailing) {
+      invoke();
+    }
+    cancel();
+  };
+  let timeoutId = null;
+  const schedule = () => {
+    if (timeoutId != null) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => {
+      timeoutId = null;
+      onTimerEnd();
+    }, debounceMs);
+  };
+  const cancelTimer = () => {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+  };
+  const cancel = () => {
+    cancelTimer();
+    pendingThis = void 0;
+    pendingArgs = null;
+  };
+  const debounced = function(...args) {
+    pendingThis = this;
+    pendingArgs = args;
+    const isFirstCall = timeoutId == null;
+    schedule();
+    if (leading && isFirstCall) {
+      invoke();
+    }
+  };
+  debounced.cancel = cancel;
+  return debounced;
+}
+
+// src/hooks/usePreservedCallback/usePreservedCallback.ts
+var import_react = require("react");
+function usePreservedCallback(callback) {
+  const callbackRef = (0, import_react.useRef)(callback);
+  (0, import_react.useEffect)(() => {
+    callbackRef.current = callback;
+  }, [callback]);
+  return (0, import_react.useCallback)((...args) => {
+    return callbackRef.current(...args);
+  }, []);
+}
+
+// src/hooks/useDebouncedCallback/useDebouncedCallback.ts
+function useDebouncedCallback({
+  onChange,
+  timeThreshold,
+  leading = false,
+  trailing = true
+}) {
+  const handleChange = usePreservedCallback(onChange);
+  const ref = (0, import_react2.useRef)({ value: false, clearPreviousDebounce: () => {
+  } });
+  (0, import_react2.useEffect)(() => {
+    const current = ref.current;
+    return () => {
+      current.clearPreviousDebounce();
+    };
+  }, []);
+  const edges = (0, import_react2.useMemo)(() => {
+    const _edges = [];
+    if (leading) {
+      _edges.push("leading");
+    }
+    if (trailing) {
+      _edges.push("trailing");
+    }
+    return _edges;
+  }, [leading, trailing]);
+  return (0, import_react2.useCallback)(
+    (nextValue) => {
+      if (nextValue === ref.current.value) {
+        return;
+      }
+      const debounced = debounce(
+        () => {
+          handleChange(nextValue);
+          ref.current.value = nextValue;
+        },
+        timeThreshold,
+        { edges }
+      );
+      ref.current.clearPreviousDebounce();
+      debounced();
+      ref.current.clearPreviousDebounce = debounced.cancel;
+    },
+    [handleChange, timeThreshold, edges]
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useDebouncedCallback
+});

package/dist/hooks/useDebouncedCallback/index.d.cts

@@ -0,0 +1,32 @@
+type DebounceOptions = {
+    leading?: boolean;
+    trailing?: boolean;
+};
+/**
+ * @description
+ * `useDebouncedCallback` is a React hook that returns a debounced version of the provided callback function.
+ * It helps optimize event handling by delaying function execution and grouping multiple calls into one.
+ *
+ * Note that if both 'leading' and 'trailing' are set, the function will be called at both the start and end of the delay period. However, it must be called at least twice within debounceMs interval for this to happen, since one debounced function call cannot trigger the function twice.
+ *
+ * @param {Object} options - The options object.
+ * @param {Function} options.onChange - The callback function to debounce.
+ * @param {number} options.timeThreshold - The number of milliseconds to delay the function execution.
+ * @param {boolean} [options.leading=false] - If `true`, the function is called at the start of the sequence.
+ * @param {boolean} [options.trailing=true] - If `true`, the function is called at the end of the sequence.
+ *
+ * @returns {Function} A debounced function that delays invoking the callback.
+ *
+ * @example
+ * function SearchInput() {
+ *   const [query, setQuery] = useState('');
+ *   const debouncedSetQuery = useDebouncedCallback({ onChange: setQuery, timeThreshold: 100 });
+ *   return <input type="text" onChange={(e) => debouncedSetQuery(e.target.value)} />;
+ * }
+ */
+declare function useDebouncedCallback({ onChange, timeThreshold, leading, trailing, }: DebounceOptions & {
+    onChange: (newValue: boolean) => void;
+    timeThreshold: number;
+}): (nextValue: boolean) => void;
+
+export { useDebouncedCallback };

package/dist/hooks/useDoubleClick/index.d.cts

@@ -11,10 +11,10 @@ type UseDoubleClickProps<E extends HTMLElement> = {
  * It delays the single click callback execution for a specified time, and cancels it if a second click (i.e. a double click) occurs within that time.
  *
  * @template {HTMLElement} E - The specific type of HTMLElement to be used with this hook (e.g., HTMLButtonElement, HTMLDivElement).
- * @param {Object} params - Configuration options for click handling.
- * @param {number} [params.delay=250] - The number of milliseconds to wait before triggering the single click callback. Defaults to 250ms.
- * @param {(event: MouseEvent<E>) => void} [params.click] - The callback function to be executed on a single click.
- * @param {(event: MouseEvent<E>) => void} params.doubleClick - The callback function to be executed on a double click. Required.
+ * @param {Object} props - Configuration options for click handling.
+ * @param {number} [props.delay=250] - The number of milliseconds to wait before triggering the single click callback. Defaults to 250ms.
+ * @param {(event: MouseEvent<E>) => void} [props.click] - The callback function to be executed on a single click.
+ * @param {(event: MouseEvent<E>) => void} props.doubleClick - The callback function to be executed on a double click. Required.
  *
  * @returns {(event: MouseEvent<E>) => void} A click handler function to attach to an element's `onClick` event.
  *

package/dist/hooks/useGeolocation/index.cjs

@@ -0,0 +1,153 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/hooks/useGeolocation/index.ts
+var useGeolocation_exports = {};
+__export(useGeolocation_exports, {
+  useGeolocation: () => useGeolocation
+});
+module.exports = __toCommonJS(useGeolocation_exports);
+
+// src/hooks/useGeolocation/useGeolocation.ts
+var import_react = 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_react.useState)({
+    loading: !!options?.mountBehavior,
+    error: null,
+    data: null
+  });
+  const [isTracking, setIsTracking] = (0, import_react.useState)(false);
+  const watchIdRef = (0, import_react.useRef)(null);
+  const checkGeolocationSupport = (0, import_react.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_react.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_react.useCallback)((error) => {
+    const { code, message } = error;
+    setState((prev) => ({
+      ...prev,
+      loading: false,
+      error: new CustomGeoLocationError({ code, message })
+    }));
+  }, []);
+  const getGeolocationOptions = (0, import_react.useCallback)(
+    () => ({
+      enableHighAccuracy: options?.enableHighAccuracy,
+      maximumAge: options?.maximumAge,
+      timeout: options?.timeout
+    }),
+    [options?.enableHighAccuracy, options?.maximumAge, options?.timeout]
+  );
+  const getCurrentPosition = (0, import_react.useCallback)(() => {
+    if (!checkGeolocationSupport()) {
+      return;
+    }
+    setState((prev) => ({ ...prev, loading: true }));
+    navigator.geolocation.getCurrentPosition(handleSuccess, handleError, getGeolocationOptions());
+  }, [handleSuccess, handleError, getGeolocationOptions, checkGeolocationSupport]);
+  const startTracking = (0, import_react.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_react.useCallback)(() => {
+    if (watchIdRef.current === null) {
+      return;
+    }
+    navigator.geolocation.clearWatch(watchIdRef.current);
+    watchIdRef.current = null;
+    setIsTracking(false);
+  }, []);
+  (0, import_react.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
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useGeolocation
+});

package/dist/hooks/useGeolocation/index.d.cts

@@ -0,0 +1,106 @@
+declare class CustomGeoLocationError extends Error {
+    code: number;
+    constructor({ code, message }: {
+        message: string;
+        code: number;
+    });
+}
+type GeolocationData = {
+    latitude: number;
+    longitude: number;
+    accuracy: number;
+    altitude: number | null;
+    altitudeAccuracy: number | null;
+    heading: number | null;
+    speed: number | null;
+    timestamp: number;
+};
+declare const GeolocationMountBehavior: {
+    readonly GET: "get";
+    readonly WATCH: "watch";
+};
+type GeolocationMountBehaviorType = (typeof GeolocationMountBehavior)[keyof typeof GeolocationMountBehavior];
+type GeolocationOptions = {
+    mountBehavior?: GeolocationMountBehaviorType;
+} & PositionOptions;
+/**
+ * @description
+ * `useGeolocation` is a React hook that retrieves and tracks the user's geographical location.
+ * It uses the browser's `Geolocation API` to support both one-time position retrieval and continuous location tracking.
+ *
+ * @param {GeolocationOptions} [options] - Geolocation options configuration
+ * @param {GeolocationMountBehaviorType} [options.mountBehavior] - How the hook behaves on mount:
+ *   -- If not provided, no automatic location fetching occurs
+ *   -- `get`: automatically fetches location once when component mounts
+ *   -- `watch`: automatically starts tracking location changes when component mounts
+ * @param {boolean} [options.enableHighAccuracy=false] - If true, provides more accurate position information (increases battery consumption)
+ * @param {number} [options.maximumAge=0] - Maximum age in milliseconds of a cached position that is acceptable to return
+ * @param {number} [options.timeout=Infinity] - Maximum time (in milliseconds) allowed for the location request
+ *
+ * @returns {Object} Object containing location data and related functions
+ * - loading `boolean` - Whether location data is currently being fetched;
+ * - error `CustomGeoLocationError|null` - Error object if an error occurred, or null
+ *   The hook uses standard Geolocation API error codes (`1-3`) and adds a custom code (`0`)
+ *   : `0` - Geolocation is not supported by the environment
+ *   : `1` - User denied permission to access geolocation
+ *   : `2` - Position unavailable
+ *   : `3` - Timeout - geolocation request took too long;
+ * - data `GeolocationData|null` - Location data object or null
+ *   : latitude `number` - The latitude in decimal degrees
+ *   : longitude `number` - The longitude in decimal degrees
+ *   : accuracy `number` - The accuracy of position in meters
+ *   : altitude `number|null` - The altitude in meters above the WGS84 ellipsoid
+ *   : altitudeAccuracy `number|null` - The altitude accuracy in meters
+ *   : heading `number|null` - The heading in degrees clockwise from true north
+ *   : speed `number|null` - The speed in meters per second
+ *   : timestamp `number` - The time when the position was retrieved;
+ * - getCurrentPosition `Function` - Function to get the current position once;
+ * - startTracking `Function` - Function to start tracking location changes;
+ * - stopTracking `Function` - Function to stop tracking location;
+ * - isTracking `boolean` - Whether location tracking is currently active;
+ *
+ * @example
+ * // Basic usage
+ * const {
+ *   loading,
+ *   error,
+ *   data,
+ *   getCurrentPosition
+ * } = useGeolocation();
+ *
+ * // Automatically fetch location when component mounts
+ * const {
+ *   loading,
+ *   error,
+ *   data
+ * } = useGeolocation({ mountBehavior: 'get' });
+ *
+ * // Location tracking
+ * const {
+ *   loading,
+ *   error,
+ *   data,
+ *   startTracking,
+ *   stopTracking,
+ *   isTracking
+ * } = useGeolocation();
+ *
+ * const handleStartTracking = () => {
+ *   startTracking();
+ * };
+ *
+ * const handleStopTracking = () => {
+ *   stopTracking();
+ * };
+ */
+declare function useGeolocation(options?: GeolocationOptions): {
+    getCurrentPosition: () => void;
+    startTracking: () => void;
+    stopTracking: () => void;
+    isTracking: boolean;
+    loading: boolean;
+    error: CustomGeoLocationError | null;
+    data: GeolocationData | null;
+};
+
+export { useGeolocation };

package/dist/hooks/useImpressionRef/index.d.cts

@@ -7,8 +7,8 @@ type UseImpressionRefOptions = Partial<{
 }>;
 /**
  * @description
- * `useImpressionRef` is a custom hook that measures the time a specific DOM element is visible on the screen and executes callbacks when the element enters or exits the viewport.
- * This hook uses `IntersectionObserver` and the `Visibility API` to track the element's visibility.
+ * `useImpressionRef` is a React hook that measures the time a specific DOM element is visible on the screen and executes callbacks when the element enters or exits the viewport.
+ * It uses `IntersectionObserver` and the `Visibility API` to track the element's visibility.
  *
  * @param {UseImpressionRefOptions} options - Options for tracking the element's visibility.
  * @param {() => void} [options.onImpressionStart] - Callback function executed when the element enters the view

package/dist/hooks/useIntersectionObserver/index.d.cts

@@ -1,7 +1,7 @@
 /**
  * @description
- * `useIntersectionObserver` is a custom hook that detects whether a specific DOM element is visible on the screen.
- * This hook uses the `IntersectionObserver` API to execute a callback when the element enters or exits the viewport.
+ * `useIntersectionObserver` is a React hook that detects whether a specific DOM element is visible on the screen.
+ * It uses the `IntersectionObserver` API to execute a callback when the element enters or exits the viewport.
  *
  * @param {(entry: IntersectionObserverEntry) => void} callback - A callback function that is executed when the visibility of the element changes.
  *   You can check `entry.isIntersecting` to determine if the element is in view.

package/dist/hooks/useIsomorphicLayoutEffect/index.d.cts

@@ -2,11 +2,11 @@ import { useEffect } from 'react';
 
 /**
  * @description
- * During SSR, there is no DOM to synchronously measure or mutate, so React warns about using useLayoutEffect.
+ * `useIsomorphicLayoutEffect` is a React hook that provides the behavior of `useLayoutEffect` without triggering warnings during server-side rendering.
+ * During SSR, there is no DOM to synchronously measure or mutate, so React warns about using `useLayoutEffect`.
  *
- * This hook provides the behavior of useLayoutEffect in the browser without triggering SSR warnings.
+ * This hook runs synchronously after DOM updates but before paint, making it ideal for:
  *
- * It runs synchronously after DOM updates but before paint, making it ideal for:
  * - Measuring DOM elements after render
  * - Applying DOM changes before paint
  * - Preventing UI flashes or layout shifts