@octanejs/mantine-hooks 0.1.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +21 -0
- package/README.md +29 -0
- package/package.json +45 -0
- package/src/index.ts +259 -0
- package/src/internal.ts +6 -0
- package/src/use-click-outside/use-click-outside.ts +57 -0
- package/src/use-clipboard/use-clipboard.ts +69 -0
- package/src/use-collapse/use-collapse.ts +162 -0
- package/src/use-collapse/use-horizontal-collapse.ts +164 -0
- package/src/use-color-scheme/use-color-scheme.ts +13 -0
- package/src/use-counter/use-counter.ts +59 -0
- package/src/use-debounced-callback/use-debounced-callback.ts +159 -0
- package/src/use-debounced-state/use-debounced-state.ts +44 -0
- package/src/use-debounced-value/use-debounced-value.ts +71 -0
- package/src/use-did-update/use-did-update.ts +26 -0
- package/src/use-disclosure/use-disclosure.ts +57 -0
- package/src/use-document-title/use-document-title.ts +9 -0
- package/src/use-document-visibility/use-document-visibility.ts +14 -0
- package/src/use-drag/use-drag.ts +463 -0
- package/src/use-event-listener/use-event-listener.ts +47 -0
- package/src/use-eye-dropper/use-eye-dropper.ts +41 -0
- package/src/use-favicon/use-favicon.ts +41 -0
- package/src/use-fetch/use-fetch.ts +85 -0
- package/src/use-file-dialog/use-file-dialog.ts +140 -0
- package/src/use-floating-window/use-floating-window.ts +431 -0
- package/src/use-focus-return/use-focus-return.ts +65 -0
- package/src/use-focus-trap/scope-tab.ts +36 -0
- package/src/use-focus-trap/tabbable.ts +65 -0
- package/src/use-focus-trap/use-focus-trap.ts +84 -0
- package/src/use-focus-within/use-focus-within.ts +90 -0
- package/src/use-force-update/use-force-update.ts +8 -0
- package/src/use-fullscreen/use-fullscreen.ts +153 -0
- package/src/use-hash/use-hash.ts +42 -0
- package/src/use-headroom/use-headroom.ts +160 -0
- package/src/use-hotkeys/parse-hotkey.ts +130 -0
- package/src/use-hotkeys/use-hotkeys.ts +63 -0
- package/src/use-hover/use-hover.ts +57 -0
- package/src/use-id/use-id.ts +23 -0
- package/src/use-idle/use-idle.ts +54 -0
- package/src/use-in-viewport/use-in-viewport.ts +34 -0
- package/src/use-input-state/use-input-state.ts +41 -0
- package/src/use-intersection/use-intersection.ts +41 -0
- package/src/use-interval/use-interval.ts +84 -0
- package/src/use-is-first-render/use-is-first-render.ts +12 -0
- package/src/use-isomorphic-effect/use-isomorphic-effect.ts +5 -0
- package/src/use-list-state/use-list-state.ts +157 -0
- package/src/use-local-storage/create-storage.ts +200 -0
- package/src/use-local-storage/use-local-storage.ts +19 -0
- package/src/use-logger/use-logger.ts +16 -0
- package/src/use-long-press/use-long-press.ts +188 -0
- package/src/use-map/use-map.ts +28 -0
- package/src/use-mask/use-mask.ts +1049 -0
- package/src/use-media-query/use-media-query.ts +57 -0
- package/src/use-merged-ref/use-merged-ref.ts +53 -0
- package/src/use-mounted/use-mounted.ts +7 -0
- package/src/use-mouse/use-mouse.ts +91 -0
- package/src/use-move/use-move.ts +165 -0
- package/src/use-mutation-observer/use-mutation-observer.ts +61 -0
- package/src/use-network/use-network.ts +70 -0
- package/src/use-orientation/use-orientation.ts +87 -0
- package/src/use-os/use-os.ts +93 -0
- package/src/use-page-leave/use-page-leave.ts +10 -0
- package/src/use-pagination/use-pagination.ts +149 -0
- package/src/use-previous/use-previous.ts +11 -0
- package/src/use-queue/use-queue.ts +71 -0
- package/src/use-radial-move/use-radial-move.ts +161 -0
- package/src/use-reduced-motion/use-reduced-motion.ts +6 -0
- package/src/use-resize-observer/use-resize-observer.ts +95 -0
- package/src/use-roving-index/use-roving-index.ts +386 -0
- package/src/use-scroll-direction/use-scroll-direction.ts +41 -0
- package/src/use-scroll-into-view/use-scroll-into-view.ts +294 -0
- package/src/use-scroll-spy/use-scroll-spy.ts +155 -0
- package/src/use-scroller/use-scroller.ts +225 -0
- package/src/use-selection/use-selection.ts +120 -0
- package/src/use-session-storage/use-session-storage.ts +19 -0
- package/src/use-set/use-set.ts +88 -0
- package/src/use-set-state/use-set-state.ts +29 -0
- package/src/use-shallow-effect/use-shallow-effect.ts +40 -0
- package/src/use-splitter/use-splitter.ts +1242 -0
- package/src/use-state-history/use-state-history.ts +70 -0
- package/src/use-text-selection/use-text-selection.ts +20 -0
- package/src/use-throttled-callback/use-throttled-callback.ts +60 -0
- package/src/use-throttled-state/use-throttled-state.ts +12 -0
- package/src/use-throttled-value/use-throttled-value.ts +23 -0
- package/src/use-timeout/use-timeout.ts +56 -0
- package/src/use-toggle/use-toggle.ts +23 -0
- package/src/use-uncontrolled/use-uncontrolled.ts +53 -0
- package/src/use-validated-state/use-validated-state.ts +50 -0
- package/src/use-viewport-size/use-viewport-size.ts +23 -0
- package/src/use-window-event/use-window-event.ts +16 -0
- package/src/use-window-scroll/use-window-scroll.ts +49 -0
- package/src/utils/clamp/clamp.ts +15 -0
- package/src/utils/index.ts +7 -0
- package/src/utils/lower-first/lower-first.ts +3 -0
- package/src/utils/random-id/random-id.ts +3 -0
- package/src/utils/range/range.ts +10 -0
- package/src/utils/shallow-equal/shallow-equal.ts +34 -0
- package/src/utils/upper-first/upper-first.ts +3 -0
- package/src/utils/use-callback-ref/use-callback-ref.ts +11 -0
|
@@ -0,0 +1,65 @@
|
|
|
1
|
+
const TABBABLE_NODES = /input|select|textarea|button|object/;
|
|
2
|
+
export const FOCUS_SELECTOR = 'a, input, select, textarea, button, object, [tabindex]';
|
|
3
|
+
|
|
4
|
+
function hidden(element: HTMLElement) {
|
|
5
|
+
if (process.env.NODE_ENV === 'test') {
|
|
6
|
+
return false;
|
|
7
|
+
}
|
|
8
|
+
|
|
9
|
+
return element.style.display === 'none';
|
|
10
|
+
}
|
|
11
|
+
|
|
12
|
+
function visible(element: HTMLElement) {
|
|
13
|
+
const isHidden =
|
|
14
|
+
element.getAttribute('aria-hidden') ||
|
|
15
|
+
element.getAttribute('hidden') ||
|
|
16
|
+
element.getAttribute('type') === 'hidden';
|
|
17
|
+
|
|
18
|
+
if (isHidden) {
|
|
19
|
+
return false;
|
|
20
|
+
}
|
|
21
|
+
|
|
22
|
+
let parentElement: HTMLElement = element;
|
|
23
|
+
while (parentElement) {
|
|
24
|
+
if (parentElement === document.body || parentElement.nodeType === 11) {
|
|
25
|
+
break;
|
|
26
|
+
}
|
|
27
|
+
|
|
28
|
+
if (hidden(parentElement)) {
|
|
29
|
+
return false;
|
|
30
|
+
}
|
|
31
|
+
|
|
32
|
+
parentElement = parentElement.parentNode as HTMLElement;
|
|
33
|
+
}
|
|
34
|
+
|
|
35
|
+
return true;
|
|
36
|
+
}
|
|
37
|
+
|
|
38
|
+
function getElementTabIndex(element: HTMLElement) {
|
|
39
|
+
let tabIndex: string | null | undefined = element.getAttribute('tabindex');
|
|
40
|
+
if (tabIndex === null) {
|
|
41
|
+
tabIndex = undefined;
|
|
42
|
+
}
|
|
43
|
+
return parseInt(tabIndex as string, 10);
|
|
44
|
+
}
|
|
45
|
+
|
|
46
|
+
export function focusable(element: HTMLElement) {
|
|
47
|
+
const nodeName = element.nodeName.toLowerCase();
|
|
48
|
+
const isTabIndexNotNaN = !Number.isNaN(getElementTabIndex(element));
|
|
49
|
+
const res =
|
|
50
|
+
// @ts-expect-error function accepts any html element but if it is a button, it should not be disabled to trigger the condition
|
|
51
|
+
(TABBABLE_NODES.test(nodeName) && !element.disabled) ||
|
|
52
|
+
(element instanceof HTMLAnchorElement ? element.href || isTabIndexNotNaN : isTabIndexNotNaN);
|
|
53
|
+
|
|
54
|
+
return res && visible(element);
|
|
55
|
+
}
|
|
56
|
+
|
|
57
|
+
export function tabbable(element: HTMLElement) {
|
|
58
|
+
const tabIndex = getElementTabIndex(element);
|
|
59
|
+
const isTabIndexNaN = Number.isNaN(tabIndex);
|
|
60
|
+
return (isTabIndexNaN || tabIndex >= 0) && focusable(element);
|
|
61
|
+
}
|
|
62
|
+
|
|
63
|
+
export function findTabbableDescendants(element: HTMLElement): HTMLElement[] {
|
|
64
|
+
return Array.from(element.querySelectorAll<HTMLElement>(FOCUS_SELECTOR)).filter(tabbable);
|
|
65
|
+
}
|
|
@@ -0,0 +1,84 @@
|
|
|
1
|
+
import { useCallback, useEffect, useRef } from 'octane';
|
|
2
|
+
import { scopeTab } from './scope-tab';
|
|
3
|
+
import { FOCUS_SELECTOR, focusable, tabbable } from './tabbable';
|
|
4
|
+
|
|
5
|
+
export function useFocusTrap(active = true): React.RefCallback<HTMLElement | null> {
|
|
6
|
+
const ref = useRef<HTMLElement | null>(null);
|
|
7
|
+
|
|
8
|
+
const focusNode = (node: HTMLElement) => {
|
|
9
|
+
let focusElement: HTMLElement | null = node.querySelector('[data-autofocus]');
|
|
10
|
+
|
|
11
|
+
if (!focusElement) {
|
|
12
|
+
const children = Array.from<HTMLElement>(node.querySelectorAll(FOCUS_SELECTOR));
|
|
13
|
+
focusElement = children.find(tabbable) || children.find(focusable) || null;
|
|
14
|
+
if (!focusElement && focusable(node)) {
|
|
15
|
+
focusElement = node;
|
|
16
|
+
}
|
|
17
|
+
}
|
|
18
|
+
|
|
19
|
+
if (focusElement) {
|
|
20
|
+
focusElement.focus({ preventScroll: true });
|
|
21
|
+
} else if (process.env.NODE_ENV === 'development') {
|
|
22
|
+
// oxlint-disable-next-line no-console
|
|
23
|
+
console.warn(
|
|
24
|
+
'[@mantine/hooks/use-focus-trap] Failed to find focusable element within provided node',
|
|
25
|
+
node,
|
|
26
|
+
);
|
|
27
|
+
}
|
|
28
|
+
};
|
|
29
|
+
|
|
30
|
+
const setRef = useCallback(
|
|
31
|
+
(node: HTMLElement | null) => {
|
|
32
|
+
if (!active) {
|
|
33
|
+
return;
|
|
34
|
+
}
|
|
35
|
+
|
|
36
|
+
if (node === null) {
|
|
37
|
+
ref.current = null;
|
|
38
|
+
return;
|
|
39
|
+
}
|
|
40
|
+
|
|
41
|
+
if (ref.current === node) {
|
|
42
|
+
return;
|
|
43
|
+
}
|
|
44
|
+
|
|
45
|
+
// Delay processing the HTML node by a frame. This ensures focus is assigned correctly.
|
|
46
|
+
setTimeout(() => {
|
|
47
|
+
if (node.getRootNode()) {
|
|
48
|
+
focusNode(node);
|
|
49
|
+
} else if (process.env.NODE_ENV === 'development') {
|
|
50
|
+
// oxlint-disable-next-line no-console
|
|
51
|
+
console.warn('[@mantine/hooks/use-focus-trap] Ref node is not part of the dom', node);
|
|
52
|
+
}
|
|
53
|
+
});
|
|
54
|
+
|
|
55
|
+
ref.current = node;
|
|
56
|
+
},
|
|
57
|
+
[active],
|
|
58
|
+
);
|
|
59
|
+
|
|
60
|
+
useEffect(() => {
|
|
61
|
+
if (!active) {
|
|
62
|
+
return undefined;
|
|
63
|
+
}
|
|
64
|
+
|
|
65
|
+
if (ref.current) {
|
|
66
|
+
setTimeout(() => {
|
|
67
|
+
if (ref.current) {
|
|
68
|
+
focusNode(ref.current);
|
|
69
|
+
}
|
|
70
|
+
});
|
|
71
|
+
}
|
|
72
|
+
|
|
73
|
+
const handleKeyDown = (event: KeyboardEvent) => {
|
|
74
|
+
if (event.key === 'Tab' && ref.current) {
|
|
75
|
+
scopeTab(ref.current, event);
|
|
76
|
+
}
|
|
77
|
+
};
|
|
78
|
+
|
|
79
|
+
document.addEventListener('keydown', handleKeyDown);
|
|
80
|
+
return () => document.removeEventListener('keydown', handleKeyDown);
|
|
81
|
+
}, [active]);
|
|
82
|
+
|
|
83
|
+
return setRef;
|
|
84
|
+
}
|
|
@@ -0,0 +1,90 @@
|
|
|
1
|
+
import { useCallback, useEffect, useRef, useState } from 'octane';
|
|
2
|
+
import { useCallbackRef } from '../utils';
|
|
3
|
+
|
|
4
|
+
function containsRelatedTarget(event: FocusEvent) {
|
|
5
|
+
if (event.currentTarget instanceof HTMLElement && event.relatedTarget instanceof HTMLElement) {
|
|
6
|
+
return event.currentTarget.contains(event.relatedTarget);
|
|
7
|
+
}
|
|
8
|
+
|
|
9
|
+
return false;
|
|
10
|
+
}
|
|
11
|
+
|
|
12
|
+
export interface UseFocusWithinOptions {
|
|
13
|
+
onFocus?: (event: FocusEvent) => void;
|
|
14
|
+
onBlur?: (event: FocusEvent) => void;
|
|
15
|
+
}
|
|
16
|
+
|
|
17
|
+
export interface UseFocusWithinReturnValue<T extends HTMLElement = any> {
|
|
18
|
+
ref: React.RefCallback<T | null>;
|
|
19
|
+
focused: boolean;
|
|
20
|
+
}
|
|
21
|
+
|
|
22
|
+
export function useFocusWithin<T extends HTMLElement = any>({
|
|
23
|
+
onBlur,
|
|
24
|
+
onFocus,
|
|
25
|
+
}: UseFocusWithinOptions = {}): UseFocusWithinReturnValue<T> {
|
|
26
|
+
const [focused, setFocused] = useState(false);
|
|
27
|
+
const focusedRef = useRef(false);
|
|
28
|
+
const previousNode = useRef<T | null>(null);
|
|
29
|
+
|
|
30
|
+
const onFocusRef = useCallbackRef(onFocus);
|
|
31
|
+
const onBlurRef = useCallbackRef(onBlur);
|
|
32
|
+
|
|
33
|
+
const _setFocused = useCallback((value: boolean) => {
|
|
34
|
+
setFocused(value);
|
|
35
|
+
focusedRef.current = value;
|
|
36
|
+
}, []);
|
|
37
|
+
|
|
38
|
+
const handleFocusIn = useCallback((event: FocusEvent) => {
|
|
39
|
+
if (!focusedRef.current) {
|
|
40
|
+
_setFocused(true);
|
|
41
|
+
onFocusRef(event);
|
|
42
|
+
}
|
|
43
|
+
}, []);
|
|
44
|
+
|
|
45
|
+
const handleFocusOut = useCallback((event: FocusEvent) => {
|
|
46
|
+
if (focusedRef.current && !containsRelatedTarget(event)) {
|
|
47
|
+
_setFocused(false);
|
|
48
|
+
onBlurRef(event);
|
|
49
|
+
}
|
|
50
|
+
}, []);
|
|
51
|
+
|
|
52
|
+
const detach = useCallback(() => {
|
|
53
|
+
const node = previousNode.current;
|
|
54
|
+
if (node) {
|
|
55
|
+
node.removeEventListener('focusin', handleFocusIn);
|
|
56
|
+
node.removeEventListener('focusout', handleFocusOut);
|
|
57
|
+
previousNode.current = null;
|
|
58
|
+
}
|
|
59
|
+
}, [handleFocusIn, handleFocusOut]);
|
|
60
|
+
|
|
61
|
+
const callbackRef: React.RefCallback<T | null> = useCallback(
|
|
62
|
+
(node) => {
|
|
63
|
+
detach();
|
|
64
|
+
if (!node) {
|
|
65
|
+
return undefined;
|
|
66
|
+
}
|
|
67
|
+
|
|
68
|
+
node.addEventListener('focusin', handleFocusIn);
|
|
69
|
+
node.addEventListener('focusout', handleFocusOut);
|
|
70
|
+
previousNode.current = node;
|
|
71
|
+
|
|
72
|
+
return () => {
|
|
73
|
+
// A stale ref cleanup must not detach a replacement node.
|
|
74
|
+
if (previousNode.current === node) {
|
|
75
|
+
detach();
|
|
76
|
+
}
|
|
77
|
+
};
|
|
78
|
+
},
|
|
79
|
+
[handleFocusIn, handleFocusOut, detach],
|
|
80
|
+
);
|
|
81
|
+
|
|
82
|
+
useEffect(() => () => detach(), [detach]);
|
|
83
|
+
|
|
84
|
+
return { ref: callbackRef, focused };
|
|
85
|
+
}
|
|
86
|
+
|
|
87
|
+
export namespace useFocusWithin {
|
|
88
|
+
export type Options = UseFocusWithinOptions;
|
|
89
|
+
export type ReturnValue<T extends HTMLElement> = UseFocusWithinReturnValue<T>;
|
|
90
|
+
}
|
|
@@ -0,0 +1,153 @@
|
|
|
1
|
+
import { useCallback, useEffect, useRef, useState } from 'octane';
|
|
2
|
+
|
|
3
|
+
function getFullscreenElement(): HTMLElement | null {
|
|
4
|
+
const _document = window.document as any;
|
|
5
|
+
|
|
6
|
+
const fullscreenElement =
|
|
7
|
+
_document.fullscreenElement ||
|
|
8
|
+
_document.webkitFullscreenElement ||
|
|
9
|
+
_document.mozFullScreenElement ||
|
|
10
|
+
_document.msFullscreenElement;
|
|
11
|
+
|
|
12
|
+
return fullscreenElement;
|
|
13
|
+
}
|
|
14
|
+
|
|
15
|
+
function exitFullscreen() {
|
|
16
|
+
const _document = window.document as any;
|
|
17
|
+
|
|
18
|
+
if (typeof _document.exitFullscreen === 'function') {
|
|
19
|
+
return _document.exitFullscreen();
|
|
20
|
+
}
|
|
21
|
+
if (typeof _document.msExitFullscreen === 'function') {
|
|
22
|
+
return _document.msExitFullscreen();
|
|
23
|
+
}
|
|
24
|
+
if (typeof _document.webkitExitFullscreen === 'function') {
|
|
25
|
+
return _document.webkitExitFullscreen();
|
|
26
|
+
}
|
|
27
|
+
if (typeof _document.mozCancelFullScreen === 'function') {
|
|
28
|
+
return _document.mozCancelFullScreen();
|
|
29
|
+
}
|
|
30
|
+
|
|
31
|
+
return null;
|
|
32
|
+
}
|
|
33
|
+
|
|
34
|
+
function enterFullScreen(element: HTMLElement) {
|
|
35
|
+
const _element = element as any;
|
|
36
|
+
|
|
37
|
+
return (
|
|
38
|
+
_element.requestFullscreen?.() ||
|
|
39
|
+
_element.msRequestFullscreen?.() ||
|
|
40
|
+
_element.webkitEnterFullscreen?.() ||
|
|
41
|
+
_element.webkitRequestFullscreen?.() ||
|
|
42
|
+
_element.mozRequestFullscreen?.()
|
|
43
|
+
);
|
|
44
|
+
}
|
|
45
|
+
|
|
46
|
+
const prefixes = ['', 'webkit', 'moz', 'ms'];
|
|
47
|
+
|
|
48
|
+
interface FullscreenEvents {
|
|
49
|
+
onFullScreen: (event: Event) => void;
|
|
50
|
+
onError: (event: Event) => void;
|
|
51
|
+
}
|
|
52
|
+
|
|
53
|
+
function addEvents(element: HTMLElement, events: FullscreenEvents) {
|
|
54
|
+
const { onFullScreen, onError } = events;
|
|
55
|
+
prefixes.forEach((prefix) => {
|
|
56
|
+
element.addEventListener(`${prefix}fullscreenchange`, onFullScreen);
|
|
57
|
+
element.addEventListener(`${prefix}fullscreenerror`, onError);
|
|
58
|
+
});
|
|
59
|
+
|
|
60
|
+
return () => removeEvents(element, events);
|
|
61
|
+
}
|
|
62
|
+
|
|
63
|
+
function removeEvents(element: HTMLElement, { onFullScreen, onError }: FullscreenEvents) {
|
|
64
|
+
prefixes.forEach((prefix) => {
|
|
65
|
+
element.removeEventListener(`${prefix}fullscreenchange`, onFullScreen);
|
|
66
|
+
element.removeEventListener(`${prefix}fullscreenerror`, onError);
|
|
67
|
+
});
|
|
68
|
+
}
|
|
69
|
+
|
|
70
|
+
export interface UseFullscreenElementReturnValue<T extends HTMLElement = any> {
|
|
71
|
+
ref: React.RefCallback<T | null>;
|
|
72
|
+
toggle: () => Promise<void>;
|
|
73
|
+
fullscreen: boolean;
|
|
74
|
+
}
|
|
75
|
+
|
|
76
|
+
export function useFullscreenElement<
|
|
77
|
+
T extends HTMLElement = any,
|
|
78
|
+
>(): UseFullscreenElementReturnValue<T> {
|
|
79
|
+
const [fullscreen, setFullscreen] = useState<boolean>(false);
|
|
80
|
+
const refElement = useRef<T | null>(null);
|
|
81
|
+
const prevNodeRef = useRef<T | null>(null);
|
|
82
|
+
|
|
83
|
+
const handleFullscreenChange = useCallback(() => {
|
|
84
|
+
setFullscreen(refElement.current === getFullscreenElement());
|
|
85
|
+
}, []);
|
|
86
|
+
|
|
87
|
+
const handleFullscreenError = useCallback(() => {
|
|
88
|
+
setFullscreen(false);
|
|
89
|
+
}, []);
|
|
90
|
+
|
|
91
|
+
const toggle = useCallback(async () => {
|
|
92
|
+
if (!getFullscreenElement() && refElement.current) {
|
|
93
|
+
await enterFullScreen(refElement.current);
|
|
94
|
+
} else {
|
|
95
|
+
await exitFullscreen();
|
|
96
|
+
}
|
|
97
|
+
}, []);
|
|
98
|
+
|
|
99
|
+
const refCallback: React.RefCallback<T | null> = useCallback((node) => {
|
|
100
|
+
if (prevNodeRef.current && prevNodeRef.current !== node) {
|
|
101
|
+
removeEvents(prevNodeRef.current, {
|
|
102
|
+
onFullScreen: handleFullscreenChange,
|
|
103
|
+
onError: handleFullscreenError,
|
|
104
|
+
});
|
|
105
|
+
}
|
|
106
|
+
|
|
107
|
+
if (node) {
|
|
108
|
+
addEvents(node, {
|
|
109
|
+
onFullScreen: handleFullscreenChange,
|
|
110
|
+
onError: handleFullscreenError,
|
|
111
|
+
});
|
|
112
|
+
}
|
|
113
|
+
|
|
114
|
+
refElement.current = node;
|
|
115
|
+
prevNodeRef.current = node;
|
|
116
|
+
}, []);
|
|
117
|
+
|
|
118
|
+
return { ref: refCallback, toggle, fullscreen };
|
|
119
|
+
}
|
|
120
|
+
|
|
121
|
+
export interface UseFullscreenDocumentReturnValue {
|
|
122
|
+
toggle: () => Promise<void>;
|
|
123
|
+
fullscreen: boolean;
|
|
124
|
+
}
|
|
125
|
+
|
|
126
|
+
export function useFullscreenDocument(): UseFullscreenDocumentReturnValue {
|
|
127
|
+
const [fullscreen, setFullscreen] = useState<boolean>(false);
|
|
128
|
+
|
|
129
|
+
const handleFullscreenChange = useCallback(() => {
|
|
130
|
+
setFullscreen(getFullscreenElement() === window.document.documentElement);
|
|
131
|
+
}, []);
|
|
132
|
+
|
|
133
|
+
const handleFullscreenError = useCallback(() => {
|
|
134
|
+
setFullscreen(false);
|
|
135
|
+
}, []);
|
|
136
|
+
|
|
137
|
+
const toggle = useCallback(async () => {
|
|
138
|
+
if (!getFullscreenElement()) {
|
|
139
|
+
await enterFullScreen(window.document.documentElement);
|
|
140
|
+
} else {
|
|
141
|
+
await exitFullscreen();
|
|
142
|
+
}
|
|
143
|
+
}, []);
|
|
144
|
+
|
|
145
|
+
useEffect(() => {
|
|
146
|
+
return addEvents(window.document.documentElement, {
|
|
147
|
+
onFullScreen: handleFullscreenChange,
|
|
148
|
+
onError: handleFullscreenError,
|
|
149
|
+
});
|
|
150
|
+
}, []);
|
|
151
|
+
|
|
152
|
+
return { toggle, fullscreen };
|
|
153
|
+
}
|
|
@@ -0,0 +1,42 @@
|
|
|
1
|
+
import { useEffect, useState } from 'octane';
|
|
2
|
+
import { withoutSlot } from '../internal';
|
|
3
|
+
import { useWindowEvent } from '../use-window-event/use-window-event';
|
|
4
|
+
|
|
5
|
+
export interface UseHashInput {
|
|
6
|
+
getInitialValueInEffect?: boolean;
|
|
7
|
+
}
|
|
8
|
+
|
|
9
|
+
export type UseHashReturnValue = [string, (value: string) => void];
|
|
10
|
+
|
|
11
|
+
export function useHash(options: UseHashInput = {}): UseHashReturnValue {
|
|
12
|
+
const { getInitialValueInEffect = true } = withoutSlot(options) ?? {};
|
|
13
|
+
const [hash, setHash] = useState<string>(
|
|
14
|
+
getInitialValueInEffect ? '' : window.location.hash || '',
|
|
15
|
+
);
|
|
16
|
+
|
|
17
|
+
const setHashHandler = (value: string) => {
|
|
18
|
+
const valueWithHash = value.startsWith('#') ? value : `#${value}`;
|
|
19
|
+
window.location.hash = valueWithHash;
|
|
20
|
+
setHash(valueWithHash);
|
|
21
|
+
};
|
|
22
|
+
|
|
23
|
+
useWindowEvent('hashchange', () => {
|
|
24
|
+
const newHash = window.location.hash;
|
|
25
|
+
if (hash !== newHash) {
|
|
26
|
+
setHash(newHash);
|
|
27
|
+
}
|
|
28
|
+
});
|
|
29
|
+
|
|
30
|
+
useEffect(() => {
|
|
31
|
+
if (getInitialValueInEffect) {
|
|
32
|
+
setHash(window.location.hash);
|
|
33
|
+
}
|
|
34
|
+
}, []);
|
|
35
|
+
|
|
36
|
+
return [hash, setHashHandler];
|
|
37
|
+
}
|
|
38
|
+
|
|
39
|
+
export namespace useHash {
|
|
40
|
+
export type Options = UseHashInput;
|
|
41
|
+
export type ReturnValue = UseHashReturnValue;
|
|
42
|
+
}
|
|
@@ -0,0 +1,160 @@
|
|
|
1
|
+
import { useEffectEvent, useRef } from 'octane';
|
|
2
|
+
import { useIsomorphicEffect } from '../use-isomorphic-effect/use-isomorphic-effect';
|
|
3
|
+
import { useScrollDirection } from '../use-scroll-direction/use-scroll-direction';
|
|
4
|
+
import { useWindowScroll } from '../use-window-scroll/use-window-scroll';
|
|
5
|
+
|
|
6
|
+
export { useScrollDirection } from '../use-scroll-direction/use-scroll-direction';
|
|
7
|
+
|
|
8
|
+
export const isFixed = (current: number, fixedAt: number) => current <= fixedAt;
|
|
9
|
+
export const isPinned = (current: number, previous: number) => current <= previous;
|
|
10
|
+
export const isReleased = (current: number, previous: number, fixedAt: number) =>
|
|
11
|
+
!isPinned(current, previous) && !isFixed(current, fixedAt);
|
|
12
|
+
|
|
13
|
+
export const isPinnedOrReleased = (
|
|
14
|
+
current: number,
|
|
15
|
+
fixedAt: number,
|
|
16
|
+
isCurrentlyPinnedRef: React.RefObject<boolean>,
|
|
17
|
+
isScrollingUp: boolean,
|
|
18
|
+
onPin?: () => void,
|
|
19
|
+
onRelease?: () => void,
|
|
20
|
+
) => {
|
|
21
|
+
const isInFixedPosition = isFixed(current, fixedAt);
|
|
22
|
+
if (isInFixedPosition && !isCurrentlyPinnedRef.current) {
|
|
23
|
+
isCurrentlyPinnedRef.current = true;
|
|
24
|
+
onPin?.();
|
|
25
|
+
} else if (!isInFixedPosition && isScrollingUp && !isCurrentlyPinnedRef.current) {
|
|
26
|
+
isCurrentlyPinnedRef.current = true;
|
|
27
|
+
onPin?.();
|
|
28
|
+
} else if (!isInFixedPosition && !isScrollingUp && isCurrentlyPinnedRef.current) {
|
|
29
|
+
isCurrentlyPinnedRef.current = false;
|
|
30
|
+
onRelease?.();
|
|
31
|
+
}
|
|
32
|
+
};
|
|
33
|
+
|
|
34
|
+
export interface UseHeadroomInput {
|
|
35
|
+
/** Number in px at which element should be fixed */
|
|
36
|
+
fixedAt?: number;
|
|
37
|
+
|
|
38
|
+
/** Number of px to scroll to fully reveal or hide the element, 100 by default */
|
|
39
|
+
scrollDistance?: number;
|
|
40
|
+
|
|
41
|
+
/** Called when element is pinned */
|
|
42
|
+
onPin?: () => void;
|
|
43
|
+
|
|
44
|
+
/** Called when element is at fixed position */
|
|
45
|
+
onFix?: () => void;
|
|
46
|
+
|
|
47
|
+
/** Called when element is unpinned */
|
|
48
|
+
onRelease?: () => void;
|
|
49
|
+
}
|
|
50
|
+
|
|
51
|
+
export interface UseHeadroomReturnValue {
|
|
52
|
+
/** True when the element is at least partially visible */
|
|
53
|
+
pinned: boolean;
|
|
54
|
+
|
|
55
|
+
/** Reveal progress: 0 = fully hidden, 1 = fully visible */
|
|
56
|
+
scrollProgress: number;
|
|
57
|
+
}
|
|
58
|
+
|
|
59
|
+
export function useHeadroom({
|
|
60
|
+
fixedAt = 0,
|
|
61
|
+
scrollDistance = 100,
|
|
62
|
+
onPin,
|
|
63
|
+
onFix,
|
|
64
|
+
onRelease,
|
|
65
|
+
}: UseHeadroomInput = {}): UseHeadroomReturnValue {
|
|
66
|
+
const isCurrentlyPinnedRef = useRef(false);
|
|
67
|
+
const scrollDirection = useScrollDirection();
|
|
68
|
+
const isScrollingUp = scrollDirection === 'up';
|
|
69
|
+
const [{ y: scrollPosition }] = useWindowScroll();
|
|
70
|
+
|
|
71
|
+
const onPinEvent = useEffectEvent(() => onPin?.());
|
|
72
|
+
const onReleaseEvent = useEffectEvent(() => onRelease?.());
|
|
73
|
+
const onFixEvent = useEffectEvent(() => onFix?.());
|
|
74
|
+
|
|
75
|
+
useIsomorphicEffect(() => {
|
|
76
|
+
isPinnedOrReleased(
|
|
77
|
+
scrollPosition,
|
|
78
|
+
fixedAt,
|
|
79
|
+
isCurrentlyPinnedRef,
|
|
80
|
+
isScrollingUp,
|
|
81
|
+
onPinEvent,
|
|
82
|
+
onReleaseEvent,
|
|
83
|
+
);
|
|
84
|
+
}, [scrollPosition, fixedAt, isScrollingUp]);
|
|
85
|
+
|
|
86
|
+
const wasFixedRef = useRef(false);
|
|
87
|
+
|
|
88
|
+
useIsomorphicEffect(() => {
|
|
89
|
+
const currentlyInFixedZone = isFixed(scrollPosition, fixedAt);
|
|
90
|
+
if (currentlyInFixedZone && !wasFixedRef.current) {
|
|
91
|
+
onFixEvent();
|
|
92
|
+
}
|
|
93
|
+
wasFixedRef.current = currentlyInFixedZone;
|
|
94
|
+
}, [scrollPosition, fixedAt]);
|
|
95
|
+
|
|
96
|
+
// Refs for scroll-progress tracking. Mutated during render (safe for refs).
|
|
97
|
+
const currentlyFixed = isFixed(scrollPosition, fixedAt);
|
|
98
|
+
const prevIsFixedRef = useRef(currentlyFixed);
|
|
99
|
+
const directionChangeScrollYRef = useRef(scrollPosition);
|
|
100
|
+
const progressAtDirectionChangeRef = useRef(currentlyFixed ? 1 : 0);
|
|
101
|
+
const prevIsScrollingUpRef = useRef(isScrollingUp);
|
|
102
|
+
|
|
103
|
+
// Detect fixed-zone transitions first. When leaving the fixed zone the baseline
|
|
104
|
+
// is anchored at fixedAt (not the current scroll position) so the delta is measured
|
|
105
|
+
// from where the element was last fully visible, regardless of how scroll position
|
|
106
|
+
// was initialised on the first render.
|
|
107
|
+
if (prevIsFixedRef.current !== currentlyFixed) {
|
|
108
|
+
prevIsFixedRef.current = currentlyFixed;
|
|
109
|
+
|
|
110
|
+
if (!currentlyFixed) {
|
|
111
|
+
directionChangeScrollYRef.current = fixedAt;
|
|
112
|
+
progressAtDirectionChangeRef.current = 1;
|
|
113
|
+
} else {
|
|
114
|
+
directionChangeScrollYRef.current = scrollPosition;
|
|
115
|
+
progressAtDirectionChangeRef.current = 1;
|
|
116
|
+
}
|
|
117
|
+
|
|
118
|
+
prevIsScrollingUpRef.current = isScrollingUp;
|
|
119
|
+
}
|
|
120
|
+
|
|
121
|
+
// When scroll direction changes outside the fixed zone, save the current progress
|
|
122
|
+
// so the next direction accumulates from that point (handles partial reveals).
|
|
123
|
+
if (!currentlyFixed && prevIsScrollingUpRef.current !== isScrollingUp) {
|
|
124
|
+
const transitionDelta = Math.abs(scrollPosition - directionChangeScrollYRef.current);
|
|
125
|
+
const transitionProgress = prevIsScrollingUpRef.current
|
|
126
|
+
? Math.min(progressAtDirectionChangeRef.current + transitionDelta / scrollDistance, 1)
|
|
127
|
+
: Math.max(progressAtDirectionChangeRef.current - transitionDelta / scrollDistance, 0);
|
|
128
|
+
|
|
129
|
+
prevIsScrollingUpRef.current = isScrollingUp;
|
|
130
|
+
directionChangeScrollYRef.current = scrollPosition;
|
|
131
|
+
progressAtDirectionChangeRef.current = transitionProgress;
|
|
132
|
+
}
|
|
133
|
+
|
|
134
|
+
let scrollProgress: number;
|
|
135
|
+
|
|
136
|
+
if (currentlyFixed) {
|
|
137
|
+
scrollProgress = 1;
|
|
138
|
+
} else {
|
|
139
|
+
const scrollDelta = Math.abs(scrollPosition - directionChangeScrollYRef.current);
|
|
140
|
+
|
|
141
|
+
if (isScrollingUp) {
|
|
142
|
+
scrollProgress = Math.min(
|
|
143
|
+
progressAtDirectionChangeRef.current + scrollDelta / scrollDistance,
|
|
144
|
+
1,
|
|
145
|
+
);
|
|
146
|
+
} else {
|
|
147
|
+
scrollProgress = Math.max(
|
|
148
|
+
progressAtDirectionChangeRef.current - scrollDelta / scrollDistance,
|
|
149
|
+
0,
|
|
150
|
+
);
|
|
151
|
+
}
|
|
152
|
+
}
|
|
153
|
+
|
|
154
|
+
return { pinned: scrollProgress > 0, scrollProgress };
|
|
155
|
+
}
|
|
156
|
+
|
|
157
|
+
export namespace useHeadroom {
|
|
158
|
+
export type Input = UseHeadroomInput;
|
|
159
|
+
export type ReturnValue = UseHeadroomReturnValue;
|
|
160
|
+
}
|