@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,463 @@
|
|
|
1
|
+
// Required to disable for webkit-user-select, although deprecated, it is still required for Safari support
|
|
2
|
+
/* eslint-disable @typescript-eslint/no-deprecated */
|
|
3
|
+
import { useCallback, useRef, useState } from 'octane';
|
|
4
|
+
|
|
5
|
+
type Vector2 = [number, number];
|
|
6
|
+
|
|
7
|
+
export interface UseDragState {
|
|
8
|
+
/** Current pointer position [x, y] */
|
|
9
|
+
xy: Vector2;
|
|
10
|
+
|
|
11
|
+
/** Position where the gesture started [x, y] */
|
|
12
|
+
initial: Vector2;
|
|
13
|
+
|
|
14
|
+
/** Displacement from start [x, y], respects axis constraint */
|
|
15
|
+
movement: Vector2;
|
|
16
|
+
|
|
17
|
+
/** Change since previous event [x, y] */
|
|
18
|
+
delta: Vector2;
|
|
19
|
+
|
|
20
|
+
/** Absolute distance per axis [x, y] */
|
|
21
|
+
distance: Vector2;
|
|
22
|
+
|
|
23
|
+
/** Movement direction per axis: -1, 0, or 1 */
|
|
24
|
+
direction: Vector2;
|
|
25
|
+
|
|
26
|
+
/** Speed per axis in px/ms */
|
|
27
|
+
velocity: Vector2;
|
|
28
|
+
|
|
29
|
+
/** Time since drag started in ms */
|
|
30
|
+
elapsedTime: number;
|
|
31
|
+
|
|
32
|
+
/** `true` on the first handler call after the threshold is met */
|
|
33
|
+
first: boolean;
|
|
34
|
+
|
|
35
|
+
/** `true` on the last handler call (pointer released or canceled) */
|
|
36
|
+
last: boolean;
|
|
37
|
+
|
|
38
|
+
/** `true` while the gesture is ongoing */
|
|
39
|
+
active: boolean;
|
|
40
|
+
|
|
41
|
+
/** `true` when the gesture qualifies as a tap (requires `filterTaps: true`) */
|
|
42
|
+
tap: boolean;
|
|
43
|
+
|
|
44
|
+
/** `true` when the gesture was interrupted by a `pointercancel` event */
|
|
45
|
+
canceled: boolean;
|
|
46
|
+
|
|
47
|
+
/** Function to programmatically cancel the current gesture */
|
|
48
|
+
cancel: () => void;
|
|
49
|
+
|
|
50
|
+
/** The source `PointerEvent` */
|
|
51
|
+
event: PointerEvent;
|
|
52
|
+
}
|
|
53
|
+
|
|
54
|
+
export interface UseDragOptions {
|
|
55
|
+
/** Constrain movement to a specific axis. `'lock'` locks to whichever axis has more movement after `axisThreshold` is exceeded. */
|
|
56
|
+
axis?: 'x' | 'y' | 'lock';
|
|
57
|
+
|
|
58
|
+
/** Movement in px required to determine axis when `axis` is `'lock'`, `1` by default */
|
|
59
|
+
axisThreshold?: number;
|
|
60
|
+
|
|
61
|
+
/** When `true`, the last state includes `tap: true` when total distance is below `tapThreshold`, `false` by default */
|
|
62
|
+
filterTaps?: boolean;
|
|
63
|
+
|
|
64
|
+
/** Max displacement in px to still be considered a tap, `3` by default */
|
|
65
|
+
tapThreshold?: number;
|
|
66
|
+
|
|
67
|
+
/** Minimum displacement in px before the drag activates. Can be a number (both axes) or `[x, y]`. `0` by default */
|
|
68
|
+
threshold?: number | Vector2;
|
|
69
|
+
|
|
70
|
+
/** Enable or disable the hook, `true` by default */
|
|
71
|
+
enabled?: boolean;
|
|
72
|
+
}
|
|
73
|
+
|
|
74
|
+
export interface UseDragReturnValue<T extends HTMLElement = any> {
|
|
75
|
+
/** Ref callback to attach to the draggable element */
|
|
76
|
+
ref: React.RefCallback<T | null>;
|
|
77
|
+
|
|
78
|
+
/** `true` while the element is being dragged */
|
|
79
|
+
active: boolean;
|
|
80
|
+
}
|
|
81
|
+
|
|
82
|
+
const VELOCITY_DECAY_MS = 100;
|
|
83
|
+
|
|
84
|
+
function sign(n: number): -1 | 0 | 1 {
|
|
85
|
+
if (n > 0) {
|
|
86
|
+
return 1;
|
|
87
|
+
}
|
|
88
|
+
if (n < 0) {
|
|
89
|
+
return -1;
|
|
90
|
+
}
|
|
91
|
+
return 0;
|
|
92
|
+
}
|
|
93
|
+
|
|
94
|
+
function getThresholdVector(threshold: number | Vector2 | undefined): Vector2 {
|
|
95
|
+
const t = threshold ?? 0;
|
|
96
|
+
if (typeof t === 'number') {
|
|
97
|
+
return [t, t];
|
|
98
|
+
}
|
|
99
|
+
return t;
|
|
100
|
+
}
|
|
101
|
+
|
|
102
|
+
interface DragInternalState {
|
|
103
|
+
isActive: boolean;
|
|
104
|
+
pointerId: number;
|
|
105
|
+
startXY: Vector2;
|
|
106
|
+
prevXY: Vector2;
|
|
107
|
+
startTimestamp: number;
|
|
108
|
+
prevTimestamp: number;
|
|
109
|
+
thresholdMet: boolean;
|
|
110
|
+
firstFired: boolean;
|
|
111
|
+
lockedAxis: 'x' | 'y' | null;
|
|
112
|
+
canceled: boolean;
|
|
113
|
+
lastVelocity: Vector2;
|
|
114
|
+
lastEvent: PointerEvent | null;
|
|
115
|
+
}
|
|
116
|
+
|
|
117
|
+
function createInitialState(): DragInternalState {
|
|
118
|
+
return {
|
|
119
|
+
isActive: false,
|
|
120
|
+
pointerId: -1,
|
|
121
|
+
startXY: [0, 0],
|
|
122
|
+
prevXY: [0, 0],
|
|
123
|
+
startTimestamp: 0,
|
|
124
|
+
prevTimestamp: 0,
|
|
125
|
+
thresholdMet: false,
|
|
126
|
+
firstFired: false,
|
|
127
|
+
lockedAxis: null,
|
|
128
|
+
canceled: false,
|
|
129
|
+
lastVelocity: [0, 0],
|
|
130
|
+
lastEvent: null,
|
|
131
|
+
};
|
|
132
|
+
}
|
|
133
|
+
|
|
134
|
+
export function useDrag<T extends HTMLElement = any>(
|
|
135
|
+
handler: (state: UseDragState) => void,
|
|
136
|
+
options: UseDragOptions = {},
|
|
137
|
+
): UseDragReturnValue<T> {
|
|
138
|
+
const [active, setActive] = useState(false);
|
|
139
|
+
|
|
140
|
+
const handlerRef = useRef(handler);
|
|
141
|
+
handlerRef.current = handler;
|
|
142
|
+
|
|
143
|
+
const optionsRef = useRef(options);
|
|
144
|
+
optionsRef.current = options;
|
|
145
|
+
|
|
146
|
+
const stateRef = useRef<DragInternalState>(createInitialState());
|
|
147
|
+
const documentControllerRef = useRef<AbortController | null>(null);
|
|
148
|
+
|
|
149
|
+
const refCallback: React.RefCallback<T | null> = useCallback((node) => {
|
|
150
|
+
if (!node) {
|
|
151
|
+
return undefined;
|
|
152
|
+
}
|
|
153
|
+
|
|
154
|
+
const elementController = new AbortController();
|
|
155
|
+
|
|
156
|
+
const applyAxisConstraint = (v: Vector2): Vector2 => {
|
|
157
|
+
const opts = optionsRef.current;
|
|
158
|
+
const s = stateRef.current;
|
|
159
|
+
|
|
160
|
+
if (opts.axis === 'x') {
|
|
161
|
+
return [v[0], 0];
|
|
162
|
+
}
|
|
163
|
+
if (opts.axis === 'y') {
|
|
164
|
+
return [0, v[1]];
|
|
165
|
+
}
|
|
166
|
+
if (opts.axis === 'lock') {
|
|
167
|
+
if (s.lockedAxis === null) {
|
|
168
|
+
const t = opts.axisThreshold ?? 1;
|
|
169
|
+
if (Math.abs(v[0]) > t || Math.abs(v[1]) > t) {
|
|
170
|
+
s.lockedAxis = Math.abs(v[0]) >= Math.abs(v[1]) ? 'x' : 'y';
|
|
171
|
+
}
|
|
172
|
+
}
|
|
173
|
+
if (s.lockedAxis === 'x') {
|
|
174
|
+
return [v[0], 0];
|
|
175
|
+
}
|
|
176
|
+
if (s.lockedAxis === 'y') {
|
|
177
|
+
return [0, v[1]];
|
|
178
|
+
}
|
|
179
|
+
}
|
|
180
|
+
return v;
|
|
181
|
+
};
|
|
182
|
+
|
|
183
|
+
const resetDrag = () => {
|
|
184
|
+
const s = stateRef.current;
|
|
185
|
+
s.isActive = false;
|
|
186
|
+
s.pointerId = -1;
|
|
187
|
+
s.thresholdMet = false;
|
|
188
|
+
s.firstFired = false;
|
|
189
|
+
s.lockedAxis = null;
|
|
190
|
+
s.canceled = false;
|
|
191
|
+
s.lastEvent = null;
|
|
192
|
+
setActive(false);
|
|
193
|
+
document.body.style.userSelect = '';
|
|
194
|
+
document.body.style.webkitUserSelect = '';
|
|
195
|
+
documentControllerRef.current?.abort();
|
|
196
|
+
documentControllerRef.current = null;
|
|
197
|
+
};
|
|
198
|
+
|
|
199
|
+
const cancel = () => {
|
|
200
|
+
const s = stateRef.current;
|
|
201
|
+
if (s.isActive && s.lastEvent) {
|
|
202
|
+
emitCanceled(s.lastEvent);
|
|
203
|
+
}
|
|
204
|
+
};
|
|
205
|
+
|
|
206
|
+
const activateDrag = () => {
|
|
207
|
+
setActive(true);
|
|
208
|
+
document.body.style.userSelect = 'none';
|
|
209
|
+
document.body.style.webkitUserSelect = 'none';
|
|
210
|
+
};
|
|
211
|
+
|
|
212
|
+
const onPointerDown = (event: PointerEvent) => {
|
|
213
|
+
if (optionsRef.current.enabled === false) {
|
|
214
|
+
return;
|
|
215
|
+
}
|
|
216
|
+
if (event.button !== 0) {
|
|
217
|
+
return;
|
|
218
|
+
}
|
|
219
|
+
if (stateRef.current.isActive) {
|
|
220
|
+
return;
|
|
221
|
+
}
|
|
222
|
+
|
|
223
|
+
const s = stateRef.current;
|
|
224
|
+
s.isActive = true;
|
|
225
|
+
s.pointerId = event.pointerId;
|
|
226
|
+
s.startXY = [event.clientX, event.clientY];
|
|
227
|
+
s.prevXY = [event.clientX, event.clientY];
|
|
228
|
+
s.startTimestamp = event.timeStamp;
|
|
229
|
+
s.prevTimestamp = event.timeStamp;
|
|
230
|
+
s.thresholdMet = false;
|
|
231
|
+
s.firstFired = false;
|
|
232
|
+
s.lockedAxis = null;
|
|
233
|
+
s.canceled = false;
|
|
234
|
+
s.lastVelocity = [0, 0];
|
|
235
|
+
s.lastEvent = event;
|
|
236
|
+
|
|
237
|
+
const [tx, ty] = getThresholdVector(optionsRef.current.threshold);
|
|
238
|
+
if (tx === 0 && ty === 0) {
|
|
239
|
+
s.thresholdMet = true;
|
|
240
|
+
s.firstFired = true;
|
|
241
|
+
activateDrag();
|
|
242
|
+
|
|
243
|
+
handlerRef.current({
|
|
244
|
+
xy: [event.clientX, event.clientY],
|
|
245
|
+
initial: [event.clientX, event.clientY],
|
|
246
|
+
movement: [0, 0],
|
|
247
|
+
delta: [0, 0],
|
|
248
|
+
distance: [0, 0],
|
|
249
|
+
direction: [0, 0],
|
|
250
|
+
velocity: [0, 0],
|
|
251
|
+
elapsedTime: 0,
|
|
252
|
+
first: true,
|
|
253
|
+
last: false,
|
|
254
|
+
active: true,
|
|
255
|
+
tap: false,
|
|
256
|
+
canceled: false,
|
|
257
|
+
cancel,
|
|
258
|
+
event,
|
|
259
|
+
});
|
|
260
|
+
if (!s.isActive) {
|
|
261
|
+
return;
|
|
262
|
+
}
|
|
263
|
+
}
|
|
264
|
+
|
|
265
|
+
documentControllerRef.current?.abort();
|
|
266
|
+
documentControllerRef.current = new AbortController();
|
|
267
|
+
const sig = documentControllerRef.current.signal;
|
|
268
|
+
|
|
269
|
+
document.addEventListener('pointermove', onPointerMove, { signal: sig });
|
|
270
|
+
document.addEventListener('pointerup', onPointerUp, { signal: sig });
|
|
271
|
+
document.addEventListener('pointercancel', onPointerCancel, { signal: sig });
|
|
272
|
+
};
|
|
273
|
+
|
|
274
|
+
const onPointerMove = (event: PointerEvent) => {
|
|
275
|
+
const s = stateRef.current;
|
|
276
|
+
if (!s.isActive || event.pointerId !== s.pointerId) {
|
|
277
|
+
return;
|
|
278
|
+
}
|
|
279
|
+
s.lastEvent = event;
|
|
280
|
+
|
|
281
|
+
const rawMovement: Vector2 = [event.clientX - s.startXY[0], event.clientY - s.startXY[1]];
|
|
282
|
+
|
|
283
|
+
if (!s.thresholdMet) {
|
|
284
|
+
const [tx, ty] = getThresholdVector(optionsRef.current.threshold);
|
|
285
|
+
if (Math.abs(rawMovement[0]) < tx && Math.abs(rawMovement[1]) < ty) {
|
|
286
|
+
s.prevXY = [event.clientX, event.clientY];
|
|
287
|
+
s.prevTimestamp = event.timeStamp;
|
|
288
|
+
return;
|
|
289
|
+
}
|
|
290
|
+
s.thresholdMet = true;
|
|
291
|
+
activateDrag();
|
|
292
|
+
}
|
|
293
|
+
|
|
294
|
+
const movement = applyAxisConstraint(rawMovement);
|
|
295
|
+
const rawDelta: Vector2 = [event.clientX - s.prevXY[0], event.clientY - s.prevXY[1]];
|
|
296
|
+
const delta = applyAxisConstraint(rawDelta);
|
|
297
|
+
const timeDelta = event.timeStamp - s.prevTimestamp;
|
|
298
|
+
const velocity: Vector2 =
|
|
299
|
+
timeDelta > 0
|
|
300
|
+
? [Math.abs(delta[0]) / timeDelta, Math.abs(delta[1]) / timeDelta]
|
|
301
|
+
: s.lastVelocity;
|
|
302
|
+
|
|
303
|
+
s.lastVelocity = velocity;
|
|
304
|
+
const isFirst = !s.firstFired;
|
|
305
|
+
s.firstFired = true;
|
|
306
|
+
s.prevXY = [event.clientX, event.clientY];
|
|
307
|
+
s.prevTimestamp = event.timeStamp;
|
|
308
|
+
|
|
309
|
+
handlerRef.current({
|
|
310
|
+
xy: [event.clientX, event.clientY],
|
|
311
|
+
initial: [...s.startXY],
|
|
312
|
+
movement,
|
|
313
|
+
delta,
|
|
314
|
+
distance: [Math.abs(movement[0]), Math.abs(movement[1])],
|
|
315
|
+
direction: [sign(delta[0]), sign(delta[1])],
|
|
316
|
+
velocity,
|
|
317
|
+
elapsedTime: event.timeStamp - s.startTimestamp,
|
|
318
|
+
first: isFirst,
|
|
319
|
+
last: false,
|
|
320
|
+
active: true,
|
|
321
|
+
tap: false,
|
|
322
|
+
canceled: false,
|
|
323
|
+
cancel,
|
|
324
|
+
event,
|
|
325
|
+
});
|
|
326
|
+
};
|
|
327
|
+
|
|
328
|
+
const onPointerUp = (event: PointerEvent) => {
|
|
329
|
+
const s = stateRef.current;
|
|
330
|
+
if (!s.isActive || event.pointerId !== s.pointerId) {
|
|
331
|
+
return;
|
|
332
|
+
}
|
|
333
|
+
|
|
334
|
+
const opts = optionsRef.current;
|
|
335
|
+
|
|
336
|
+
if (!s.thresholdMet) {
|
|
337
|
+
if (opts.filterTaps) {
|
|
338
|
+
const rawMov: Vector2 = [event.clientX - s.startXY[0], event.clientY - s.startXY[1]];
|
|
339
|
+
const mov = applyAxisConstraint(rawMov);
|
|
340
|
+
const dist: Vector2 = [Math.abs(mov[0]), Math.abs(mov[1])];
|
|
341
|
+
const maxDist = Math.max(dist[0], dist[1]);
|
|
342
|
+
const isTap = maxDist < (opts.tapThreshold ?? 3);
|
|
343
|
+
s.isActive = false;
|
|
344
|
+
|
|
345
|
+
handlerRef.current({
|
|
346
|
+
xy: [event.clientX, event.clientY],
|
|
347
|
+
initial: [...s.startXY],
|
|
348
|
+
movement: mov,
|
|
349
|
+
delta: mov,
|
|
350
|
+
distance: dist,
|
|
351
|
+
direction: [sign(mov[0]), sign(mov[1])],
|
|
352
|
+
velocity: [0, 0],
|
|
353
|
+
elapsedTime: event.timeStamp - s.startTimestamp,
|
|
354
|
+
first: true,
|
|
355
|
+
last: true,
|
|
356
|
+
active: false,
|
|
357
|
+
tap: isTap,
|
|
358
|
+
canceled: false,
|
|
359
|
+
cancel,
|
|
360
|
+
event,
|
|
361
|
+
});
|
|
362
|
+
}
|
|
363
|
+
resetDrag();
|
|
364
|
+
return;
|
|
365
|
+
}
|
|
366
|
+
|
|
367
|
+
const rawMovement: Vector2 = [event.clientX - s.startXY[0], event.clientY - s.startXY[1]];
|
|
368
|
+
const movement = applyAxisConstraint(rawMovement);
|
|
369
|
+
const distance: Vector2 = [Math.abs(movement[0]), Math.abs(movement[1])];
|
|
370
|
+
const rawDelta: Vector2 = [event.clientX - s.prevXY[0], event.clientY - s.prevXY[1]];
|
|
371
|
+
const delta = applyAxisConstraint(rawDelta);
|
|
372
|
+
|
|
373
|
+
const timeSinceLastMove = event.timeStamp - s.prevTimestamp;
|
|
374
|
+
const velocity: Vector2 = timeSinceLastMove > VELOCITY_DECAY_MS ? [0, 0] : s.lastVelocity;
|
|
375
|
+
|
|
376
|
+
const maxDistance = Math.max(distance[0], distance[1]);
|
|
377
|
+
const tap = opts.filterTaps === true && maxDistance < (opts.tapThreshold ?? 3);
|
|
378
|
+
s.isActive = false;
|
|
379
|
+
|
|
380
|
+
handlerRef.current({
|
|
381
|
+
xy: [event.clientX, event.clientY],
|
|
382
|
+
initial: [...s.startXY],
|
|
383
|
+
movement,
|
|
384
|
+
delta,
|
|
385
|
+
distance,
|
|
386
|
+
direction: [sign(delta[0]), sign(delta[1])],
|
|
387
|
+
velocity,
|
|
388
|
+
elapsedTime: event.timeStamp - s.startTimestamp,
|
|
389
|
+
first: !s.firstFired,
|
|
390
|
+
last: true,
|
|
391
|
+
active: false,
|
|
392
|
+
tap,
|
|
393
|
+
canceled: false,
|
|
394
|
+
cancel,
|
|
395
|
+
event,
|
|
396
|
+
});
|
|
397
|
+
|
|
398
|
+
resetDrag();
|
|
399
|
+
};
|
|
400
|
+
|
|
401
|
+
const emitCanceled = (event: PointerEvent) => {
|
|
402
|
+
const s = stateRef.current;
|
|
403
|
+
const rawMovement: Vector2 = [event.clientX - s.startXY[0], event.clientY - s.startXY[1]];
|
|
404
|
+
const movement = applyAxisConstraint(rawMovement);
|
|
405
|
+
// Mark the gesture inactive before notifying the consumer so calling
|
|
406
|
+
// cancel() from the terminal update cannot recursively cancel again.
|
|
407
|
+
s.isActive = false;
|
|
408
|
+
|
|
409
|
+
handlerRef.current({
|
|
410
|
+
xy: [event.clientX, event.clientY],
|
|
411
|
+
initial: [...s.startXY],
|
|
412
|
+
movement,
|
|
413
|
+
delta: [0, 0],
|
|
414
|
+
distance: [Math.abs(movement[0]), Math.abs(movement[1])],
|
|
415
|
+
direction: [0, 0],
|
|
416
|
+
velocity: [0, 0],
|
|
417
|
+
elapsedTime: event.timeStamp - s.startTimestamp,
|
|
418
|
+
first: !s.firstFired,
|
|
419
|
+
last: true,
|
|
420
|
+
active: false,
|
|
421
|
+
tap: false,
|
|
422
|
+
canceled: true,
|
|
423
|
+
cancel,
|
|
424
|
+
event,
|
|
425
|
+
});
|
|
426
|
+
|
|
427
|
+
resetDrag();
|
|
428
|
+
};
|
|
429
|
+
|
|
430
|
+
const onPointerCancel = (event: PointerEvent) => {
|
|
431
|
+
const s = stateRef.current;
|
|
432
|
+
if (!s.isActive || event.pointerId !== s.pointerId) {
|
|
433
|
+
return;
|
|
434
|
+
}
|
|
435
|
+
s.lastEvent = event;
|
|
436
|
+
emitCanceled(event);
|
|
437
|
+
};
|
|
438
|
+
|
|
439
|
+
node.addEventListener('pointerdown', onPointerDown, {
|
|
440
|
+
signal: elementController.signal,
|
|
441
|
+
});
|
|
442
|
+
|
|
443
|
+
return () => {
|
|
444
|
+
elementController.abort();
|
|
445
|
+
documentControllerRef.current?.abort();
|
|
446
|
+
documentControllerRef.current = null;
|
|
447
|
+
if (stateRef.current.isActive) {
|
|
448
|
+
stateRef.current.isActive = false;
|
|
449
|
+
setActive(false);
|
|
450
|
+
document.body.style.userSelect = '';
|
|
451
|
+
document.body.style.webkitUserSelect = '';
|
|
452
|
+
}
|
|
453
|
+
};
|
|
454
|
+
}, []);
|
|
455
|
+
|
|
456
|
+
return { ref: refCallback, active };
|
|
457
|
+
}
|
|
458
|
+
|
|
459
|
+
export namespace useDrag {
|
|
460
|
+
export type State = UseDragState;
|
|
461
|
+
export type Options = UseDragOptions;
|
|
462
|
+
export type ReturnValue<T extends HTMLElement = any> = UseDragReturnValue<T>;
|
|
463
|
+
}
|
|
@@ -0,0 +1,47 @@
|
|
|
1
|
+
import { useCallback, useEffect, useRef } from 'octane';
|
|
2
|
+
|
|
3
|
+
export function useEventListener<K extends keyof HTMLElementEventMap, T extends HTMLElement = any>(
|
|
4
|
+
type: K,
|
|
5
|
+
listener: (this: T, ev: HTMLElementEventMap[K]) => any,
|
|
6
|
+
options?: boolean | AddEventListenerOptions,
|
|
7
|
+
): React.RefCallback<T | null> {
|
|
8
|
+
const attachment = useRef<{
|
|
9
|
+
node: T;
|
|
10
|
+
type: K;
|
|
11
|
+
listener: (this: T, ev: HTMLElementEventMap[K]) => any;
|
|
12
|
+
options?: boolean | AddEventListenerOptions;
|
|
13
|
+
} | null>(null);
|
|
14
|
+
|
|
15
|
+
const detach = useCallback(() => {
|
|
16
|
+
const current = attachment.current;
|
|
17
|
+
if (current) {
|
|
18
|
+
current.node.removeEventListener(current.type, current.listener as any, current.options);
|
|
19
|
+
attachment.current = null;
|
|
20
|
+
}
|
|
21
|
+
}, []);
|
|
22
|
+
|
|
23
|
+
const callbackRef: React.RefCallback<T | null> = useCallback(
|
|
24
|
+
(node) => {
|
|
25
|
+
detach();
|
|
26
|
+
if (!node) {
|
|
27
|
+
return undefined;
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
node.addEventListener(type, listener as any, options);
|
|
31
|
+
const current = { node, type, listener, options };
|
|
32
|
+
attachment.current = current;
|
|
33
|
+
|
|
34
|
+
return () => {
|
|
35
|
+
// A stale ref cleanup must not detach a replacement node.
|
|
36
|
+
if (attachment.current === current) {
|
|
37
|
+
detach();
|
|
38
|
+
}
|
|
39
|
+
};
|
|
40
|
+
},
|
|
41
|
+
[type, listener, options, detach],
|
|
42
|
+
);
|
|
43
|
+
|
|
44
|
+
useEffect(() => () => detach(), [detach]);
|
|
45
|
+
|
|
46
|
+
return callbackRef;
|
|
47
|
+
}
|
|
@@ -0,0 +1,41 @@
|
|
|
1
|
+
import { useCallback, useState } from 'octane';
|
|
2
|
+
import { useIsomorphicEffect } from '../use-isomorphic-effect/use-isomorphic-effect';
|
|
3
|
+
|
|
4
|
+
export interface EyeDropperOpenOptions {
|
|
5
|
+
signal?: AbortSignal;
|
|
6
|
+
}
|
|
7
|
+
|
|
8
|
+
export interface EyeDropperOpenReturnType {
|
|
9
|
+
sRGBHex: string;
|
|
10
|
+
}
|
|
11
|
+
|
|
12
|
+
export interface UseEyeDropperReturnValue {
|
|
13
|
+
supported: boolean;
|
|
14
|
+
open: (options?: EyeDropperOpenOptions) => Promise<EyeDropperOpenReturnType | undefined>;
|
|
15
|
+
}
|
|
16
|
+
|
|
17
|
+
export function useEyeDropper(): UseEyeDropperReturnValue {
|
|
18
|
+
const [supported, setSupported] = useState(false);
|
|
19
|
+
|
|
20
|
+
useIsomorphicEffect(() => {
|
|
21
|
+
setSupported(typeof window !== 'undefined' && !isOpera() && 'EyeDropper' in window);
|
|
22
|
+
}, []);
|
|
23
|
+
|
|
24
|
+
const open = useCallback(
|
|
25
|
+
(options: EyeDropperOpenOptions = {}): Promise<EyeDropperOpenReturnType | undefined> => {
|
|
26
|
+
if (supported) {
|
|
27
|
+
const eyeDropper = new (window as any).EyeDropper();
|
|
28
|
+
return eyeDropper.open(options);
|
|
29
|
+
}
|
|
30
|
+
|
|
31
|
+
return Promise.resolve(undefined);
|
|
32
|
+
},
|
|
33
|
+
[supported],
|
|
34
|
+
);
|
|
35
|
+
|
|
36
|
+
return { supported, open };
|
|
37
|
+
}
|
|
38
|
+
|
|
39
|
+
function isOpera() {
|
|
40
|
+
return navigator.userAgent.includes('OPR');
|
|
41
|
+
}
|
|
@@ -0,0 +1,41 @@
|
|
|
1
|
+
import { useRef } from 'octane';
|
|
2
|
+
import { useIsomorphicEffect } from '../use-isomorphic-effect/use-isomorphic-effect';
|
|
3
|
+
|
|
4
|
+
const MIME_TYPES: Record<string, string> = {
|
|
5
|
+
ico: 'image/x-icon',
|
|
6
|
+
png: 'image/png',
|
|
7
|
+
svg: 'image/svg+xml',
|
|
8
|
+
gif: 'image/gif',
|
|
9
|
+
};
|
|
10
|
+
|
|
11
|
+
export function useFavicon(url: string) {
|
|
12
|
+
const link = useRef<HTMLLinkElement | null>(null);
|
|
13
|
+
|
|
14
|
+
useIsomorphicEffect(() => {
|
|
15
|
+
if (!url) {
|
|
16
|
+
return;
|
|
17
|
+
}
|
|
18
|
+
|
|
19
|
+
if (!link.current) {
|
|
20
|
+
const existingElements = document.querySelectorAll<HTMLLinkElement>('link[rel*="icon"]');
|
|
21
|
+
existingElements.forEach((element) => document.head.removeChild(element));
|
|
22
|
+
|
|
23
|
+
const element = document.createElement('link');
|
|
24
|
+
element.rel = 'shortcut icon';
|
|
25
|
+
link.current = element;
|
|
26
|
+
document.querySelector('head')!.appendChild(element);
|
|
27
|
+
}
|
|
28
|
+
|
|
29
|
+
const splittedUrl = url.split('.');
|
|
30
|
+
const extension = splittedUrl[splittedUrl.length - 1].toLowerCase();
|
|
31
|
+
const mimeType = MIME_TYPES[extension];
|
|
32
|
+
|
|
33
|
+
if (mimeType) {
|
|
34
|
+
link.current.setAttribute('type', mimeType);
|
|
35
|
+
} else {
|
|
36
|
+
link.current.removeAttribute('type');
|
|
37
|
+
}
|
|
38
|
+
|
|
39
|
+
link.current.setAttribute('href', url);
|
|
40
|
+
}, [url]);
|
|
41
|
+
}
|
|
@@ -0,0 +1,85 @@
|
|
|
1
|
+
import { useCallback, useEffect, useRef, useState } from 'octane';
|
|
2
|
+
|
|
3
|
+
export interface UseFetchOptions extends RequestInit {
|
|
4
|
+
autoInvoke?: boolean;
|
|
5
|
+
}
|
|
6
|
+
|
|
7
|
+
export interface UseFetchReturnValue<T> {
|
|
8
|
+
data: T | null;
|
|
9
|
+
loading: boolean;
|
|
10
|
+
error: Error | null;
|
|
11
|
+
refetch: () => Promise<any>;
|
|
12
|
+
abort: () => void;
|
|
13
|
+
}
|
|
14
|
+
|
|
15
|
+
export function useFetch<T>(
|
|
16
|
+
url: string,
|
|
17
|
+
{ autoInvoke = true, ...options }: UseFetchOptions = {},
|
|
18
|
+
): UseFetchReturnValue<T> {
|
|
19
|
+
const [data, setData] = useState<T | null>(null);
|
|
20
|
+
const [loading, setLoading] = useState(false);
|
|
21
|
+
const [error, setError] = useState<Error | null>(null);
|
|
22
|
+
const controller = useRef<AbortController | null>(null);
|
|
23
|
+
|
|
24
|
+
const refetch = useCallback(() => {
|
|
25
|
+
if (controller.current) {
|
|
26
|
+
controller.current.abort();
|
|
27
|
+
}
|
|
28
|
+
|
|
29
|
+
const request = new AbortController();
|
|
30
|
+
controller.current = request;
|
|
31
|
+
|
|
32
|
+
setLoading(true);
|
|
33
|
+
setError(null);
|
|
34
|
+
|
|
35
|
+
return fetch(url, { ...options, signal: request.signal })
|
|
36
|
+
.then((res) => {
|
|
37
|
+
if (!res.ok) {
|
|
38
|
+
throw new Error(`Request failed with status ${res.status}`);
|
|
39
|
+
}
|
|
40
|
+
return res.json();
|
|
41
|
+
})
|
|
42
|
+
.then((res) => {
|
|
43
|
+
if (controller.current === request) {
|
|
44
|
+
setData(res);
|
|
45
|
+
setLoading(false);
|
|
46
|
+
}
|
|
47
|
+
return res as T;
|
|
48
|
+
})
|
|
49
|
+
.catch((err) => {
|
|
50
|
+
if (controller.current === request) {
|
|
51
|
+
setLoading(false);
|
|
52
|
+
if (err.name !== 'AbortError') {
|
|
53
|
+
setError(err);
|
|
54
|
+
}
|
|
55
|
+
}
|
|
56
|
+
|
|
57
|
+
return err;
|
|
58
|
+
});
|
|
59
|
+
}, [url, JSON.stringify(options)]);
|
|
60
|
+
|
|
61
|
+
const abort = useCallback(() => {
|
|
62
|
+
if (controller.current) {
|
|
63
|
+
controller.current?.abort('');
|
|
64
|
+
}
|
|
65
|
+
}, []);
|
|
66
|
+
|
|
67
|
+
useEffect(() => {
|
|
68
|
+
if (autoInvoke) {
|
|
69
|
+
refetch();
|
|
70
|
+
}
|
|
71
|
+
|
|
72
|
+
return () => {
|
|
73
|
+
if (controller.current) {
|
|
74
|
+
controller.current.abort('');
|
|
75
|
+
}
|
|
76
|
+
};
|
|
77
|
+
}, [refetch, autoInvoke]);
|
|
78
|
+
|
|
79
|
+
return { data, loading, error, refetch, abort };
|
|
80
|
+
}
|
|
81
|
+
|
|
82
|
+
export namespace useFetch {
|
|
83
|
+
export type Options = UseFetchOptions;
|
|
84
|
+
export type ReturnValue<T> = UseFetchReturnValue<T>;
|
|
85
|
+
}
|