@siberiacancode/reactuse 0.0.112 → 0.0.114

package/dist/types/hooks/useMutation/useMutation.d.ts

@@ -0,0 +1,36 @@
+interface UseMutationOptions<Data> {
+    retry?: ((failureCount: number, error: Error) => boolean) | boolean | number;
+    retryDelay?: ((retry: number, error: Error) => number) | number;
+    onError?: (error: Error) => void;
+    onSuccess?: (data: Data) => void;
+}
+interface UseMutationReturn<Body, Data> {
+    data: Data | null;
+    error: Error | null;
+    isError: boolean;
+    isLoading: boolean;
+    isSuccess: boolean;
+    mutate: (body?: Body, options?: UseMutationOptions<Data>) => void;
+    mutateAsync: (body?: Body, options?: UseMutationOptions<Data>) => Promise<Data>;
+}
+export interface RequestOptions<Data> extends UseMutationOptions<Data> {
+    attempt?: number;
+}
+/**
+ * @name useMutation
+ * @description - Hook that defines the logic when mutate data
+ * @category Utilities
+ *
+ * @template Body The type of the body
+ * @template Data The type of the data
+ * @param {(body: Body) => Promise<Data>} callback The callback function to be invoked
+ * @param {boolean | number} [options.retry] The retry count of requests
+ * @param {(data: Data) => void} [options.onSuccess] The callback function to be invoked on success
+ * @param {(error: Error) => void} [options.onError] The callback function to be invoked on error
+ * @returns {UseMutationReturn<Data>} An object with the state of the mutation
+ *
+ * @example
+ * const { mutate, mutateAsync, isLoading, isError, isSuccess, error, data } = useMutation((name) => Promise.resolve(name));
+ */
+export declare const useMutation: <Body, Data>(callback: (body: Body) => Promise<Data>, options?: UseMutationOptions<Data>) => UseMutationReturn<Body, Data>;
+export {};

package/dist/types/hooks/useMutationObserver/useMutationObserver.d.ts

@@ -0,0 +1,60 @@
+import { HookTarget } from '../../utils/helpers';
+import { StateRef } from '../useRefState/useRefState';
+/** The mutation observer target element type */
+export type UseMutationObserverTarget = HookTarget;
+/** The mutation observer return type */
+export interface UseMutationObserverReturn {
+    /** The mutation observer instance */
+    observer: MutationObserver;
+    /** The mutation observer entries */
+    stop: () => void;
+}
+/** The mutation observer options type */
+export interface UseMutationObserverOptions extends MutationObserverInit {
+    /** The enabled state of the mutation observer */
+    enabled?: boolean;
+}
+export interface UseMutationObserver {
+    (target: HookTarget, callback: MutationCallback, options?: UseMutationObserverOptions): UseMutationObserverReturn;
+    <Target extends Element>(callback: MutationCallback, options?: UseMutationObserverOptions, target?: never): UseMutationObserverReturn & {
+        ref: StateRef<Target>;
+    };
+}
+/**
+ * @name useMutationObserver
+ * @description - Hook that gives you mutation observer state
+ * @category Browser
+ *
+ * @overload
+ * @template Target The target element
+ * @param {MutationCallback} callback The callback to execute when mutation is detected
+ * @param {boolean} [options.enabled=true] The enabled state of the mutation observer
+ * @param {boolean} [options.attributes] Set to true if mutations to target's attributes are to be observed
+ * @param {boolean} [options.characterData] Set to true if mutations to target's data are to be observed
+ * @param {boolean} [options.childList] Set to true if mutations to target's children are to be observed
+ * @param {boolean} [options.subtree]  Set to true if mutations to not just target, but also target's descendants are to be observed
+ * @param {boolean} [options.characterDataOldValue] Set to true if characterData is set to true or omitted and target's data before the mutation needs to be recorded
+ * @param {boolean} [options.attributeOldValue]  Set to a list of attribute local names (without namespace) if not all attribute mutations need to be observed and attributes is true or omitted
+ * @param {string[]} [options.attributeFilter] Set to a list of attribute local names (without namespace) if not all attribute mutations need to be observed and attributes is true or omitted
+ * @returns {UseMutationObserverReturn & { ref: StateRef<Target> }} An object containing the mutation observer state
+ *
+ * @example
+ * const { ref, observer, stop } = useMutationObserver(() => console.log('callback'))
+ *
+ * @overload
+ * @param {HookTarget} target The target element to observe
+ * @param {MutationCallback} callback The callback to execute when mutation is detected
+ * @param {boolean} [options.enabled=true] The enabled state of the mutation observer
+ * @param {boolean} [options.attributes] Set to true if mutations to target's attributes are to be observed
+ * @param {boolean} [options.characterData] Set to true if mutations to target's data are to be observed
+ * @param {boolean} [options.childList] Set to true if mutations to target's children are to be observed
+ * @param {boolean} [options.subtree]  Set to true if mutations to not just target, but also target's descendants are to be observed
+ * @param {boolean} [options.characterDataOldValue] Set to true if characterData is set to true or omitted and target's data before the mutation needs to be recorded
+ * @param {boolean} [options.attributeOldValue]  Set to a list of attribute local names (without namespace) if not all attribute mutations need to be observed and attributes is true or omitted
+ * @param {string[]} [options.attributeFilter] Set to a list of attribute local names (without namespace) if not all attribute mutations need to be observed and attributes is true or omitted
+ * @returns {UseMutationObserverReturn} An object containing the mutation observer state
+ *
+ * @example
+ * const { observer, stop } = useMutationObserver(ref, () => console.log('callback'))
+ */
+export declare const useMutationObserver: UseMutationObserver;

package/dist/types/hooks/useNetwork/useNetwork.d.ts

@@ -0,0 +1,51 @@
+export interface Connection extends EventTarget {
+    readonly downlink: number;
+    readonly downlinkMax: number;
+    readonly effectiveType: '2g' | '3g' | '4g' | 'slow-2g';
+    readonly rtt: number;
+    readonly saveData: boolean;
+    onChange: (event: Event) => void;
+    readonly type: 'bluetooth' | 'cellular' | 'ethernet' | 'mixed' | 'none' | 'other' | 'unknown' | 'wifi' | 'wimax';
+}
+declare global {
+    interface Navigator {
+        readonly connection: Connection;
+        readonly mozConnection: Connection;
+        readonly webkitConnection: Connection;
+    }
+}
+/** The type of network connection */
+export type ConnectionType = Connection['type'];
+/** The effective type of connection */
+export type ConnectionEffectiveType = Connection['effectiveType'];
+/** The use network return type */
+export interface UseNetworkReturn {
+    /** The estimated downlink speed in megabits per seconds */
+    downlink?: Connection['downlink'];
+    /** The maximum downlink speed, if available */
+    downlinkMax?: Connection['downlinkMax'];
+    /** The effective type of connection (e.g., '2g', '3g', '4g') */
+    effectiveType?: Connection['effectiveType'];
+    /** Indicates if the device is currently online */
+    online: boolean;
+    /** The estimated round-trip time in milliseconds */
+    rtt?: Connection['rtt'];
+    /** Indicates if the user has enabled data saving mode */
+    saveData?: Connection['saveData'];
+    /** The type of network connection (e.g., 'wifi', 'cellular') */
+    type?: Connection['type'];
+}
+export declare const getConnection: () => Connection;
+/**
+ * @name useNetwork
+ * @description - Hook to track network status
+ * @category Sensors
+ *
+ * @browserapi navigator.connection https://developer.mozilla.org/en-US/docs/Web/API/Navigator/connection
+ *
+ * @returns {UseNetworkReturn} An object containing the network status
+ *
+ * @example
+ * const { online, downlink, downlinkMax, effectiveType, rtt, saveData, type } = useNetwork();
+ */
+export declare const useNetwork: () => UseNetworkReturn;

package/dist/types/hooks/useOffsetPagination/useOffsetPagination.d.ts

@@ -0,0 +1,68 @@
+/** The use offset pagination return type */
+export interface UseOffsetPaginationOptions {
+    /** The initial page number */
+    initialPage?: number;
+    /** The number of items per page */
+    pageSize?: number;
+    /** The total number of items */
+    total?: number;
+    /** The callback function to be invoked when page changes */
+    onPageChange?: ({ page, pageSize }: {
+        page: number;
+        pageSize: number;
+    }) => void;
+    /** The callback function to be invoked when page count changes */
+    onPageCountChange?: ({ page, pageSize }: {
+        page: number;
+        pageSize: number;
+    }) => void;
+    /** The callback function to be invoked when page size changes */
+    onPageSizeChange?: ({ page, pageSize }: {
+        page: number;
+        pageSize: number;
+    }) => void;
+}
+/** The use offset pagination return type */
+export interface UseOffsetPaginationReturn {
+    /** The number of items per page */
+    currentPageSize: number;
+    /** Whether the current page is the first page */
+    isFirstPage: boolean;
+    /** Whether the current page is the last page */
+    isLastPage: boolean;
+    /** The current page number */
+    page: number;
+    /** The total number of pages */
+    pageCount: number;
+    /** The callback function to go to the next page */
+    next: () => void;
+    /** The callback function to go to the previous page */
+    prev: () => void;
+    /** The callback function to set the current page */
+    set: (page: number) => void;
+}
+/**
+ * @name useOffsetPagination
+ * @description - Hook that defines the logic when pagination
+ * @category Utilities
+ *
+ * @param {UseOffsetPaginationOptions} options - The options for the hook
+ * @param {number} [options.total] - The total number of items
+ * @param {number} [options.pageSize] - The number of items per page
+ * @param {number} [options.initialPage] - The current page
+ * @param {({ page, pageSize }: { page: number; pageSize: number }) => void} [options.onPageChange] - The callback function to be invoked when page changes
+ * @param {({ page, pageSize }: { page: number; pageSize: number }) => void} [options.onPageCountChange] - The callback function to be invoked when page count changes
+ * @param {({ page, pageSize }: { page: number; pageSize: number }) => void} [options.onPageSizeChange] - The callback function to be invoked when page size changes
+ * @returns {UseOffsetPaginationReturn} - The state of the hook
+ *
+ * @example
+ * const { currentPage, currentPageSize, pageCount, isFirstPage, isLastPage, prev, next } = useOffsetPagination({
+ *  total: 100,
+ *  pageSize: 10,
+ *  page: 1,
+ *  onPageChange: (page) => {},
+ *  onPageCountChange: (pageCount) => {},
+ *  onPageSizeChange: (pageSize) => {}
+ * });
+ */
+export declare const useOffsetPagination: ({ total, pageSize, initialPage, onPageChange, onPageCountChange, onPageSizeChange }?: UseOffsetPaginationOptions) => UseOffsetPaginationReturn;

package/dist/types/hooks/useOnce/useOnce.d.ts

@@ -0,0 +1,14 @@
+import { EffectCallback } from 'react';
+/**
+ * @name useEffectOnce
+ * @description - Hook that runs an effect only once. Please do not use it in production code!
+ * @category Humor
+ *
+ * @warning - This hook will run effect only once even in strict mode. Please do not use it in production code!
+ *
+ * @param {EffectCallback} effect The effect to run
+ *
+ * @example
+ * useOnce(() => console.log('effect once'));
+ */
+export declare function useOnce(effect: EffectCallback): void;

package/dist/types/hooks/useOnline/useOnline.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @name useOnline
+ * @description - Hook that manages if the user is online
+ * @category Sensors
+ *
+ * @browserapi navigator.onLine https://developer.mozilla.org/en-US/docs/Web/API/Navigator/onLine
+ *
+ * @returns {boolean} A boolean indicating if the user is online
+ *
+ * @example
+ * const online = useOnline();
+ */
+export declare const useOnline: () => boolean;

package/dist/types/hooks/useOperatingSystem/useOperatingSystem.d.ts

@@ -0,0 +1,14 @@
+/** The operating system type */
+export type OperatingSystem = 'android' | 'ios' | 'linux' | 'macos' | 'undetermined' | 'windows';
+export declare const getOperatingSystem: () => OperatingSystem;
+/**
+ * @name useOperatingSystem
+ * @description - Hook that returns the operating system of the current browser
+ * @category Browser
+ *
+ * @returns {OperatingSystem} The operating system
+ *
+ * @example
+ * const operatingSystem = useOperatingSystem();
+ */
+export declare const useOperatingSystem: () => OperatingSystem;

package/dist/types/hooks/useOptimistic/useOptimistic.d.ts

@@ -0,0 +1,18 @@
+export type UseOptimisticReturn<State> = [
+    State,
+    (optimisticValue: State, promise: Promise<any>) => void
+];
+/**
+ * @name useOptimistic
+ * @description - Hook that allows get optimistic value before its update
+ * @category Utilities
+ *
+ * @template State The type of the state
+ * @param {State} state The value to be returned initially and whenever no action is pending
+ * @param {(currentState: State, optimisticValue: State) => State} update A pure function that takes the current state and the optimistic value passed to updateOptimistic and returns the resulting optimistic state
+ * @returns {UseOptimisticReturn<State>} The resulting optimistic state, and the function to update it
+ *
+ * @example
+ * const [optimisticValue, updateOptimistic] = useOptimistic<number>(count, (currentState, optimisticValue) => currentState + optimisticValue);
+ */
+export declare const useOptimistic: <State, OptimisticState = State>(externalState: State, update: (currentState: State, optimisticState: OptimisticState) => State) => readonly [State, (optimisticValue: OptimisticState, promise: Promise<any>) => Promise<any>];

package/dist/types/hooks/useOrientation/useOrientation.d.ts

@@ -0,0 +1,20 @@
+/** The use orientation return type */
+export interface UseOrientationReturn {
+    /** The current screen orientation angle */
+    angle: number;
+    /** The screen orientation type */
+    type: OrientationType;
+}
+/**
+ * @name useOrientation
+ * @description - Hook that returns the current screen orientation
+ * @category Browser
+ *
+ * @browserapi window.screen.orientation https://developer.mozilla.org/en-US/docs/Web/API/Screen/orientation
+ *
+ * @returns {UseOrientationReturn} An object containing the current screen orientation
+ *
+ * @example
+ * const { angle, type } = useOrientation();
+ */
+export declare const useOrientation: () => UseOrientationReturn;

package/dist/types/hooks/useOtpCredential/useOtpCredential.d.ts

@@ -0,0 +1,49 @@
+declare global {
+    interface OTPOptions {
+        readonly transport: string[];
+    }
+    interface CredentialRequestOptions {
+        readonly otp: OTPOptions;
+    }
+    interface Credential {
+        readonly code: string;
+    }
+}
+export type UseOtpCredentialCallback = (otp: Credential | null) => void;
+export interface UseOtpCredentialParams {
+    onError: (error: any) => void;
+    onSuccess: (credential: Credential | null) => void;
+}
+export interface UseOtpCredentialReturn {
+    abort: AbortController['abort'];
+    aborted: boolean;
+    supported: boolean;
+    get: () => Promise<Credential | null>;
+}
+export interface UseOtpCredential {
+    (callback?: UseOtpCredentialCallback): UseOtpCredentialReturn;
+    (params?: UseOtpCredentialParams): UseOtpCredentialReturn;
+}
+/**
+ * @name useOtpCredential
+ * @description - Hook that creates an otp credential
+ * @category Browser
+ *
+ * @browserapi navigator.credentials https://developer.mozilla.org/en-US/docs/Web/API/Navigator/credentials
+ *
+ * @overload
+ * @param {UseOtpCredentialCallback} callback The callback function to be invoked
+ * @returns {UseOtpCredentialReturn}
+ *
+ * @example
+ * useOtpCredential((credential) => console.log(credential));
+ *
+ * @overload
+ * @param {UseOtpCredentialCallback} params.onSuccess The callback function to be invoked on success
+ * @param {UseOtpCredentialCallback} params.onError The callback function to be invoked on error
+ * @returns {UseOtpCredentialReturn}
+ *
+ * @example
+ * useOtpCredential({ onSuccess: (credential) => console.log(credential), onError: (error) => console.log(error) });
+ */
+export declare const useOtpCredential: UseOtpCredential;

package/dist/types/hooks/usePageLeave/usePageLeave.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @name usePageLeave
+ * @description - Hook what calls given function when mouse leaves the page
+ * @category Sensors
+ *
+ * @param {() => void} [callback] The callback function what calls then mouse leaves the page
+ * @returns {boolean} A boolean which determines if the mouse left the page
+ *
+ * @example
+ * const isLeft = usePageLeave(() => console.log('on leave'))
+ */
+export declare const usePageLeave: (callback?: () => void) => boolean;

package/dist/types/hooks/usePaint/usePaint.d.ts

@@ -0,0 +1,97 @@
+import { HookTarget } from '../../utils/helpers';
+import { StateRef } from '../useRefState/useRefState';
+export interface Point {
+    x: number;
+    y: number;
+}
+export declare class Pointer implements Point {
+    x: number;
+    y: number;
+    constructor(x: number, y: number);
+    update(point: Point): void;
+    getDifferenceTo(point: Point): Pointer;
+    getDistanceTo(point: Point): number;
+    getAngleTo(point: Point): number;
+    equalsTo(point: Point): boolean;
+    moveByAngle(angle: number, distance: number): this;
+}
+export declare class Paint {
+    pointer: Pointer;
+    brush: Pointer;
+    radius: number;
+    smooth: boolean;
+    points: Point[];
+    lines: {
+        points: Point[];
+        color: string;
+        radius: number;
+        opacity: number;
+    }[];
+    constructor({ x, y, radius, smooth }: {
+        x: number;
+        y: number;
+        radius: number;
+        smooth: boolean;
+    });
+    getBrushCoordinates(): {
+        x: number;
+        y: number;
+    };
+    getPointerCoordinates(): {
+        x: number;
+        y: number;
+    };
+    update(point: Point): boolean;
+}
+export interface UsePaintOptions {
+    /** Brush color */
+    color?: string;
+    /** Initial lines */
+    initialLines?: Paint['lines'];
+    /** Brush opacity */
+    opacity?: number;
+    /** Brush radius */
+    radius?: number;
+    /** Smooth brush movement */
+    smooth?: boolean;
+    /** Callback when the mouse is down */
+    onMouseDown?: (event: MouseEvent, paint: Paint) => void;
+    /** Callback when the mouse is moved */
+    onMouseMove?: (event: MouseEvent, paint: Paint) => void;
+    /** Callback when the mouse is up */
+    onMouseUp?: (event: MouseEvent, paint: Paint) => void;
+}
+export interface UsePaintReturn {
+    drawing: boolean;
+    lines: Paint['lines'];
+    clear: () => void;
+    draw: (points: Point[], color: string, opacity: number, radius: number) => void;
+    undo: () => void;
+}
+export interface UsePaint {
+    (target: HookTarget, options?: UsePaintOptions): UsePaintReturn;
+    <Target extends HTMLCanvasElement>(options?: UsePaintOptions, target?: never): UsePaintReturn & {
+        ref: StateRef<Target>;
+    };
+}
+/**
+ * @name usePaint
+ * @description - Hook that allows you to draw in a specific area
+ * @category Browser
+ *
+ * @overload
+ * @param {HookTarget} target The target element to be painted
+ * @param {UsePaintOptions} [options] The options to be used
+ * @returns {UsePaintReturn} An object containing the current pencil options and functions to interact with the paint
+ *
+ * @example
+ * const drawing = usePaint(canvasRef);
+ *
+ * @overload
+ * @param {UsePaintOptions} [options] The options to be used
+ * @returns {UsePaintReturn & { ref: StateRef<HTMLCanvasElement> }} An object containing the current pencil options and functions to interact with the paint
+ *
+ * @example
+ * const { ref, drawing } = usePaint();
+ */
+export declare const usePaint: UsePaint;

package/dist/types/hooks/useParallax/useParallax.d.ts

@@ -0,0 +1,54 @@
+import { HookTarget } from '../../utils/helpers';
+import { StateRef } from '../useRefState/useRefState';
+/** The use parallax value type */
+export interface UseParallaxValue {
+    /** Roll value. Scaled to `-0.5 ~ 0.5` */
+    roll: number;
+    /** Sensor source, can be `mouse` or `deviceOrientation` */
+    source: 'deviceOrientation' | 'mouse';
+    /** Tilt value. Scaled to `-0.5 ~ 0.5` */
+    tilt: number;
+}
+/** The use parallax options type */
+export interface UseParallaxOptions {
+    /** Device orientation roll adjust function */
+    deviceOrientationRollAdjust?: (value: number) => number;
+    /** Device orientation tilt adjust function */
+    deviceOrientationTiltAdjust?: (value: number) => number;
+    /** Mouse roll adjust function */
+    mouseRollAdjust?: (value: number) => number;
+    /** Mouse tilt adjust function */
+    mouseTiltAdjust?: (value: number) => number;
+}
+interface UseParallaxReturn {
+    value: UseParallaxValue;
+}
+export interface UseParallax {
+    (target: HookTarget, options?: UseParallaxOptions): UseParallaxReturn;
+    <Target extends Element>(options?: UseParallaxOptions, target?: never): UseParallaxReturn & {
+        ref: StateRef<Target>;
+    };
+}
+/**
+ * @name useParallax
+ * @description - Hook to help create parallax effect
+ * @category Sensors
+ *
+ * @overload
+ * @param {HookTarget} target The target element for the parallax effect
+ * @param {UseParallaxOptions} options The options for the parallax effect
+ * @returns {UseParallaxReturn} An object of parallax values
+ *
+ * @example
+ * const { value } = useParallax(ref);
+ *
+ * @overload
+ * @template Target The target element for the parallax effect
+ * @param {UseParallaxOptions} options The options for the parallax effect
+ * @returns {UseParallaxReturn & { ref: StateRef<Target> }} An object of parallax values
+ *
+ * @example
+ * const { ref, value } = useParallax();
+ */
+export declare const useParallax: UseParallax;
+export {};

package/dist/types/hooks/usePerformanceObserver/usePerformanceObserver.d.ts

@@ -0,0 +1,25 @@
+/** The use performance observer options type */
+export type UsePerformanceObserverOptions = PerformanceObserverInit & {
+    /** Whether to start the observer immediately */
+    immediate?: boolean;
+};
+/**
+ * @name usePerformanceObserver
+ * @description - Hook that allows you to observe performance entries
+ * @category Sensors
+ *
+ * @browserapi PerformanceObserver https://developer.mozilla.org/en-US/docs/Web/API/PerformanceObserver
+ *
+ * @param {UsePerformanceObserverOptions} options The options for the performance observer
+ * @param {PerformanceObserverCallback} callback The function to handle performance entries
+ * @returns {object} An object containing the observer's support status and methods to start and stop the observer
+ *
+ * @example
+ * const { supported, entries, start, stop } = usePerformanceObserver();
+ */
+export declare const usePerformanceObserver: (options: UsePerformanceObserverOptions, callback?: PerformanceObserverCallback) => {
+    supported: boolean;
+    entries: PerformanceEntry[];
+    start: () => void;
+    stop: () => void;
+};

package/dist/types/hooks/usePermission/usePermission.d.ts

@@ -0,0 +1,35 @@
+/** The permission name */
+export type UsePermissionName = 'accelerometer' | 'accessibility-events' | 'ambient-light-sensor' | 'background-sync' | 'camera' | 'clipboard-read' | 'clipboard-write' | 'gyroscope' | 'magnetometer' | 'microphone' | 'notifications' | 'payment-handler' | 'persistent-storage' | 'push' | 'speaker' | PermissionName;
+/** The use permission options type */
+export interface UsePermissionOptions {
+    /** Whether the permission is enabled */
+    enabled: boolean;
+}
+/** The use permission return type */
+export interface UsePermissionReturn {
+    /** The permission state */
+    state: PermissionState;
+    /** The permission supported status */
+    supported: boolean;
+    /** The permission query function */
+    query: () => Promise<PermissionState>;
+}
+/**
+ *  @name usePermission
+ *  @description - Hook that gives you the state of permission
+ *  @category Browser
+ *
+ *  @browserapi navigator.permissions https://developer.mozilla.org/en-US/docs/Web/API/Navigator/permissions
+ *
+ *  @param {UsePermissionName} permissionDescriptorName - The permission name
+ *  @param {boolean} [options.enabled=true] - Whether the permission is enabled
+ *  @returns {UsePermissionReturn} An object containing the state and the supported status
+ *
+ *  @example
+ *  const { state, supported, query } = usePermission('microphone');
+ */
+export declare const usePermission: (permissionDescriptorName: UsePermissionName, options?: UsePermissionOptions) => {
+    state: PermissionState;
+    supported: boolean;
+    query: () => Promise<PermissionState>;
+};

package/dist/types/hooks/usePointerLock/usePointerLock.d.ts

@@ -0,0 +1,26 @@
+import { MouseEvent } from 'react';
+/** The use pointer lock return type */
+interface UsePointerLockReturn {
+    /** The pointer lock element */
+    element?: Element;
+    /** Whether the pointer lock is supported */
+    supported: boolean;
+    /** Lock the pointer lock */
+    lock: (event: MouseEvent) => void;
+    /** Unlock the pointer lock */
+    unlock: () => boolean;
+}
+/**
+ * @name usePointerLock
+ * @description - Hook that provides reactive pointer lock
+ * @category Sensors
+ *
+ * @browserapi pointerLockElement https://developer.mozilla.org/en-US/docs/Web/API/Document/pointerLockElement
+ *
+ * @returns {UsePointerLockReturn} An object containing the pointer lock element and functions to interact with the pointer lock
+ *
+ * @example
+ * const { supported, lock, unlock, element } = usePointerLock();
+ */
+export declare const usePointerLock: () => UsePointerLockReturn;
+export {};

package/dist/types/hooks/usePostMessage/usePostMessage.d.ts

@@ -0,0 +1,16 @@
+export type UsePostMessageReturn<Message> = (message: Message) => void;
+/**
+ * @name usePostMessage
+ * @description - Hook that allows you to receive messages from other origins
+ * @category Browser
+ *
+ * @overload
+ * @template Message The message data type
+ * @param {string | string[]} origin The origin of the message
+ * @param {(message: Message) => Message} callback callback to get received message
+ * @returns {(message: Message) => void} An object containing the current message
+ *
+ * @example
+ * const postMessage = usePostMessage();
+ */
+export declare const usePostMessage: <Message>(origin: string | "*" | string[], callback: (message: Message, event: MessageEvent<Message>) => void) => UsePostMessageReturn<Message>;

package/dist/types/hooks/usePreferredColorScheme/usePreferredColorScheme.d.ts

@@ -0,0 +1,13 @@
+/** The use preferred color scheme return type */
+export type UsePreferredColorSchemeReturn = 'dark' | 'light' | 'no-preference';
+/**
+ * @name usePreferredColorScheme
+ * @description - Hook that returns user preferred color scheme
+ * @category Browser
+ *
+ * @returns {UsePreferredColorSchemeReturn} String of preferred color scheme
+ *
+ * @example
+ * const colorScheme = usePreferredColorScheme();
+ */
+export declare const usePreferredColorScheme: () => UsePreferredColorSchemeReturn;

package/dist/types/hooks/usePreferredContrast/usePreferredContrast.d.ts

@@ -0,0 +1,13 @@
+/** The use preferred contrast return type */
+export type UsePreferredContrastReturn = 'custom' | 'less' | 'more' | 'no-preference';
+/**
+ * @name usePreferredContrast
+ * @description - Hook that returns the contrast preference
+ * @category Browser
+ *
+ * @returns {UsePreferredContrastReturn} The contrast preference
+ *
+ * @example
+ * const contrast = usePreferredContrast();
+ */
+export declare const usePreferredContrast: () => UsePreferredContrastReturn;

package/dist/types/hooks/usePreferredDark/usePreferredDark.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @name usePreferredDark
+ * @description - Hook that returns if the user prefers dark mode
+ * @category Browser
+ *
+ * @example
+ * const isDark = usePreferredDark();
+ */
+export declare const usePreferredDark: () => boolean;