@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.
Files changed (99) hide show
  1. package/LICENSE +21 -0
  2. package/README.md +29 -0
  3. package/package.json +45 -0
  4. package/src/index.ts +259 -0
  5. package/src/internal.ts +6 -0
  6. package/src/use-click-outside/use-click-outside.ts +57 -0
  7. package/src/use-clipboard/use-clipboard.ts +69 -0
  8. package/src/use-collapse/use-collapse.ts +162 -0
  9. package/src/use-collapse/use-horizontal-collapse.ts +164 -0
  10. package/src/use-color-scheme/use-color-scheme.ts +13 -0
  11. package/src/use-counter/use-counter.ts +59 -0
  12. package/src/use-debounced-callback/use-debounced-callback.ts +159 -0
  13. package/src/use-debounced-state/use-debounced-state.ts +44 -0
  14. package/src/use-debounced-value/use-debounced-value.ts +71 -0
  15. package/src/use-did-update/use-did-update.ts +26 -0
  16. package/src/use-disclosure/use-disclosure.ts +57 -0
  17. package/src/use-document-title/use-document-title.ts +9 -0
  18. package/src/use-document-visibility/use-document-visibility.ts +14 -0
  19. package/src/use-drag/use-drag.ts +463 -0
  20. package/src/use-event-listener/use-event-listener.ts +47 -0
  21. package/src/use-eye-dropper/use-eye-dropper.ts +41 -0
  22. package/src/use-favicon/use-favicon.ts +41 -0
  23. package/src/use-fetch/use-fetch.ts +85 -0
  24. package/src/use-file-dialog/use-file-dialog.ts +140 -0
  25. package/src/use-floating-window/use-floating-window.ts +431 -0
  26. package/src/use-focus-return/use-focus-return.ts +65 -0
  27. package/src/use-focus-trap/scope-tab.ts +36 -0
  28. package/src/use-focus-trap/tabbable.ts +65 -0
  29. package/src/use-focus-trap/use-focus-trap.ts +84 -0
  30. package/src/use-focus-within/use-focus-within.ts +90 -0
  31. package/src/use-force-update/use-force-update.ts +8 -0
  32. package/src/use-fullscreen/use-fullscreen.ts +153 -0
  33. package/src/use-hash/use-hash.ts +42 -0
  34. package/src/use-headroom/use-headroom.ts +160 -0
  35. package/src/use-hotkeys/parse-hotkey.ts +130 -0
  36. package/src/use-hotkeys/use-hotkeys.ts +63 -0
  37. package/src/use-hover/use-hover.ts +57 -0
  38. package/src/use-id/use-id.ts +23 -0
  39. package/src/use-idle/use-idle.ts +54 -0
  40. package/src/use-in-viewport/use-in-viewport.ts +34 -0
  41. package/src/use-input-state/use-input-state.ts +41 -0
  42. package/src/use-intersection/use-intersection.ts +41 -0
  43. package/src/use-interval/use-interval.ts +84 -0
  44. package/src/use-is-first-render/use-is-first-render.ts +12 -0
  45. package/src/use-isomorphic-effect/use-isomorphic-effect.ts +5 -0
  46. package/src/use-list-state/use-list-state.ts +157 -0
  47. package/src/use-local-storage/create-storage.ts +200 -0
  48. package/src/use-local-storage/use-local-storage.ts +19 -0
  49. package/src/use-logger/use-logger.ts +16 -0
  50. package/src/use-long-press/use-long-press.ts +188 -0
  51. package/src/use-map/use-map.ts +28 -0
  52. package/src/use-mask/use-mask.ts +1049 -0
  53. package/src/use-media-query/use-media-query.ts +57 -0
  54. package/src/use-merged-ref/use-merged-ref.ts +53 -0
  55. package/src/use-mounted/use-mounted.ts +7 -0
  56. package/src/use-mouse/use-mouse.ts +91 -0
  57. package/src/use-move/use-move.ts +165 -0
  58. package/src/use-mutation-observer/use-mutation-observer.ts +61 -0
  59. package/src/use-network/use-network.ts +70 -0
  60. package/src/use-orientation/use-orientation.ts +87 -0
  61. package/src/use-os/use-os.ts +93 -0
  62. package/src/use-page-leave/use-page-leave.ts +10 -0
  63. package/src/use-pagination/use-pagination.ts +149 -0
  64. package/src/use-previous/use-previous.ts +11 -0
  65. package/src/use-queue/use-queue.ts +71 -0
  66. package/src/use-radial-move/use-radial-move.ts +161 -0
  67. package/src/use-reduced-motion/use-reduced-motion.ts +6 -0
  68. package/src/use-resize-observer/use-resize-observer.ts +95 -0
  69. package/src/use-roving-index/use-roving-index.ts +386 -0
  70. package/src/use-scroll-direction/use-scroll-direction.ts +41 -0
  71. package/src/use-scroll-into-view/use-scroll-into-view.ts +294 -0
  72. package/src/use-scroll-spy/use-scroll-spy.ts +155 -0
  73. package/src/use-scroller/use-scroller.ts +225 -0
  74. package/src/use-selection/use-selection.ts +120 -0
  75. package/src/use-session-storage/use-session-storage.ts +19 -0
  76. package/src/use-set/use-set.ts +88 -0
  77. package/src/use-set-state/use-set-state.ts +29 -0
  78. package/src/use-shallow-effect/use-shallow-effect.ts +40 -0
  79. package/src/use-splitter/use-splitter.ts +1242 -0
  80. package/src/use-state-history/use-state-history.ts +70 -0
  81. package/src/use-text-selection/use-text-selection.ts +20 -0
  82. package/src/use-throttled-callback/use-throttled-callback.ts +60 -0
  83. package/src/use-throttled-state/use-throttled-state.ts +12 -0
  84. package/src/use-throttled-value/use-throttled-value.ts +23 -0
  85. package/src/use-timeout/use-timeout.ts +56 -0
  86. package/src/use-toggle/use-toggle.ts +23 -0
  87. package/src/use-uncontrolled/use-uncontrolled.ts +53 -0
  88. package/src/use-validated-state/use-validated-state.ts +50 -0
  89. package/src/use-viewport-size/use-viewport-size.ts +23 -0
  90. package/src/use-window-event/use-window-event.ts +16 -0
  91. package/src/use-window-scroll/use-window-scroll.ts +49 -0
  92. package/src/utils/clamp/clamp.ts +15 -0
  93. package/src/utils/index.ts +7 -0
  94. package/src/utils/lower-first/lower-first.ts +3 -0
  95. package/src/utils/random-id/random-id.ts +3 -0
  96. package/src/utils/range/range.ts +10 -0
  97. package/src/utils/shallow-equal/shallow-equal.ts +34 -0
  98. package/src/utils/upper-first/upper-first.ts +3 -0
  99. package/src/utils/use-callback-ref/use-callback-ref.ts +11 -0
@@ -0,0 +1,130 @@
1
+ export interface KeyboardModifiers {
2
+ alt: boolean;
3
+ ctrl: boolean;
4
+ meta: boolean;
5
+ mod: boolean;
6
+ shift: boolean;
7
+ }
8
+
9
+ export interface Hotkey extends KeyboardModifiers {
10
+ key?: string;
11
+ }
12
+
13
+ type CheckHotkeyMatch = (event: KeyboardEvent) => boolean;
14
+
15
+ const keyNameMap: Record<string, string> = {
16
+ ' ': 'space',
17
+ ArrowLeft: 'arrowleft',
18
+ ArrowRight: 'arrowright',
19
+ ArrowUp: 'arrowup',
20
+ ArrowDown: 'arrowdown',
21
+ Escape: 'escape',
22
+ Esc: 'escape',
23
+ esc: 'escape',
24
+ Enter: 'enter',
25
+ Tab: 'tab',
26
+ Backspace: 'backspace',
27
+ Delete: 'delete',
28
+ Insert: 'insert',
29
+ Home: 'home',
30
+ End: 'end',
31
+ PageUp: 'pageup',
32
+ PageDown: 'pagedown',
33
+ '+': 'plus',
34
+ '-': 'minus',
35
+ '*': 'asterisk',
36
+ '/': 'slash',
37
+ };
38
+
39
+ function normalizeKey(key: string): string {
40
+ const lowerKey = key.replace('Key', '').toLowerCase();
41
+ return keyNameMap[key] || lowerKey;
42
+ }
43
+
44
+ export function parseHotkey(hotkey: string): Hotkey {
45
+ const keys = hotkey
46
+ .toLowerCase()
47
+ .split('+')
48
+ .map((part) => part.trim());
49
+
50
+ const modifiers: KeyboardModifiers = {
51
+ alt: keys.includes('alt'),
52
+ ctrl: keys.includes('ctrl'),
53
+ meta: keys.includes('meta'),
54
+ mod: keys.includes('mod'),
55
+ shift: keys.includes('shift'),
56
+ };
57
+
58
+ const reservedKeys = ['alt', 'ctrl', 'meta', 'shift', 'mod'];
59
+
60
+ const freeKey = keys.find((key) => !reservedKeys.includes(key));
61
+
62
+ return {
63
+ ...modifiers,
64
+ key: freeKey === '[plus]' ? '+' : freeKey,
65
+ };
66
+ }
67
+
68
+ function isExactHotkey(hotkey: Hotkey, event: KeyboardEvent, usePhysicalKeys?: boolean): boolean {
69
+ const { alt, ctrl, meta, mod, shift, key } = hotkey;
70
+ const { altKey, ctrlKey, metaKey, shiftKey, key: pressedKey, code: pressedCode } = event;
71
+
72
+ if (alt !== altKey) {
73
+ return false;
74
+ }
75
+
76
+ if (mod) {
77
+ if (!ctrlKey && !metaKey) {
78
+ return false;
79
+ }
80
+ } else {
81
+ if (ctrl !== ctrlKey) {
82
+ return false;
83
+ }
84
+ if (meta !== metaKey) {
85
+ return false;
86
+ }
87
+ }
88
+ if (shift !== shiftKey) {
89
+ return false;
90
+ }
91
+
92
+ if (
93
+ key &&
94
+ (usePhysicalKeys
95
+ ? normalizeKey(pressedCode) === normalizeKey(key)
96
+ : normalizeKey(pressedKey ?? pressedCode) === normalizeKey(key))
97
+ ) {
98
+ return true;
99
+ }
100
+
101
+ return false;
102
+ }
103
+
104
+ export function getHotkeyMatcher(hotkey: string, usePhysicalKeys?: boolean): CheckHotkeyMatch {
105
+ return (event) => isExactHotkey(parseHotkey(hotkey), event, usePhysicalKeys);
106
+ }
107
+
108
+ export interface HotkeyItemOptions {
109
+ preventDefault?: boolean;
110
+ usePhysicalKeys?: boolean;
111
+ }
112
+
113
+ type HotkeyItem = [string, (event: any) => void, HotkeyItemOptions?];
114
+
115
+ export function getHotkeyHandler(hotkeys: HotkeyItem[]) {
116
+ return (event: React.KeyboardEvent<HTMLElement> | KeyboardEvent) => {
117
+ const _event = 'nativeEvent' in event ? event.nativeEvent : event;
118
+ hotkeys.forEach(
119
+ ([hotkey, handler, options = { preventDefault: true, usePhysicalKeys: false }]) => {
120
+ if (getHotkeyMatcher(hotkey, options.usePhysicalKeys)(_event)) {
121
+ if (options.preventDefault) {
122
+ event.preventDefault();
123
+ }
124
+
125
+ handler(_event);
126
+ }
127
+ },
128
+ );
129
+ };
130
+ }
@@ -0,0 +1,63 @@
1
+ import { useEffect, useEffectEvent } from 'octane';
2
+ import { getHotkeyHandler, getHotkeyMatcher } from './parse-hotkey';
3
+ import type { HotkeyItemOptions } from './parse-hotkey';
4
+
5
+ export type { HotkeyItemOptions };
6
+ export { getHotkeyHandler };
7
+
8
+ export type HotkeyItem = [string, (event: KeyboardEvent) => void, HotkeyItemOptions?];
9
+
10
+ function withoutSlot<T>(value: T | symbol): T | undefined {
11
+ return typeof value === 'symbol' ? undefined : value;
12
+ }
13
+
14
+ function shouldFireEvent(
15
+ event: KeyboardEvent,
16
+ tagsToIgnore: string[],
17
+ triggerOnContentEditable = false,
18
+ ) {
19
+ if (event.target instanceof HTMLElement) {
20
+ if (triggerOnContentEditable) {
21
+ return !tagsToIgnore.includes(event.target.tagName);
22
+ }
23
+
24
+ return !event.target.isContentEditable && !tagsToIgnore.includes(event.target.tagName);
25
+ }
26
+
27
+ return true;
28
+ }
29
+
30
+ export function useHotkeys(
31
+ hotkeys: HotkeyItem[],
32
+ tagsToIgnore: string[] = ['INPUT', 'TEXTAREA', 'SELECT'],
33
+ triggerOnContentEditable = false,
34
+ ) {
35
+ const ignoredTags = withoutSlot(tagsToIgnore) ?? ['INPUT', 'TEXTAREA', 'SELECT'];
36
+ const allowContentEditable = withoutSlot(triggerOnContentEditable) ?? false;
37
+
38
+ const handleKeydown = useEffectEvent((event: KeyboardEvent) => {
39
+ hotkeys.forEach(
40
+ ([hotkey, handler, options = { preventDefault: true, usePhysicalKeys: false }]) => {
41
+ if (
42
+ getHotkeyMatcher(hotkey, options.usePhysicalKeys)(event) &&
43
+ shouldFireEvent(event, ignoredTags, allowContentEditable)
44
+ ) {
45
+ if (options.preventDefault) {
46
+ event.preventDefault();
47
+ }
48
+
49
+ handler(event);
50
+ }
51
+ },
52
+ );
53
+ });
54
+
55
+ useEffect(() => {
56
+ document.documentElement.addEventListener('keydown', handleKeydown);
57
+ return () => document.documentElement.removeEventListener('keydown', handleKeydown);
58
+ }, []);
59
+ }
60
+
61
+ export namespace useHotkeys {
62
+ export type Hotkey = HotkeyItem;
63
+ }
@@ -0,0 +1,57 @@
1
+ import { useCallback, useRef, useState } from 'octane';
2
+
3
+ export interface UseHoverReturnValue<T extends HTMLElement = any> {
4
+ hovered: boolean;
5
+ ref: React.RefCallback<T | null>;
6
+ }
7
+
8
+ export function useHover<T extends HTMLElement = any>(): UseHoverReturnValue<T> {
9
+ const [hovered, setHovered] = useState(false);
10
+ const previousNode = useRef<HTMLElement | null>(null);
11
+
12
+ const handleMouseEnter = useCallback(() => {
13
+ setHovered(true);
14
+ }, []);
15
+
16
+ const handleMouseLeave = useCallback(() => {
17
+ setHovered(false);
18
+ }, []);
19
+
20
+ const ref: React.RefCallback<T | null> = useCallback(
21
+ (node) => {
22
+ if (previousNode.current) {
23
+ previousNode.current.removeEventListener('mouseenter', handleMouseEnter);
24
+ previousNode.current.removeEventListener('mouseleave', handleMouseLeave);
25
+ }
26
+
27
+ if (node) {
28
+ node.addEventListener('mouseenter', handleMouseEnter);
29
+ node.addEventListener('mouseleave', handleMouseLeave);
30
+ }
31
+
32
+ previousNode.current = node;
33
+
34
+ return () => {
35
+ node?.removeEventListener('mouseenter', handleMouseEnter);
36
+ node?.removeEventListener('mouseleave', handleMouseLeave);
37
+ if (previousNode.current === node) {
38
+ previousNode.current = null;
39
+ // Ref detaches run before replacement attaches. Defer the reset
40
+ // so a replacement in the same commit can preserve hover state.
41
+ queueMicrotask(() => {
42
+ if (previousNode.current === null) {
43
+ setHovered(false);
44
+ }
45
+ });
46
+ }
47
+ };
48
+ },
49
+ [handleMouseEnter, handleMouseLeave],
50
+ );
51
+
52
+ return { ref, hovered };
53
+ }
54
+
55
+ export namespace useHover {
56
+ export type ReturnValue<T extends HTMLElement> = UseHoverReturnValue<T>;
57
+ }
@@ -0,0 +1,23 @@
1
+ import { useId as useReactId, useRef, useState } from 'octane';
2
+ import { useIsomorphicEffect } from '../use-isomorphic-effect/use-isomorphic-effect';
3
+ import { randomId } from '../utils';
4
+
5
+ export function useId(staticId?: string) {
6
+ const reactId = useReactId();
7
+ const [uuid, setUuid] = useState(`mantine-${reactId.replace(/:/g, '')}`);
8
+ const hasInitializedRef = useRef(false);
9
+
10
+ useIsomorphicEffect(() => {
11
+ if (hasInitializedRef.current) {
12
+ return;
13
+ }
14
+ hasInitializedRef.current = true;
15
+ setUuid(randomId());
16
+ }, []);
17
+
18
+ if (typeof staticId === 'string') {
19
+ return staticId;
20
+ }
21
+
22
+ return uuid;
23
+ }
@@ -0,0 +1,54 @@
1
+ import { useEffect, useRef, useState } from 'octane';
2
+
3
+ export interface UseIdleOptions {
4
+ events?: (keyof DocumentEventMap)[];
5
+ initialState?: boolean;
6
+ }
7
+
8
+ const DEFAULT_OPTIONS: Required<UseIdleOptions> = {
9
+ events: ['keydown', 'mousemove', 'touchmove', 'click', 'scroll', 'wheel'],
10
+ initialState: true,
11
+ };
12
+
13
+ function withoutSlot<T>(value: T | symbol): T | undefined {
14
+ return typeof value === 'symbol' ? undefined : value;
15
+ }
16
+
17
+ export function useIdle(timeout: number, options?: UseIdleOptions) {
18
+ const { events, initialState } = { ...DEFAULT_OPTIONS, ...withoutSlot(options) };
19
+ const [idle, setIdle] = useState(initialState);
20
+ const timer = useRef(-1);
21
+
22
+ useEffect(() => {
23
+ const handleEvents = () => {
24
+ setIdle(false);
25
+
26
+ if (timer.current) {
27
+ window.clearTimeout(timer.current);
28
+ }
29
+
30
+ timer.current = window.setTimeout(() => {
31
+ setIdle(true);
32
+ }, timeout);
33
+ };
34
+
35
+ events.forEach((event) => document.addEventListener(event, handleEvents));
36
+
37
+ // Start the timer immediately instead of waiting for the first event to happen
38
+ timer.current = window.setTimeout(() => {
39
+ setIdle(true);
40
+ }, timeout);
41
+
42
+ return () => {
43
+ events.forEach((event) => document.removeEventListener(event, handleEvents));
44
+ window.clearTimeout(timer.current);
45
+ timer.current = -1;
46
+ };
47
+ }, [timeout]);
48
+
49
+ return idle;
50
+ }
51
+
52
+ export namespace useIdle {
53
+ export type Options = UseIdleOptions;
54
+ }
@@ -0,0 +1,34 @@
1
+ import { useCallback, useRef, useState } from 'octane';
2
+
3
+ export interface UseInViewportReturnValue<T extends HTMLElement = any> {
4
+ inViewport: boolean;
5
+ ref: React.RefCallback<T | null>;
6
+ }
7
+
8
+ export function useInViewport<T extends HTMLElement = any>(): UseInViewportReturnValue<T> {
9
+ const observer = useRef<IntersectionObserver | null>(null);
10
+ const [inViewport, setInViewport] = useState(false);
11
+
12
+ const ref: React.RefCallback<T | null> = useCallback((node) => {
13
+ if (typeof IntersectionObserver !== 'undefined') {
14
+ observer.current?.disconnect();
15
+
16
+ if (node) {
17
+ observer.current = new IntersectionObserver((entries) => {
18
+ const lastEntry = entries[entries.length - 1];
19
+ setInViewport(lastEntry.isIntersecting);
20
+ });
21
+ observer.current.observe(node);
22
+ } else {
23
+ observer.current = null;
24
+ setInViewport(false);
25
+ }
26
+ }
27
+ }, []);
28
+
29
+ return { ref, inViewport };
30
+ }
31
+
32
+ export namespace useInViewport {
33
+ export type ReturnValue<T extends HTMLElement> = UseInViewportReturnValue<T>;
34
+ }
@@ -0,0 +1,41 @@
1
+ import { useState } from 'octane';
2
+
3
+ export function getInputOnChange<T>(
4
+ setValue: (value: null | undefined | T | ((current: T) => T)) => void,
5
+ ) {
6
+ return (val: null | undefined | T | React.ChangeEvent<any> | ((current: T) => T)) => {
7
+ if (!val) {
8
+ setValue(val as T);
9
+ } else if (typeof val === 'function') {
10
+ setValue(val);
11
+ } else if (
12
+ typeof val === 'object' &&
13
+ (('currentTarget' in val && val.currentTarget != null) ||
14
+ ('target' in val && val.target != null))
15
+ ) {
16
+ const currentTarget = ('currentTarget' in val && val.currentTarget) || (val as any).target;
17
+
18
+ if (currentTarget.type === 'checkbox') {
19
+ setValue((currentTarget as any).checked as any);
20
+ } else {
21
+ setValue(currentTarget.value as any);
22
+ }
23
+ } else {
24
+ setValue(val as T);
25
+ }
26
+ };
27
+ }
28
+
29
+ export type UseInputStateReturnValue<T> = [
30
+ T,
31
+ (value: null | undefined | T | React.ChangeEvent<any>) => void,
32
+ ];
33
+
34
+ export function useInputState<T>(initialState: T): UseInputStateReturnValue<T> {
35
+ const [value, setValue] = useState<T>(initialState);
36
+ return [value, getInputOnChange<T>(setValue as any)];
37
+ }
38
+
39
+ export namespace useInputState {
40
+ export type ReturnValue<T> = UseInputStateReturnValue<T>;
41
+ }
@@ -0,0 +1,41 @@
1
+ import { useCallback, useRef, useState } from 'octane';
2
+
3
+ export interface UseIntersectionReturnValue<T> {
4
+ ref: React.RefCallback<T | null>;
5
+ entry: IntersectionObserverEntry | null;
6
+ }
7
+
8
+ export function useIntersection<T extends HTMLElement = any>(
9
+ options?: IntersectionObserverInit,
10
+ ): UseIntersectionReturnValue<T> {
11
+ const [entry, setEntry] = useState<IntersectionObserverEntry | null>(null);
12
+
13
+ const observer = useRef<IntersectionObserver | null>(null);
14
+
15
+ const ref: React.RefCallback<T | null> = useCallback(
16
+ (element) => {
17
+ if (observer.current) {
18
+ observer.current.disconnect();
19
+ observer.current = null;
20
+ }
21
+
22
+ if (element === null) {
23
+ setEntry(null);
24
+ return;
25
+ }
26
+
27
+ observer.current = new IntersectionObserver(([_entry]) => {
28
+ setEntry(_entry);
29
+ }, options);
30
+
31
+ observer.current.observe(element);
32
+ },
33
+ [options?.rootMargin, options?.root, options?.threshold],
34
+ );
35
+
36
+ return { ref, entry };
37
+ }
38
+
39
+ export namespace useIntersection {
40
+ export type ReturnValue<T> = UseIntersectionReturnValue<T>;
41
+ }
@@ -0,0 +1,84 @@
1
+ import { useCallback, useEffect, useRef, useState } from 'octane';
2
+
3
+ export interface UseIntervalOptions {
4
+ /** If set, the interval will start automatically when the component is mounted, `false` by default */
5
+ autoInvoke?: boolean;
6
+ }
7
+
8
+ export interface UseIntervalReturnValue {
9
+ /** Starts the interval */
10
+ start: () => void;
11
+
12
+ /** Stops the interval */
13
+ stop: () => void;
14
+
15
+ /** Toggles the interval */
16
+ toggle: () => void;
17
+
18
+ /** Indicates if the interval is active */
19
+ active: boolean;
20
+ }
21
+
22
+ export function useInterval(
23
+ fn: () => void,
24
+ interval: number,
25
+ { autoInvoke = false }: UseIntervalOptions = {},
26
+ ): UseIntervalReturnValue {
27
+ const [active, setActive] = useState(false);
28
+ const intervalRef = useRef<number | null>(null);
29
+ const fnRef = useRef<(() => void) | null>(null);
30
+ const intervalValueRef = useRef(interval);
31
+ intervalValueRef.current = interval;
32
+
33
+ const start = useCallback(() => {
34
+ setActive((old) => {
35
+ if (!old && !intervalRef.current) {
36
+ intervalRef.current = window.setInterval(fnRef.current!, intervalValueRef.current);
37
+ }
38
+ return true;
39
+ });
40
+ }, []);
41
+
42
+ const stop = useCallback(() => {
43
+ setActive(false);
44
+ if (intervalRef.current) {
45
+ window.clearInterval(intervalRef.current);
46
+ }
47
+ intervalRef.current = null;
48
+ }, []);
49
+
50
+ const toggle = useCallback(() => {
51
+ setActive((current) => {
52
+ if (current) {
53
+ if (intervalRef.current) {
54
+ window.clearInterval(intervalRef.current);
55
+ }
56
+ intervalRef.current = null;
57
+ return false;
58
+ }
59
+ if (!intervalRef.current) {
60
+ intervalRef.current = window.setInterval(fnRef.current!, intervalValueRef.current);
61
+ }
62
+ return true;
63
+ });
64
+ }, []);
65
+
66
+ useEffect(() => {
67
+ fnRef.current = fn;
68
+ active && start();
69
+ return stop;
70
+ }, [fn, active, interval]);
71
+
72
+ useEffect(() => {
73
+ if (autoInvoke) {
74
+ start();
75
+ }
76
+ }, []);
77
+
78
+ return { start, stop, toggle, active };
79
+ }
80
+
81
+ export namespace useInterval {
82
+ export type Options = UseIntervalOptions;
83
+ export type ReturnValue = UseIntervalReturnValue;
84
+ }
@@ -0,0 +1,12 @@
1
+ import { useRef } from 'octane';
2
+
3
+ export function useIsFirstRender() {
4
+ const renderRef = useRef(true);
5
+
6
+ if (renderRef.current === true) {
7
+ renderRef.current = false;
8
+ return true;
9
+ }
10
+
11
+ return renderRef.current;
12
+ }
@@ -0,0 +1,5 @@
1
+ import { useEffect, useLayoutEffect } from 'octane';
2
+
3
+ // UseLayoutEffect will show warning if used during ssr, for example with Next.js
4
+ // UseIsomorphicEffect removes it by replacing useLayoutEffect with useEffect during ssr
5
+ export const useIsomorphicEffect = typeof document !== 'undefined' ? useLayoutEffect : useEffect;