react-simplikit 0.0.51 → 0.0.52

package/dist/hooks/useGeolocation/useGeolocation.cjs

@@ -0,0 +1,210 @@
+"use client";
+let react = require("react");
+//#region src/hooks/useGeolocation/useGeolocation.ts
+var CustomGeoLocationError = class extends Error {
+	code;
+	constructor({ code, message }) {
+		super(message);
+		this.name = "CustomGeoLocationError";
+		this.code = code;
+	}
+};
+const GeolocationMountBehavior = {
+	GET: "get",
+	WATCH: "watch"
+};
+/**
+* @deprecated This hook is deprecated as it depends on browser-specific APIs (navigator.geolocation).
+* react-simplikit is now focused on platform-independent, pure state/logic hooks.
+* This hook will be removed in a future major version.
+*
+* @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();
+* };
+*/
+function useGeolocation(options) {
+	const [state, setState] = (0, react.useState)({
+		loading: !!options?.mountBehavior,
+		error: null,
+		data: null
+	});
+	const [isTracking, setIsTracking] = (0, react.useState)(false);
+	const watchIdRef = (0, react.useRef)(null);
+	const checkGeolocationSupport = (0, 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, 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, react.useCallback)((error) => {
+		const { code, message } = error;
+		setState((prev) => ({
+			...prev,
+			loading: false,
+			error: new CustomGeoLocationError({
+				code,
+				message
+			})
+		}));
+	}, []);
+	const getGeolocationOptions = (0, react.useCallback)(() => ({
+		enableHighAccuracy: options?.enableHighAccuracy,
+		maximumAge: options?.maximumAge,
+		timeout: options?.timeout
+	}), [
+		options?.enableHighAccuracy,
+		options?.maximumAge,
+		options?.timeout
+	]);
+	const getCurrentPosition = (0, react.useCallback)(() => {
+		if (!checkGeolocationSupport()) return;
+		setState((prev) => ({
+			...prev,
+			loading: true
+		}));
+		navigator.geolocation.getCurrentPosition(handleSuccess, handleError, getGeolocationOptions());
+	}, [
+		handleSuccess,
+		handleError,
+		getGeolocationOptions,
+		checkGeolocationSupport
+	]);
+	const startTracking = (0, 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, react.useCallback)(() => {
+		if (watchIdRef.current === null) return;
+		navigator.geolocation.clearWatch(watchIdRef.current);
+		watchIdRef.current = null;
+		setIsTracking(false);
+	}, []);
+	(0, 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
+	};
+}
+//#endregion
+exports.CustomGeoLocationError = CustomGeoLocationError;
+exports.useGeolocation = useGeolocation;

package/{esm/hooks/useGeolocation/index.d.ts → dist/hooks/useGeolocation/useGeolocation.d.cts}

@@ -1,27 +1,29 @@
+
+//#region src/hooks/useGeolocation/useGeolocation.d.ts
 declare class CustomGeoLocationError extends Error {
+  code: number;
+  constructor({ code, message }: {
+    message: string;
     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;
+  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";
+  readonly GET: "get";
+  readonly WATCH: "watch";
 };
 type GeolocationMountBehaviorType = (typeof GeolocationMountBehavior)[keyof typeof GeolocationMountBehavior];
 type GeolocationOptions = {
-    mountBehavior?: GeolocationMountBehaviorType;
+  mountBehavior?: GeolocationMountBehaviorType;
 } & PositionOptions;
 /**
  * @deprecated This hook is deprecated as it depends on browser-specific APIs (navigator.geolocation).
@@ -98,13 +100,13 @@ type GeolocationOptions = {
  * };
  */
 declare function useGeolocation(options?: GeolocationOptions): {
-    getCurrentPosition: () => void;
-    startTracking: () => void;
-    stopTracking: () => void;
-    isTracking: boolean;
-    loading: boolean;
-    error: CustomGeoLocationError | null;
-    data: GeolocationData | null;
+  getCurrentPosition: () => void;
+  startTracking: () => void;
+  stopTracking: () => void;
+  isTracking: boolean;
+  loading: boolean;
+  error: CustomGeoLocationError | null;
+  data: GeolocationData | null;
 };
-
-export { useGeolocation };
+//#endregion
+export { CustomGeoLocationError, useGeolocation };

package/dist/hooks/useGeolocation/{index.d.cts → useGeolocation.d.mts}

@@ -1,27 +1,29 @@
+
+//#region src/hooks/useGeolocation/useGeolocation.d.ts
 declare class CustomGeoLocationError extends Error {
+  code: number;
+  constructor({ code, message }: {
+    message: string;
     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;
+  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";
+  readonly GET: "get";
+  readonly WATCH: "watch";
 };
 type GeolocationMountBehaviorType = (typeof GeolocationMountBehavior)[keyof typeof GeolocationMountBehavior];
 type GeolocationOptions = {
-    mountBehavior?: GeolocationMountBehaviorType;
+  mountBehavior?: GeolocationMountBehaviorType;
 } & PositionOptions;
 /**
  * @deprecated This hook is deprecated as it depends on browser-specific APIs (navigator.geolocation).
@@ -98,13 +100,13 @@ type GeolocationOptions = {
  * };
  */
 declare function useGeolocation(options?: GeolocationOptions): {
-    getCurrentPosition: () => void;
-    startTracking: () => void;
-    stopTracking: () => void;
-    isTracking: boolean;
-    loading: boolean;
-    error: CustomGeoLocationError | null;
-    data: GeolocationData | null;
+  getCurrentPosition: () => void;
+  startTracking: () => void;
+  stopTracking: () => void;
+  isTracking: boolean;
+  loading: boolean;
+  error: CustomGeoLocationError | null;
+  data: GeolocationData | null;
 };
-
-export { useGeolocation };
+//#endregion
+export { CustomGeoLocationError, useGeolocation };

package/dist/hooks/useGeolocation/useGeolocation.mjs

@@ -0,0 +1,209 @@
+"use client";
+import { useCallback, useEffect, useRef, useState } from "react";
+//#region src/hooks/useGeolocation/useGeolocation.ts
+var CustomGeoLocationError = class extends Error {
+	code;
+	constructor({ code, message }) {
+		super(message);
+		this.name = "CustomGeoLocationError";
+		this.code = code;
+	}
+};
+const GeolocationMountBehavior = {
+	GET: "get",
+	WATCH: "watch"
+};
+/**
+* @deprecated This hook is deprecated as it depends on browser-specific APIs (navigator.geolocation).
+* react-simplikit is now focused on platform-independent, pure state/logic hooks.
+* This hook will be removed in a future major version.
+*
+* @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();
+* };
+*/
+function useGeolocation(options) {
+	const [state, setState] = useState({
+		loading: !!options?.mountBehavior,
+		error: null,
+		data: null
+	});
+	const [isTracking, setIsTracking] = useState(false);
+	const watchIdRef = useRef(null);
+	const checkGeolocationSupport = 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 = 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 = useCallback((error) => {
+		const { code, message } = error;
+		setState((prev) => ({
+			...prev,
+			loading: false,
+			error: new CustomGeoLocationError({
+				code,
+				message
+			})
+		}));
+	}, []);
+	const getGeolocationOptions = useCallback(() => ({
+		enableHighAccuracy: options?.enableHighAccuracy,
+		maximumAge: options?.maximumAge,
+		timeout: options?.timeout
+	}), [
+		options?.enableHighAccuracy,
+		options?.maximumAge,
+		options?.timeout
+	]);
+	const getCurrentPosition = useCallback(() => {
+		if (!checkGeolocationSupport()) return;
+		setState((prev) => ({
+			...prev,
+			loading: true
+		}));
+		navigator.geolocation.getCurrentPosition(handleSuccess, handleError, getGeolocationOptions());
+	}, [
+		handleSuccess,
+		handleError,
+		getGeolocationOptions,
+		checkGeolocationSupport
+	]);
+	const startTracking = 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 = useCallback(() => {
+		if (watchIdRef.current === null) return;
+		navigator.geolocation.clearWatch(watchIdRef.current);
+		watchIdRef.current = null;
+		setIsTracking(false);
+	}, []);
+	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
+	};
+}
+//#endregion
+export { CustomGeoLocationError, useGeolocation };

package/dist/hooks/useImpressionRef/useImpressionRef.cjs

@@ -0,0 +1,67 @@
+"use client";
+const require_usePreservedCallback = require("../usePreservedCallback/usePreservedCallback.cjs");
+const require_useDebouncedCallback = require("../useDebouncedCallback/useDebouncedCallback.cjs");
+const require_useIntersectionObserver = require("../useIntersectionObserver/useIntersectionObserver.cjs");
+const require_useVisibilityEvent = require("../useVisibilityEvent/useVisibilityEvent.cjs");
+let react = require("react");
+//#region src/hooks/useImpressionRef/useImpressionRef.ts
+/**
+* @deprecated This hook is deprecated as it depends on browser-specific APIs (IntersectionObserver, Visibility API).
+* react-simplikit is now focused on platform-independent, pure state/logic hooks.
+* This hook will be removed in a future major version.
+*
+* @description
+* `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
+* @param {() => void} [options.onImpressionEnd] - Callback function executed when the element exits the view
+* @param {number} [options.timeThreshold=0] - Minimum time the element must be visible (in milliseconds)
+* @param {number} [options.areaThreshold=0] - Minimum ratio of the element that must be visible (0 to 1)
+* @param {string} options.rootMargin - Margin to adjust the detection area
+*
+* @returns {(element: Element | null) => void} A function to set the element. Attach this function to the `ref` attribute, and the callbacks will be executed whenever the element's visibility changes.
+*
+* @example
+* import { useImpressionRef } from 'react-simplikit';
+*
+* function Component() {
+*   const ref = useImpressionRef<HTMLDivElement>({
+*     onImpressionStart: () => console.log('Element entered view'),
+*     onImpressionEnd: () => console.log('Element exited view'),
+*     timeThreshold: 1000,
+*     areaThreshold: 0.5,
+*   });
+*
+*   return <div ref={ref}>Track my visibility!</div>;
+* }
+*/
+function useImpressionRef({ onImpressionStart = () => {}, onImpressionEnd = () => {}, rootMargin, areaThreshold = 0, timeThreshold = 0 }) {
+	const impressionStartHandler = require_usePreservedCallback.usePreservedCallback(onImpressionStart);
+	const impressionEndHandler = require_usePreservedCallback.usePreservedCallback(onImpressionEnd);
+	const isIntersectingRef = (0, react.useRef)(false);
+	const impressionEventHandler = require_useDebouncedCallback.useDebouncedCallback({
+		timeThreshold,
+		onChange: (impressed) => {
+			(impressed ? impressionStartHandler : impressionEndHandler)();
+		},
+		leading: true
+	});
+	require_useVisibilityEvent.useVisibilityEvent((documentVisible) => {
+		if (!isIntersectingRef.current) return;
+		impressionEventHandler(documentVisible === "visible");
+	});
+	return require_useIntersectionObserver.useIntersectionObserver((entry) => {
+		if (document.visibilityState === "hidden") return;
+		const currentRatio = entry.intersectionRatio;
+		const isIntersecting = areaThreshold === 0 ? entry.isIntersecting : currentRatio >= areaThreshold;
+		isIntersectingRef.current = isIntersecting;
+		impressionEventHandler(isIntersecting);
+	}, {
+		rootMargin,
+		threshold: areaThreshold
+	});
+}
+//#endregion
+exports.useImpressionRef = useImpressionRef;

package/{esm/hooks/useImpressionRef/index.d.ts → dist/hooks/useImpressionRef/useImpressionRef.d.cts}

@@ -1,9 +1,11 @@
+
+//#region src/hooks/useImpressionRef/useImpressionRef.d.ts
 type UseImpressionRefOptions = Partial<{
-    onImpressionStart: () => void;
-    onImpressionEnd: () => void;
-    rootMargin: string;
-    areaThreshold: number;
-    timeThreshold: number;
+  onImpressionStart: () => void;
+  onImpressionEnd: () => void;
+  rootMargin: string;
+  areaThreshold: number;
+  timeThreshold: number;
 }>;
 /**
  * @deprecated This hook is deprecated as it depends on browser-specific APIs (IntersectionObserver, Visibility API).
@@ -37,6 +39,6 @@ type UseImpressionRefOptions = Partial<{
  *   return <div ref={ref}>Track my visibility!</div>;
  * }
  */
-declare function useImpressionRef<Element extends HTMLElement>({ onImpressionStart, onImpressionEnd, rootMargin, areaThreshold, timeThreshold, }: UseImpressionRefOptions): (element: Element | null) => void;
-
-export { type UseImpressionRefOptions, useImpressionRef };
+declare function useImpressionRef<Element extends HTMLElement>({ onImpressionStart, onImpressionEnd, rootMargin, areaThreshold, timeThreshold }: UseImpressionRefOptions): (element: Element | null) => void;
+//#endregion
+export { UseImpressionRefOptions, useImpressionRef };

package/dist/hooks/useImpressionRef/{index.d.cts → useImpressionRef.d.mts}

@@ -1,9 +1,11 @@
+
+//#region src/hooks/useImpressionRef/useImpressionRef.d.ts
 type UseImpressionRefOptions = Partial<{
-    onImpressionStart: () => void;
-    onImpressionEnd: () => void;
-    rootMargin: string;
-    areaThreshold: number;
-    timeThreshold: number;
+  onImpressionStart: () => void;
+  onImpressionEnd: () => void;
+  rootMargin: string;
+  areaThreshold: number;
+  timeThreshold: number;
 }>;
 /**
  * @deprecated This hook is deprecated as it depends on browser-specific APIs (IntersectionObserver, Visibility API).
@@ -37,6 +39,6 @@ type UseImpressionRefOptions = Partial<{
  *   return <div ref={ref}>Track my visibility!</div>;
  * }
  */
-declare function useImpressionRef<Element extends HTMLElement>({ onImpressionStart, onImpressionEnd, rootMargin, areaThreshold, timeThreshold, }: UseImpressionRefOptions): (element: Element | null) => void;
-
-export { type UseImpressionRefOptions, useImpressionRef };
+declare function useImpressionRef<Element extends HTMLElement>({ onImpressionStart, onImpressionEnd, rootMargin, areaThreshold, timeThreshold }: UseImpressionRefOptions): (element: Element | null) => void;
+//#endregion
+export { UseImpressionRefOptions, useImpressionRef };