@mantine/hooks 8.3.13 → 9.0.0-alpha.0

package/lib/index.d.ts

@@ -21,7 +21,7 @@ export { useLocalStorage, readLocalStorageValue } from './use-local-storage/use-
 export { useSessionStorage, readSessionStorageValue, } from './use-session-storage/use-session-storage.js';
 export { useMediaQuery } from './use-media-query/use-media-query.js';
 export { useMergedRef, mergeRefs, assignRef } from './use-merged-ref/use-merged-ref.js';
-export { useMouse } from './use-mouse/use-mouse.js';
+export { useMouse, useMousePosition } from './use-mouse/use-mouse.js';
 export { useMove, clampUseMovePosition } from './use-move/use-move.js';
 export { usePagination } from './use-pagination/use-pagination.js';
 export { useQueue } from './use-queue/use-queue.js';
@@ -38,7 +38,7 @@ export { useWindowScroll } from './use-window-scroll/use-window-scroll.js';
 export { useIntersection } from './use-intersection/use-intersection.js';
 export { useHash } from './use-hash/use-hash.js';
 export { useHotkeys, getHotkeyHandler } from './use-hotkeys/use-hotkeys.js';
-export { useFullscreen } from './use-fullscreen/use-fullscreen.js';
+export { useFullscreenDocument, useFullscreenElement } from './use-fullscreen/use-fullscreen.js';
 export { useLogger } from './use-logger/use-logger.js';
 export { useHover } from './use-hover/use-hover.js';
 export { useValidatedState } from './use-validated-state/use-validated-state.js';
@@ -56,7 +56,7 @@ export { useFavicon } from './use-favicon/use-favicon.js';
 export { useHeadroom } from './use-headroom/use-headroom.js';
 export { useEyeDropper } from './use-eye-dropper/use-eye-dropper.js';
 export { useInViewport } from './use-in-viewport/use-in-viewport.js';
-export { useMutationObserver } from './use-mutation-observer/use-mutation-observer.js';
+export { useMutationObserver, useMutationObserverTarget, } from './use-mutation-observer/use-mutation-observer.js';
 export { useMounted } from './use-mounted/use-mounted.js';
 export { useStateHistory } from './use-state-history/use-state-history.js';
 export { useMap } from './use-map/use-map.js';
@@ -69,25 +69,29 @@ export { useOrientation } from './use-orientation/use-orientation.js';
 export { useFetch } from './use-fetch/use-fetch.js';
 export { useRadialMove, normalizeRadialValue } from './use-radial-move/use-radial-move.js';
 export { useScrollSpy } from './use-scroll-spy/use-scroll-spy.js';
+export { useScroller } from './use-scroller/use-scroller.js';
 export { useFileDialog } from './use-file-dialog/use-file-dialog.js';
 export { useLongPress } from './use-long-press/use-long-press.js';
 export { useSelection } from './use-selection/use-selection.js';
+export { useFloatingWindow } from './use-floating-window/use-floating-window.js';
+export { useCollapse } from './use-collapse/use-collapse.js';
+export { useHorizontalCollapse } from './use-collapse/use-horizontal-collapse.js';
 export type { UseMediaQueryOptions } from './use-media-query/use-media-query';
-export type { UseClipboardOptions, UseClipboardReturnValue } from './use-clipboard/use-clipboard';
+export type { UseClipboardInput as UseClipboardOptions, UseClipboardReturnValue, } from './use-clipboard/use-clipboard';
 export type { UseColorSchemeValue } from './use-color-scheme/use-color-scheme';
-export type { UseCounterOptions, UseCounterHandlers, UseCounterReturnValue, } from './use-counter/use-counter';
-export type { UseDebouncedCallbackOptions, UseDebouncedCallbackReturnValue, } from './use-debounced-callback/use-debounced-callback';
-export type { UseDebouncedStateOptions, UseDebouncedStateReturnValue, } from './use-debounced-state/use-debounced-state';
+export type { UseCounterOptions as UseCounterOptions, UseCounterHandlers, UseCounterReturnValue, } from './use-counter/use-counter';
+export type { UseDebouncedCallbackOptions as UseDebouncedCallbackOptions, UseDebouncedCallbackReturnValue, } from './use-debounced-callback/use-debounced-callback';
+export type { UseDebouncedStateOptions as UseDebouncedStateOptions, UseDebouncedStateReturnValue, } from './use-debounced-state/use-debounced-state';
 export type { UseDebouncedValueOptions, UseDebouncedValueReturnValue, } from './use-debounced-value/use-debounced-value';
 export type { UseDisclosureOptions, UseDisclosureHandlers, UseDisclosureReturnValue, } from './use-disclosure/use-disclosure';
 export type { EyeDropperOpenOptions, EyeDropperOpenReturnType, UseEyeDropperReturnValue, } from './use-eye-dropper/use-eye-dropper';
 export type { UseFetchOptions, UseFetchReturnValue } from './use-fetch/use-fetch';
 export type { UseFileDialogOptions, UseFileDialogReturnValue, } from './use-file-dialog/use-file-dialog';
-export type { UseFocusReturnOptions, UseFocusReturnReturnValue, } from './use-focus-return/use-focus-return';
+export type { UseFocusReturnInput as UseFocusReturnOptions, UseFocusReturnReturnValue, } from './use-focus-return/use-focus-return';
 export type { UseFocusWithinOptions, UseFocusWithinReturnValue, } from './use-focus-within/use-focus-within';
-export type { UseFullscreenReturnValue } from './use-fullscreen/use-fullscreen';
-export type { UseHashOptions, UseHashReturnValue } from './use-hash/use-hash';
-export type { UseHeadroomOptions } from './use-headroom/use-headroom';
+export type { UseFullscreenElementReturnValue } from './use-fullscreen/use-fullscreen';
+export type { UseHashInput as UseHashOptions, UseHashReturnValue } from './use-hash/use-hash';
+export type { UseHeadroomInput as UseHeadroomOptions } from './use-headroom/use-headroom';
 export type { HotkeyItemOptions, HotkeyItem } from './use-hotkeys/use-hotkeys';
 export type { UseHoverReturnValue } from './use-hover/use-hover';
 export type { UseIdleOptions } from './use-idle/use-idle';
@@ -100,12 +104,13 @@ export type { UseStorageOptions, UseStorageReturnValue } from './use-local-stora
 export type { UseMovePosition, UseMoveHandlers, UseMoveReturnValue } from './use-move/use-move';
 export type { UserNetworkReturnValue } from './use-network/use-network';
 export type { UseOrientationOptions, UseOrientationReturnType, } from './use-orientation/use-orientation';
-export type { UseOSReturnValue as OS, UseOSReturnValue, UseOsOptions } from './use-os/use-os';
+export type { UseOSReturnValue, UseOsOptions } from './use-os/use-os';
 export type { UsePaginationOptions, UsePaginationReturnValue, } from './use-pagination/use-pagination';
 export type { UseQueueOptions, UseQueueReturnValue } from './use-queue/use-queue';
 export type { UseRadialMoveOptions, UseRadialMoveReturnValue, } from './use-radial-move/use-radial-move';
 export type { UseScrollIntoViewOptions, UseScrollIntoViewReturnValue, } from './use-scroll-into-view/use-scroll-into-view';
-export type { UseScrollSpyOptions, UseScrollSpyHeadingData, UseScrollSpyReturnType, } from './use-scroll-spy/use-scroll-spy';
+export type { UseScrollSpyOptions, UseScrollSpyHeadingData, UseScrollSpyReturnValue, } from './use-scroll-spy/use-scroll-spy';
+export type { UseScrollerOptions, UseScrollerReturnValue, UseScrollerScrollState, } from './use-scroller/use-scroller';
 export type { UseSetStateCallback, UseSetStateReturnValue } from './use-set-state/use-set-state';
 export type { UseStateHistoryHandlers, UseStateHistoryValue as StateHistory, UseStateHistoryValue, UseStateHistoryReturnValue, } from './use-state-history/use-state-history';
 export type { UseTimeoutOptions, UseTimeoutReturnValue } from './use-timeout/use-timeout';
@@ -114,4 +119,8 @@ export type { UseUncontrolledOptions, UseUncontrolledReturnValue, } from './use-
 export type { UseValidatedStateValue, UseValidatedStateReturnValue, } from './use-validated-state/use-validated-state';
 export type { UseWindowScrollPosition, UseWindowScrollTo, UseWindowScrollReturnValue, } from './use-window-scroll/use-window-scroll';
 export type { UseLongPressOptions, UseLongPressReturnValue } from './use-long-press/use-long-press';
+export type { SetFloatingWindowPosition, UseFloatingWindowOptions, UseFloatingWindowReturnValue, } from './use-floating-window/use-floating-window';
 export type { UseSelectionHandlers, UseSelectionInput, UseSelectionReturnValue, } from './use-selection/use-selection';
+export type { UseElementSizeReturnValue, UseResizeObserverReturnValue, ObserverRect, } from './use-resize-observer/use-resize-observer';
+export type { UseCollapseInput, UseCollapseReturnValue, UseCollapseState, } from './use-collapse/use-collapse';
+export type { UseHorizontalCollapseInput, UseHorizontalCollapseReturnValue, UseHorizontalCollapseState, } from './use-collapse/use-horizontal-collapse';

package/lib/use-clipboard/use-clipboard.d.ts

@@ -1,4 +1,4 @@
-export interface UseClipboardOptions {
+export interface UseClipboardInput {
     /** Time in ms after which the copied state will reset, `2000` by default */
     timeout?: number;
 }
@@ -12,4 +12,8 @@ export interface UseClipboardReturnValue {
     /** Boolean indicating if the value was copied successfully */
     copied: boolean;
 }
-export declare function useClipboard(options?: UseClipboardOptions): UseClipboardReturnValue;
+export declare function useClipboard(options?: UseClipboardInput): UseClipboardReturnValue;
+export declare namespace useClipboard {
+    type Input = UseClipboardInput;
+    type ReturnValue = UseClipboardReturnValue;
+}

package/lib/use-collapse/use-collapse.d.ts

@@ -0,0 +1,41 @@
+import React, { CSSProperties } from 'react';
+export declare function getElementHeight(elementRef: React.RefObject<HTMLElement | null>): number | "auto";
+export interface UseCollapseInput {
+    /** Expanded state  */
+    expanded: boolean;
+    /** Transition duration in milliseconds, by default calculated based on content height */
+    transitionDuration?: number;
+    /** Transition timing function, `ease` by default */
+    transitionTimingFunction?: string;
+    /** Called when transition ends */
+    onTransitionEnd?: () => void;
+    /** Called when transition starts */
+    onTransitionStart?: () => void;
+    /** If true, collapsed content is kept in the DOM and hidden with `display: none` styles */
+    keepMounted?: boolean;
+}
+interface GetCollapsePropsInput {
+    style?: CSSProperties;
+    ref?: React.Ref<HTMLDivElement>;
+}
+interface GetCollapsePropsReturnValue {
+    'aria-hidden': boolean;
+    inert: boolean;
+    ref: React.RefCallback<HTMLDivElement>;
+    onTransitionEnd: (event: React.TransitionEvent<Element>) => void;
+    style: React.CSSProperties;
+}
+export type UseCollapseState = 'entering' | 'entered' | 'exiting' | 'exited';
+export interface UseCollapseReturnValue {
+    /** Current transition state */
+    state: UseCollapseState;
+    /** Props to pass down to the collapsible element */
+    getCollapseProps: (input?: GetCollapsePropsInput) => GetCollapsePropsReturnValue;
+}
+export declare function useCollapse({ transitionDuration, transitionTimingFunction, onTransitionEnd, onTransitionStart, expanded, keepMounted, }: UseCollapseInput): UseCollapseReturnValue;
+export declare namespace useCollapse {
+    type Input = UseCollapseInput;
+    type ReturnValue = UseCollapseReturnValue;
+    type State = UseCollapseState;
+}
+export {};

package/lib/use-collapse/use-horizontal-collapse.d.ts

@@ -0,0 +1,36 @@
+import React, { CSSProperties } from 'react';
+export declare function getElementWidth(elementRef: React.RefObject<HTMLElement | null>): number | "auto";
+export interface UseHorizontalCollapseInput {
+    /** Expanded state  */
+    expanded: boolean;
+    /** Transition duration in milliseconds, by default calculated based on content width */
+    transitionDuration?: number;
+    /** Transition timing function, `ease` by default */
+    transitionTimingFunction?: string;
+    /** Called when transition ends */
+    onTransitionEnd?: () => void;
+    /** Called when transition starts */
+    onTransitionStart?: () => void;
+    /** If true, collapsed content is kept in the DOM and hidden with `display: none` styles */
+    keepMounted?: boolean;
+}
+interface GetHorizontalCollapsePropsInput {
+    style?: CSSProperties;
+    ref?: React.Ref<HTMLDivElement>;
+}
+interface GetHorizontalCollapsePropsReturnValue {
+    'aria-hidden': boolean;
+    inert: boolean;
+    ref: React.RefCallback<HTMLDivElement>;
+    onTransitionEnd: (event: React.TransitionEvent<Element>) => void;
+    style: React.CSSProperties;
+}
+export type UseHorizontalCollapseState = 'entering' | 'entered' | 'exiting' | 'exited';
+export interface UseHorizontalCollapseReturnValue {
+    /** Current transition state */
+    state: UseHorizontalCollapseState;
+    /** Props to pass down to the collapsible element */
+    getCollapseProps: (input?: GetHorizontalCollapsePropsInput) => GetHorizontalCollapsePropsReturnValue;
+}
+export declare function useHorizontalCollapse({ transitionDuration, transitionTimingFunction, onTransitionEnd, onTransitionStart, expanded, keepMounted, }: UseHorizontalCollapseInput): UseHorizontalCollapseReturnValue;
+export {};

package/lib/use-counter/use-counter.d.ts

@@ -9,4 +9,9 @@ export interface UseCounterHandlers {
     reset: () => void;
 }
 export type UseCounterReturnValue = [number, UseCounterHandlers];
-export declare function useCounter(initialValue?: number, options?: UseCounterOptions): [number, UseCounterHandlers];
+export declare function useCounter(initialValue?: number, options?: UseCounterOptions): UseCounterReturnValue;
+export declare namespace useCounter {
+    type Options = UseCounterOptions;
+    type Handlers = UseCounterHandlers;
+    type ReturnValue = UseCounterReturnValue;
+}

package/lib/use-debounced-callback/use-debounced-callback.d.ts

@@ -12,3 +12,7 @@ export declare function useDebouncedCallback<T extends (...args: any[]) => any>(
     cancel: () => void;
     _isFirstCall: boolean;
 };
+export declare namespace useDebouncedCallback {
+    type Options = UseDebouncedCallbackOptions;
+    type ReturnValue<T extends (...args: any[]) => any> = UseDebouncedCallbackReturnValue<T>;
+}

package/lib/use-debounced-state/use-debounced-state.d.ts

@@ -4,3 +4,7 @@ export interface UseDebouncedStateOptions {
 }
 export type UseDebouncedStateReturnValue<T> = [T, (newValue: SetStateAction<T>) => void];
 export declare function useDebouncedState<T = any>(defaultValue: T, wait: number, options?: UseDebouncedStateOptions): UseDebouncedStateReturnValue<T>;
+export declare namespace useDebouncedState {
+    type Options = UseDebouncedStateOptions;
+    type ReturnValue<T> = UseDebouncedStateReturnValue<T>;
+}

package/lib/use-debounced-value/use-debounced-value.d.ts

@@ -3,3 +3,7 @@ export interface UseDebouncedValueOptions {
 }
 export type UseDebouncedValueReturnValue<T> = [T, () => void];
 export declare function useDebouncedValue<T = any>(value: T, wait: number, options?: UseDebouncedValueOptions): UseDebouncedValueReturnValue<T>;
+export declare namespace useDebouncedValue {
+    type Options = UseDebouncedValueOptions;
+    type ReturnValue<T> = UseDebouncedValueReturnValue<T>;
+}

package/lib/use-disclosure/use-disclosure.d.ts

@@ -3,9 +3,15 @@ export interface UseDisclosureOptions {
     onClose?: () => void;
 }
 export interface UseDisclosureHandlers {
+    set: (value: boolean) => void;
     open: () => void;
     close: () => void;
     toggle: () => void;
 }
 export type UseDisclosureReturnValue = [boolean, UseDisclosureHandlers];
 export declare function useDisclosure(initialState?: boolean, options?: UseDisclosureOptions): UseDisclosureReturnValue;
+export declare namespace useDisclosure {
+    type Options = UseDisclosureOptions;
+    type Handlers = UseDisclosureHandlers;
+    type ReturnValue = UseDisclosureReturnValue;
+}

package/lib/use-fetch/use-fetch.d.ts

@@ -9,3 +9,7 @@ export interface UseFetchReturnValue<T> {
     abort: () => void;
 }
 export declare function useFetch<T>(url: string, { autoInvoke, ...options }?: UseFetchOptions): UseFetchReturnValue<T>;
+export declare namespace useFetch {
+    type Options = UseFetchOptions;
+    type ReturnValue<T> = UseFetchReturnValue<T>;
+}

package/lib/use-file-dialog/use-file-dialog.d.ts

@@ -22,3 +22,7 @@ export interface UseFileDialogReturnValue {
     reset: () => void;
 }
 export declare function useFileDialog(input?: UseFileDialogOptions): UseFileDialogReturnValue;
+export declare namespace useFileDialog {
+    type Options = UseFileDialogOptions;
+    type ReturnValue = UseFileDialogReturnValue;
+}

package/lib/use-floating-window/use-floating-window.d.ts

@@ -0,0 +1,52 @@
+import { RefCallback } from 'react';
+interface FloatingWindowPositionConfig {
+    top?: number;
+    left?: number;
+    right?: number;
+    bottom?: number;
+}
+interface FloatingWindowPosition {
+    /** Element offset from the left side of the viewport */
+    x: number;
+    /** Element offset from the top side of the viewport */
+    y: number;
+}
+export interface UseFloatingWindowOptions {
+    /** If `false`, the element can not be dragged. */
+    enabled?: boolean;
+    /** If `true`, the element can only move within the current viewport boundaries. */
+    constrainToViewport?: boolean;
+    /** The offset from the viewport edges when constraining the element. Requires `constrainToViewport: true`. */
+    constrainOffset?: number;
+    /** Selector of an element that should be used to drag floating window. If not specified, the entire root element is used as a drag target. */
+    dragHandleSelector?: string;
+    /** Selector of an element within `dragHandleSelector` that should be excluded from the drag event. */
+    excludeDragHandleSelector?: string;
+    /** If set, restricts movement to the specified axis */
+    axis?: 'x' | 'y';
+    /** Initial position. If not set, calculated from element styles. */
+    initialPosition?: FloatingWindowPositionConfig;
+    /** Called when the element position changes */
+    onPositionChange?: (pos: FloatingWindowPosition) => void;
+    /** Called when the drag starts */
+    onDragStart?: () => void;
+    /** Called when the drag stops */
+    onDragEnd?: () => void;
+}
+export type SetFloatingWindowPosition = (position: FloatingWindowPositionConfig) => void;
+export interface UseFloatingWindowReturnValue<T extends HTMLElement> {
+    /** Ref to the element that should be draggable */
+    ref: RefCallback<T | null>;
+    /** Function to set the position of the element */
+    setPosition: SetFloatingWindowPosition;
+    /** `true` if the element is currently being dragged */
+    isDragging: boolean;
+}
+export declare function useFloatingWindow<T extends HTMLElement>(options?: UseFloatingWindowOptions): UseFloatingWindowReturnValue<T>;
+export declare namespace useFloatingWindow {
+    type Options = UseFloatingWindowOptions;
+    type Position = FloatingWindowPosition;
+    type SetPosition = SetFloatingWindowPosition;
+    type ReturnValue<T extends HTMLElement> = UseFloatingWindowReturnValue<T>;
+}
+export {};

package/lib/use-focus-return/use-focus-return.d.ts

@@ -1,6 +1,10 @@
-export interface UseFocusReturnOptions {
+export interface UseFocusReturnInput {
     opened: boolean;
     shouldReturnFocus?: boolean;
 }
 export type UseFocusReturnReturnValue = () => void;
-export declare function useFocusReturn({ opened, shouldReturnFocus, }: UseFocusReturnOptions): UseFocusReturnReturnValue;
+export declare function useFocusReturn({ opened, shouldReturnFocus, }: UseFocusReturnInput): UseFocusReturnReturnValue;
+export declare namespace useFocusReturn {
+    type Input = UseFocusReturnInput;
+    type ReturnValue = UseFocusReturnReturnValue;
+}

package/lib/use-focus-within/use-focus-within.d.ts

@@ -7,3 +7,7 @@ export interface UseFocusWithinReturnValue<T extends HTMLElement = any> {
     focused: boolean;
 }
 export declare function useFocusWithin<T extends HTMLElement = any>({ onBlur, onFocus, }?: UseFocusWithinOptions): UseFocusWithinReturnValue<T>;
+export declare namespace useFocusWithin {
+    type Options = UseFocusWithinOptions;
+    type ReturnValue<T extends HTMLElement> = UseFocusWithinReturnValue<T>;
+}

package/lib/use-fullscreen/use-fullscreen.d.ts

@@ -1,6 +1,11 @@
-export interface UseFullscreenReturnValue<T extends HTMLElement = any> {
+export interface UseFullscreenElementReturnValue<T extends HTMLElement = any> {
     ref: React.RefCallback<T | null>;
     toggle: () => Promise<void>;
     fullscreen: boolean;
 }
-export declare function useFullscreen<T extends HTMLElement = any>(): UseFullscreenReturnValue<T>;
+export declare function useFullscreenElement<T extends HTMLElement = any>(): UseFullscreenElementReturnValue<T>;
+export interface UseFullscreenDocumentReturnValue {
+    toggle: () => Promise<void>;
+    fullscreen: boolean;
+}
+export declare function useFullscreenDocument(): UseFullscreenDocumentReturnValue;

package/lib/use-hash/use-hash.d.ts

@@ -1,5 +1,9 @@
-export interface UseHashOptions {
+export interface UseHashInput {
     getInitialValueInEffect?: boolean;
 }
 export type UseHashReturnValue = [string, (value: string) => void];
-export declare function useHash({ getInitialValueInEffect, }?: UseHashOptions): UseHashReturnValue;
+export declare function useHash({ getInitialValueInEffect }?: UseHashInput): UseHashReturnValue;
+export declare namespace useHash {
+    type Options = UseHashInput;
+    type ReturnValue = UseHashReturnValue;
+}

package/lib/use-headroom/use-headroom.d.ts

@@ -3,7 +3,7 @@ export declare const isPinned: (current: number, previous: number) => boolean;
 export declare const isReleased: (current: number, previous: number, fixedAt: number) => boolean;
 export declare const isPinnedOrReleased: (current: number, fixedAt: number, isCurrentlyPinnedRef: React.RefObject<boolean>, isScrollingUp: boolean, onPin?: () => void, onRelease?: () => void) => void;
 export declare const useScrollDirection: () => boolean;
-export interface UseHeadroomOptions {
+export interface UseHeadroomInput {
     /** Number in px at which element should be fixed */
     fixedAt?: number;
     /** Called when element is pinned */
@@ -13,4 +13,7 @@ export interface UseHeadroomOptions {
     /** Called when element is unpinned */
     onRelease?: () => void;
 }
-export declare function useHeadroom({ fixedAt, onPin, onFix, onRelease }?: UseHeadroomOptions): boolean;
+export declare function useHeadroom({ fixedAt, onPin, onFix, onRelease }?: UseHeadroomInput): boolean;
+export declare namespace useHeadroom {
+    type Input = UseHeadroomInput;
+}

package/lib/use-hotkeys/use-hotkeys.d.ts

@@ -3,3 +3,6 @@ export type { HotkeyItemOptions };
 export { getHotkeyHandler };
 export type HotkeyItem = [string, (event: KeyboardEvent) => void, HotkeyItemOptions?];
 export declare function useHotkeys(hotkeys: HotkeyItem[], tagsToIgnore?: string[], triggerOnContentEditable?: boolean): void;
+export declare namespace useHotkeys {
+    type Hotkey = HotkeyItem;
+}

package/lib/use-hover/use-hover.d.ts

@@ -3,3 +3,6 @@ export interface UseHoverReturnValue<T extends HTMLElement = any> {
     ref: React.RefCallback<T | null>;
 }
 export declare function useHover<T extends HTMLElement = any>(): UseHoverReturnValue<T>;
+export declare namespace useHover {
+    type ReturnValue<T extends HTMLElement> = UseHoverReturnValue<T>;
+}

package/lib/use-idle/use-idle.d.ts

@@ -3,3 +3,6 @@ export interface UseIdleOptions {
     initialState?: boolean;
 }
 export declare function useIdle(timeout: number, options?: UseIdleOptions): boolean;
+export declare namespace useIdle {
+    type Options = UseIdleOptions;
+}

package/lib/use-in-viewport/use-in-viewport.d.ts

@@ -3,3 +3,6 @@ export interface UseInViewportReturnValue<T extends HTMLElement = any> {
     ref: React.RefCallback<T | null>;
 }
 export declare function useInViewport<T extends HTMLElement = any>(): UseInViewportReturnValue<T>;
+export declare namespace useInViewport {
+    type ReturnValue<T extends HTMLElement> = UseInViewportReturnValue<T>;
+}

package/lib/use-input-state/use-input-state.d.ts

@@ -4,3 +4,6 @@ export type UseInputStateReturnValue<T> = [
     (value: null | undefined | T | React.ChangeEvent<any>) => void
 ];
 export declare function useInputState<T>(initialState: T): UseInputStateReturnValue<T>;
+export declare namespace useInputState {
+    type ReturnValue<T> = UseInputStateReturnValue<T>;
+}

package/lib/use-intersection/use-intersection.d.ts

@@ -3,3 +3,6 @@ export interface UseIntersectionReturnValue<T> {
     entry: IntersectionObserverEntry | null;
 }
 export declare function useIntersection<T extends HTMLElement = any>(options?: IntersectionObserverInit): UseIntersectionReturnValue<T>;
+export declare namespace useIntersection {
+    type ReturnValue<T> = UseIntersectionReturnValue<T>;
+}

package/lib/use-interval/use-interval.d.ts

@@ -13,3 +13,7 @@ export interface UseIntervalReturnValue {
     active: boolean;
 }
 export declare function useInterval(fn: () => void, interval: number, { autoInvoke }?: UseIntervalOptions): UseIntervalReturnValue;
+export declare namespace useInterval {
+    type Options = UseIntervalOptions;
+    type ReturnValue = UseIntervalReturnValue;
+}

package/lib/use-list-state/use-list-state.d.ts

@@ -22,3 +22,7 @@ export interface UseListStateHandlers<T> {
 }
 export type UseListStateReturnValue<T> = [T[], UseListStateHandlers<T>];
 export declare function useListState<T>(initialValue?: T[] | (() => T[])): UseListStateReturnValue<T>;
+export declare namespace useListState {
+    type ReturnValue<T> = UseListStateReturnValue<T>;
+    type Handlers<T> = UseListStateHandlers<T>;
+}

package/lib/use-long-press/use-long-press.d.ts

@@ -17,3 +17,7 @@ export interface UseLongPressReturnValue {
     onTouchEnd: (event: React.TouchEvent) => void;
 }
 export declare function useLongPress(onLongPress: (event: React.MouseEvent | React.TouchEvent) => void, options?: UseLongPressOptions): UseLongPressReturnValue;
+export declare namespace useLongPress {
+    type Options = UseLongPressOptions;
+    type ReturnValue = UseLongPressReturnValue;
+}

package/lib/use-media-query/use-media-query.d.ts

@@ -2,3 +2,6 @@ export interface UseMediaQueryOptions {
     getInitialValueInEffect: boolean;
 }
 export declare function useMediaQuery(query: string, initialValue?: boolean, { getInitialValueInEffect }?: UseMediaQueryOptions): boolean;
+export declare namespace useMediaQuery {
+    type Options = UseMediaQueryOptions;
+}

package/lib/use-mouse/use-mouse.d.ts

@@ -1,7 +1,19 @@
+export interface UseMouseReturnValue<T extends HTMLElement = any> {
+    ref: React.RefCallback<T | null>;
+    x: number;
+    y: number;
+}
 export declare function useMouse<T extends HTMLElement = any>(options?: {
     resetOnExit?: boolean;
-}): {
+}): UseMouseReturnValue<T>;
+export interface UseMousePositionReturnValue {
     x: number;
     y: number;
-    ref: import("react").RefObject<T | null>;
-};
+}
+export declare function useMousePosition(): UseMousePositionReturnValue;
+export declare namespace useMouse {
+    type ReturnValue<T extends HTMLElement> = UseMouseReturnValue<T>;
+}
+export declare namespace useMousePosition {
+    type ReturnValue = UseMousePositionReturnValue;
+}

package/lib/use-move/use-move.d.ts

@@ -15,3 +15,7 @@ export interface UseMoveReturnValue<T extends HTMLElement = any> {
     active: boolean;
 }
 export declare function useMove<T extends HTMLElement = any>(onChange: (value: UseMovePosition) => void, handlers?: UseMoveHandlers, dir?: 'ltr' | 'rtl'): UseMoveReturnValue<T>;
+export declare namespace useMove {
+    type Handlers = UseMoveHandlers;
+    type ReturnValue<T extends HTMLElement> = UseMoveReturnValue<T>;
+}

package/lib/use-mutation-observer/use-mutation-observer.d.ts

@@ -1 +1,2 @@
-export declare function useMutationObserver<T extends HTMLElement = any>(callback: MutationCallback, options: MutationObserverInit, target?: HTMLElement | (() => HTMLElement) | null): import("react").RefObject<T | null>;
+export declare function useMutationObserver<T extends HTMLElement = any>(callback: MutationCallback, options: MutationObserverInit): React.RefCallback<T | null>;
+export declare function useMutationObserverTarget(callback: MutationCallback, options: MutationObserverInit, target?: HTMLElement | (() => HTMLElement) | null): void;

package/lib/use-network/use-network.d.ts

@@ -8,3 +8,6 @@ export interface UserNetworkReturnValue {
     type?: 'bluetooth' | 'cellular' | 'ethernet' | 'wifi' | 'wimax' | 'none' | 'other' | 'unknown';
 }
 export declare function useNetwork(): UserNetworkReturnValue;
+export declare namespace useNetwork {
+    type ReturnValue = UserNetworkReturnValue;
+}

package/lib/use-orientation/use-orientation.d.ts

@@ -20,3 +20,7 @@ export interface UseOrientationReturnType {
     type: OrientationType;
 }
 export declare function useOrientation({ defaultAngle, defaultType, getInitialValueInEffect, }?: UseOrientationOptions): UseOrientationReturnType;
+export declare namespace useOrientation {
+    type Options = UseOrientationOptions;
+    type ReturnType = UseOrientationReturnType;
+}

package/lib/use-os/use-os.d.ts

@@ -3,3 +3,7 @@ export interface UseOsOptions {
     getValueInEffect: boolean;
 }
 export declare function useOs(options?: UseOsOptions): UseOSReturnValue;
+export declare namespace useOs {
+    type Options = UseOsOptions;
+    type ReturnValue = UseOSReturnValue;
+}

package/lib/use-pagination/use-pagination.d.ts

@@ -1,6 +1,6 @@
 export declare const DOTS = "dots";
 export interface UsePaginationOptions {
-    /** Page selected on initial render, defaults to 1 */
+    /** Page selected on initial render, defaults to 1 or startValue if provided */
     initialPage?: number;
     /** Controlled active page number */
     page?: number;
@@ -12,6 +12,8 @@ export interface UsePaginationOptions {
     boundaries?: number;
     /** Callback fired after change of each page */
     onChange?: (page: number) => void;
+    /** Starting page number, defaults to 1 */
+    startValue?: number;
 }
 export interface UsePaginationReturnValue {
     /** Array of page numbers and dots */
@@ -29,4 +31,8 @@ export interface UsePaginationReturnValue {
     /** Function to go to last page */
     last: () => void;
 }
-export declare function usePagination({ total, siblings, boundaries, page, initialPage, onChange, }: UsePaginationOptions): UsePaginationReturnValue;
+export declare function usePagination({ total, siblings, boundaries, page, initialPage, onChange, startValue, }: UsePaginationOptions): UsePaginationReturnValue;
+export declare namespace usePagination {
+    type Options = UsePaginationOptions;
+    type ReturnValue = UsePaginationReturnValue;
+}

package/lib/use-queue/use-queue.d.ts

@@ -17,3 +17,7 @@ export interface UseQueueReturnValue<T> {
     cleanQueue: () => void;
 }
 export declare function useQueue<T>({ initialValues, limit, }: UseQueueOptions<T>): UseQueueReturnValue<T>;
+export declare namespace useQueue {
+    type Options<T> = UseQueueOptions<T>;
+    type ReturnValue<T> = UseQueueReturnValue<T>;
+}

package/lib/use-radial-move/use-radial-move.d.ts

@@ -16,3 +16,7 @@ export interface UseRadialMoveReturnValue<T extends HTMLElement = any> {
     active: boolean;
 }
 export declare function useRadialMove<T extends HTMLElement = any>(onChange: (value: number) => void, { step, onChangeEnd, onScrubStart, onScrubEnd }?: UseRadialMoveOptions): UseRadialMoveReturnValue<T>;
+export declare namespace useRadialMove {
+    type Options = UseRadialMoveOptions;
+    type ReturnValue<T extends HTMLElement> = UseRadialMoveReturnValue<T>;
+}

package/lib/use-resize-observer/use-resize-observer.d.ts

@@ -1,8 +1,22 @@
-type ObserverRect = Omit<DOMRectReadOnly, 'toJSON'>;
-export declare function useResizeObserver<T extends HTMLElement = any>(options?: ResizeObserverOptions): readonly [import("react").RefObject<T | null>, ObserverRect];
+export type ObserverRect = Omit<DOMRectReadOnly, 'toJSON'>;
+export type UseResizeObserverReturnValue<T extends HTMLElement = any> = [
+    React.RefCallback<T | null>,
+    ObserverRect
+];
+export declare function useResizeObserver<T extends HTMLElement = any>(options?: ResizeObserverOptions): UseResizeObserverReturnValue<T>;
+export interface UseElementSizeReturnValue<T extends HTMLElement = any> {
+    ref: React.RefCallback<T | null>;
+    width: number;
+    height: number;
+}
 export declare function useElementSize<T extends HTMLElement = any>(options?: ResizeObserverOptions): {
-    ref: import("react").RefObject<T | null>;
+    ref: React.RefCallback<T | null>;
     width: number;
     height: number;
 };
-export {};
+export declare namespace useResizeObserver {
+    type ReturnValue<T extends HTMLElement> = UseResizeObserverReturnValue<T>;
+}
+export declare namespace useElementSize {
+    type ReturnValue<T extends HTMLElement> = UseElementSizeReturnValue<T>;
+}

package/lib/use-scroll-into-view/use-scroll-into-view.d.ts

@@ -25,4 +25,8 @@ export interface UseScrollIntoViewReturnValue<Target extends HTMLElement = any,
     cancel: () => void;
 }
 export declare function useScrollIntoView<Target extends HTMLElement = any, Parent extends HTMLElement | null = null>({ duration, axis, onScrollFinish, easing, offset, cancelable, isList, }?: UseScrollIntoViewOptions): UseScrollIntoViewReturnValue<Target, Parent>;
+export declare namespace useScrollIntoView {
+    type Options = UseScrollIntoViewOptions;
+    type ReturnValue<Target extends HTMLElement, Parent extends HTMLElement | null> = UseScrollIntoViewReturnValue<Target, Parent>;
+}
 export {};