@barqjs/aria 0.0.0-stage → 0.2.0-next.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 (76) hide show
  1. package/LICENSE +21 -0
  2. package/README.md +293 -2
  3. package/package.json +347 -4
  4. package/src/breadcrumbs.tsx +296 -0
  5. package/src/button.tsx +342 -0
  6. package/src/calendar.tsx +1389 -0
  7. package/src/checkbox.tsx +570 -0
  8. package/src/collections.ts +976 -0
  9. package/src/color.ts +562 -0
  10. package/src/colorpicker.tsx +1478 -0
  11. package/src/combobox.tsx +2481 -0
  12. package/src/command.tsx +1184 -0
  13. package/src/date.ts +652 -0
  14. package/src/datefield.tsx +951 -0
  15. package/src/datepicker.tsx +556 -0
  16. package/src/dialog.tsx +890 -0
  17. package/src/disclosure.tsx +659 -0
  18. package/src/dom.ts +706 -0
  19. package/src/drawer.ts +674 -0
  20. package/src/focus.ts +1370 -0
  21. package/src/form.tsx +94 -0
  22. package/src/gridlist.tsx +563 -0
  23. package/src/i18n.ts +823 -0
  24. package/src/index.ts +1270 -0
  25. package/src/interactions/description.ts +73 -0
  26. package/src/interactions/flags.ts +35 -0
  27. package/src/interactions/focus-events.ts +218 -0
  28. package/src/interactions/focusable.ts +86 -0
  29. package/src/interactions/hover.ts +213 -0
  30. package/src/interactions/interact-outside.ts +123 -0
  31. package/src/interactions/keyboard.ts +105 -0
  32. package/src/interactions/listeners.ts +78 -0
  33. package/src/interactions/long-press.ts +160 -0
  34. package/src/interactions/modality.ts +416 -0
  35. package/src/interactions/move.ts +257 -0
  36. package/src/interactions/open-link.ts +193 -0
  37. package/src/interactions/press.ts +898 -0
  38. package/src/interactions/prevent-focus.ts +102 -0
  39. package/src/interactions/scroll-wheel.ts +43 -0
  40. package/src/interactions/text-selection.ts +77 -0
  41. package/src/interactions.ts +81 -0
  42. package/src/label.ts +128 -0
  43. package/src/link.tsx +381 -0
  44. package/src/listbox.tsx +721 -0
  45. package/src/live.ts +204 -0
  46. package/src/menu.tsx +2290 -0
  47. package/src/menubar.tsx +575 -0
  48. package/src/navigation.ts +735 -0
  49. package/src/numberfield.tsx +838 -0
  50. package/src/otp.ts +430 -0
  51. package/src/overlays.ts +1247 -0
  52. package/src/platform.ts +74 -0
  53. package/src/presence.ts +164 -0
  54. package/src/questionnaire.tsx +1712 -0
  55. package/src/radio.tsx +567 -0
  56. package/src/register-dom.ts +12 -0
  57. package/src/scroller.ts +1165 -0
  58. package/src/select.tsx +1665 -0
  59. package/src/selection.ts +1415 -0
  60. package/src/slider.tsx +1042 -0
  61. package/src/splitter.ts +1152 -0
  62. package/src/static-collection.ts +211 -0
  63. package/src/switch.tsx +186 -0
  64. package/src/table.tsx +0 -0
  65. package/src/tabs.tsx +1018 -0
  66. package/src/tag.tsx +452 -0
  67. package/src/textfield.tsx +417 -0
  68. package/src/toast.ts +658 -0
  69. package/src/toggle-input.tsx +48 -0
  70. package/src/toggle.ts +321 -0
  71. package/src/togglegroup.ts +365 -0
  72. package/src/toolbar.tsx +179 -0
  73. package/src/tooltip.tsx +657 -0
  74. package/src/utils.ts +758 -0
  75. package/src/validation.ts +447 -0
  76. package/src/virtualizer.tsx +674 -0
@@ -0,0 +1,898 @@
1
+ /**
2
+ * A press, across mouse, touch, pen, keyboard and screen reader.
3
+ *
4
+ * `onClick` is not this. A click fires for a keyboard activation on a `button`
5
+ * and for nothing else, so a `div` with `role="button"` gets no keyboard
6
+ * support; it fires after the pointer is released with no event for the press
7
+ * beginning, so nothing can show a pressed state; it fires on a drag that
8
+ * started elsewhere and ended over the element; and on touch it arrives up to
9
+ * 300ms late, after the browser has decided the tap was not a double tap.
10
+ *
11
+ * What is here is the set of behaviours a native button has and a click
12
+ * handler does not:
13
+ *
14
+ * - Enter and Space activate, with the platform's own rules about which one a
15
+ * link, a checkbox or a text field should ignore.
16
+ * - The press ends when the pointer leaves and resumes when it returns, so a
17
+ * press begun by accident can be abandoned by sliding off.
18
+ * - A press cancelled by a scroll, a drag or a `pointercancel` fires no press.
19
+ * - Text selection is suppressed for the duration on the platforms that would
20
+ * otherwise start one.
21
+ * - Focus can be kept where it is without `preventDefault()` cancelling the
22
+ * drag and selection behaviour that call would also cancel.
23
+ */
24
+
25
+ import { type Accessor, createEffect, createSignal } from "@barqjs/core";
26
+ import { isServer } from "@barqjs/web";
27
+ import { tryCleanup } from "@barqjs/primitives/utils";
28
+ import {
29
+ contains,
30
+ focusWithoutScrolling,
31
+ isStyledElement,
32
+ ownerDocument,
33
+ ownerWindow,
34
+ targetElement,
35
+ } from "../dom.ts";
36
+ import { isMac } from "../platform.ts";
37
+ import { access, type DOMProps, type MaybeAccessor } from "../utils.ts";
38
+ import { isOpeningLink } from "./flags.ts";
39
+ import { globalListeners } from "./listeners.ts";
40
+ import { isVirtualClick, isVirtualPointerEvent, type PointerType } from "./modality.ts";
41
+ import { openLink } from "./open-link.ts";
42
+ import { preventFocus } from "./prevent-focus.ts";
43
+ import { disableTextSelection, restoreTextSelection } from "./text-selection.ts";
44
+
45
+ /** The element a hook needs, as a value or an accessor. */
46
+ export type ElementRef<T extends Element = Element> = MaybeAccessor<T | null | undefined>;
47
+
48
+ export interface PressEvent {
49
+ type: "pressstart" | "pressend" | "pressup" | "press";
50
+ /** What produced the press. */
51
+ pointerType: PointerType;
52
+ /** The element the press handler is bound to. */
53
+ target: Element;
54
+ shiftKey: boolean;
55
+ ctrlKey: boolean;
56
+ metaKey: boolean;
57
+ altKey: boolean;
58
+ /** Where the press landed, relative to the target's top-left corner. */
59
+ x: number;
60
+ y: number;
61
+ /** The key, for a keyboard press. */
62
+ key?: string | undefined;
63
+ /**
64
+ * Let the event keep bubbling.
65
+ *
66
+ * A press stops propagation by default, so a pressable row inside a
67
+ * pressable list activates one of the two rather than both.
68
+ */
69
+ continuePropagation(): void;
70
+ }
71
+
72
+ interface EventLike {
73
+ currentTarget: EventTarget | null;
74
+ shiftKey: boolean;
75
+ ctrlKey: boolean;
76
+ metaKey: boolean;
77
+ altKey: boolean;
78
+ clientX?: number | undefined;
79
+ clientY?: number | undefined;
80
+ key?: string | undefined;
81
+ }
82
+
83
+ class Press implements PressEvent {
84
+ type: PressEvent["type"];
85
+ pointerType: PointerType;
86
+ target: Element;
87
+ shiftKey: boolean;
88
+ ctrlKey: boolean;
89
+ metaKey: boolean;
90
+ altKey: boolean;
91
+ x: number;
92
+ y: number;
93
+ key: string | undefined;
94
+ #stopPropagation = true;
95
+
96
+ constructor(
97
+ type: PressEvent["type"],
98
+ pointerType: PointerType,
99
+ original: EventLike,
100
+ target?: Element | null,
101
+ ) {
102
+ const element = (target ?? original.currentTarget) as Element | null;
103
+ const rect = element?.getBoundingClientRect();
104
+ let x = 0;
105
+ let y = 0;
106
+ if (rect !== undefined) {
107
+ if (original.clientX !== undefined && original.clientY !== undefined) {
108
+ x = original.clientX - rect.left;
109
+ y = original.clientY - rect.top;
110
+ } else {
111
+ x = rect.width / 2;
112
+ y = rect.height / 2;
113
+ }
114
+ }
115
+
116
+ this.type = type;
117
+ this.pointerType = pointerType;
118
+ this.target = original.currentTarget as Element;
119
+ this.shiftKey = original.shiftKey;
120
+ this.metaKey = original.metaKey;
121
+ this.ctrlKey = original.ctrlKey;
122
+ this.altKey = original.altKey;
123
+ this.x = x;
124
+ this.y = y;
125
+ this.key = original.key;
126
+ }
127
+
128
+ continuePropagation(): void {
129
+ this.#stopPropagation = false;
130
+ }
131
+
132
+ get shouldStopPropagation(): boolean {
133
+ return this.#stopPropagation;
134
+ }
135
+ }
136
+
137
+ export interface PressOptions {
138
+ /** The element the press is bound to. Needed only for the touch-action style. */
139
+ ref?: ElementRef;
140
+ /** Whether the press should be inert. */
141
+ isDisabled?: MaybeAccessor<boolean | undefined>;
142
+ /** Force the pressed state on, for a trigger whose overlay is open. */
143
+ isPressed?: MaybeAccessor<boolean | undefined>;
144
+ /** Keep focus where it is when the element is pressed. */
145
+ preventFocusOnPress?: MaybeAccessor<boolean | undefined>;
146
+ /**
147
+ * End the press for good when the pointer leaves, rather than resuming it if
148
+ * the pointer comes back.
149
+ */
150
+ shouldCancelOnPointerExit?: MaybeAccessor<boolean | undefined>;
151
+ /** Allow the platform's own text selection during the press. */
152
+ allowTextSelectionOnPress?: MaybeAccessor<boolean | undefined>;
153
+ onPress?: (event: PressEvent) => void;
154
+ onPressStart?: (event: PressEvent) => void;
155
+ onPressEnd?: (event: PressEvent) => void;
156
+ onPressUp?: (event: PressEvent) => void;
157
+ onPressChange?: (isPressed: boolean) => void;
158
+ /**
159
+ * The native click, for interoperability.
160
+ *
161
+ * Fired for a real click and synthesised for a keyboard or touch activation,
162
+ * which is what the platform does for a `button`.
163
+ */
164
+ onClick?: (event: MouseEvent) => void;
165
+ }
166
+
167
+ export interface PressResult {
168
+ /** Props to spread on the pressable element. */
169
+ pressProps: DOMProps;
170
+ /** Whether the element is pressed right now. */
171
+ isPressed: Accessor<boolean>;
172
+ }
173
+
174
+ interface PressState {
175
+ isPressed: boolean;
176
+ didFirePressStart: boolean;
177
+ isTriggeringEvent: boolean;
178
+ activePointerId: number | null;
179
+ target: Element | null;
180
+ isOverTarget: boolean;
181
+ pointerType: PointerType | null;
182
+ metaKeyEvents: Map<string, KeyboardEvent> | undefined;
183
+ disposables: (() => void)[];
184
+ }
185
+
186
+ const LINK_CLICKED = Symbol.for("barq.aria.linkClicked");
187
+ const PRESSABLE_ATTRIBUTE = "data-barq-pressable";
188
+ const STYLE_ID = "barq-aria-pressable-style";
189
+
190
+ const NON_TEXT_INPUT_TYPES = new Set([
191
+ "checkbox",
192
+ "radio",
193
+ "range",
194
+ "color",
195
+ "file",
196
+ "image",
197
+ "button",
198
+ "submit",
199
+ "reset",
200
+ ]);
201
+
202
+ function isAnchorLink(target: Element): target is HTMLAnchorElement {
203
+ return target.tagName === "A" && target.hasAttribute("href");
204
+ }
205
+
206
+ function isValidInputKey(target: HTMLInputElement, key: string): boolean {
207
+ // Space toggles a checkbox or radio. Enter submits the form instead.
208
+ return target.type === "checkbox" || target.type === "radio"
209
+ ? key === " "
210
+ : NON_TEXT_INPUT_TYPES.has(target.type);
211
+ }
212
+
213
+ /**
214
+ * Whether the key activates the element.
215
+ *
216
+ * Space and Enter, minus every case where the platform means something else
217
+ * by them: a text field, a textarea, a contenteditable, and a link, which only
218
+ * Enter activates.
219
+ */
220
+ function isActivationKey(event: KeyboardEvent, currentTarget: Element): boolean {
221
+ const { key, code } = event;
222
+ const element = currentTarget as HTMLElement;
223
+ const role = element.getAttribute("role");
224
+ const view = ownerWindow(element);
225
+
226
+ if (key !== "Enter" && key !== " " && key !== "Spacebar" && code !== "Space") return false;
227
+ if (element instanceof view.HTMLInputElement && !isValidInputKey(element, key)) return false;
228
+ if (element instanceof view.HTMLTextAreaElement) return false;
229
+ if (element.isContentEditable) return false;
230
+ if ((role === "link" || (!role && isAnchorLink(element))) && key !== "Enter") return false;
231
+ return true;
232
+ }
233
+
234
+ function shouldPreventDefaultUp(target: Element): boolean {
235
+ if (target instanceof HTMLInputElement) return false;
236
+ if (target instanceof HTMLButtonElement)
237
+ return target.type !== "submit" && target.type !== "reset";
238
+ if (isAnchorLink(target)) return false;
239
+ return true;
240
+ }
241
+
242
+ function shouldPreventDefaultKeyboard(target: Element, key: string): boolean {
243
+ // Control-Enter opens the context menu on macOS.
244
+ if (isMac() && key === "Enter") return false;
245
+
246
+ if (target instanceof HTMLInputElement) {
247
+ // Enter on a checkbox or radio submits the form; it must not also toggle.
248
+ if (key === "Enter" && (target.type === "checkbox" || target.type === "radio")) return false;
249
+ return !isValidInputKey(target, key);
250
+ }
251
+
252
+ return shouldPreventDefaultUp(target);
253
+ }
254
+
255
+ interface Rect {
256
+ top: number;
257
+ right: number;
258
+ bottom: number;
259
+ left: number;
260
+ }
261
+
262
+ function touchRect(touch: Touch): Rect {
263
+ const offsetX = touch.radiusX ?? 0;
264
+ const offsetY = touch.radiusY ?? 0;
265
+ return {
266
+ top: touch.clientY - offsetY,
267
+ right: touch.clientX + offsetX,
268
+ bottom: touch.clientY + offsetY,
269
+ left: touch.clientX - offsetX,
270
+ };
271
+ }
272
+
273
+ function overlaps(a: Rect, b: Rect): boolean {
274
+ if (a.left > b.right || b.left > a.right) return false;
275
+ if (a.top > b.bottom || b.top > a.bottom) return false;
276
+ return true;
277
+ }
278
+
279
+ function isOverTarget(touch: Touch, target: Element): boolean {
280
+ return overlaps(target.getBoundingClientRect(), touchRect(touch));
281
+ }
282
+
283
+ function touchById(event: TouchEvent, pointerId: number | null): Touch | null {
284
+ for (let i = 0; i < event.changedTouches.length; i++) {
285
+ const touch = event.changedTouches[i];
286
+ if (touch !== undefined && touch.identifier === pointerId) return touch;
287
+ }
288
+ return null;
289
+ }
290
+
291
+ function fromTouchEvent(target: Element, event: TouchEvent): EventLike {
292
+ const touch = event.targetTouches.length === 1 ? event.targetTouches[0] : undefined;
293
+ return {
294
+ currentTarget: target,
295
+ shiftKey: event.shiftKey,
296
+ ctrlKey: event.ctrlKey,
297
+ metaKey: event.metaKey,
298
+ altKey: event.altKey,
299
+ clientX: touch?.clientX ?? 0,
300
+ clientY: touch?.clientY ?? 0,
301
+ };
302
+ }
303
+
304
+ function retarget(target: Element, event: EventLike): EventLike {
305
+ return {
306
+ currentTarget: target,
307
+ shiftKey: event.shiftKey,
308
+ ctrlKey: event.ctrlKey,
309
+ metaKey: event.metaKey,
310
+ altKey: event.altKey,
311
+ clientX: event.clientX,
312
+ clientY: event.clientY,
313
+ key: event.key,
314
+ };
315
+ }
316
+
317
+ /**
318
+ * The stylesheet that keeps a double tap from waiting 300ms for a zoom.
319
+ *
320
+ * `touch-action: manipulation` is supposed to be equivalent, but in WebKit it
321
+ * stops `pointercancel` firing on scroll, which is how a press knows it was
322
+ * abandoned.
323
+ */
324
+ function installPressableStyle(doc: Document): void {
325
+ if (doc.head === null || doc.getElementById(STYLE_ID) !== null) return;
326
+ const style = doc.createElement("style");
327
+ style.id = STYLE_ID;
328
+ const nonce = doc.querySelector<HTMLMetaElement>('meta[property="csp-nonce"]')?.content;
329
+ if (nonce !== undefined && nonce !== "") style.nonce = nonce;
330
+ style.textContent = `@layer{[${PRESSABLE_ATTRIBUTE}]{touch-action:pan-x pan-y pinch-zoom}}`;
331
+ doc.head.prepend(style);
332
+ }
333
+
334
+ /**
335
+ * Press handling for one element.
336
+ *
337
+ * ```tsx
338
+ * const { pressProps, isPressed } = press({ onPress: () => count.update((n) => n + 1) });
339
+ * <div {...pressProps} role="button" tabIndex={0} data-pressed={isPressed} />
340
+ * ```
341
+ */
342
+ export function press(options: PressOptions): PressResult {
343
+ const [pressed, setPressed] = createSignal(false);
344
+ const listeners = globalListeners();
345
+
346
+ const state: PressState = {
347
+ isPressed: false,
348
+ didFirePressStart: false,
349
+ isTriggeringEvent: false,
350
+ activePointerId: null,
351
+ target: null,
352
+ isOverTarget: false,
353
+ pointerType: null,
354
+ metaKeyEvents: undefined,
355
+ disposables: [],
356
+ };
357
+
358
+ const isDisabled = (): boolean => access(options.isDisabled) === true;
359
+ const allowTextSelection = (): boolean => access(options.allowTextSelectionOnPress) === true;
360
+
361
+ const triggerPressStart = (original: EventLike, pointerType: PointerType): boolean => {
362
+ if (isDisabled() || state.didFirePressStart) return false;
363
+
364
+ let stopPropagation = true;
365
+ state.isTriggeringEvent = true;
366
+ if (options.onPressStart !== undefined) {
367
+ const event = new Press("pressstart", pointerType, original);
368
+ options.onPressStart(event);
369
+ stopPropagation = event.shouldStopPropagation;
370
+ }
371
+ options.onPressChange?.(true);
372
+
373
+ state.isTriggeringEvent = false;
374
+ state.didFirePressStart = true;
375
+ setPressed(true);
376
+ return stopPropagation;
377
+ };
378
+
379
+ const triggerPressEnd = (
380
+ original: EventLike,
381
+ pointerType: PointerType,
382
+ wasPressed = true,
383
+ ): boolean => {
384
+ if (!state.didFirePressStart) return false;
385
+
386
+ state.didFirePressStart = false;
387
+ state.isTriggeringEvent = true;
388
+
389
+ let stopPropagation = true;
390
+ if (options.onPressEnd !== undefined) {
391
+ const event = new Press("pressend", pointerType, original);
392
+ options.onPressEnd(event);
393
+ stopPropagation = event.shouldStopPropagation;
394
+ }
395
+ options.onPressChange?.(false);
396
+ setPressed(false);
397
+
398
+ if (options.onPress !== undefined && wasPressed && !isDisabled()) {
399
+ const event = new Press("press", pointerType, original);
400
+ options.onPress(event);
401
+ stopPropagation &&= event.shouldStopPropagation;
402
+ }
403
+
404
+ state.isTriggeringEvent = false;
405
+ return stopPropagation;
406
+ };
407
+
408
+ const triggerPressUp = (original: EventLike, pointerType: PointerType): boolean => {
409
+ if (isDisabled()) return false;
410
+ if (options.onPressUp === undefined) return true;
411
+
412
+ state.isTriggeringEvent = true;
413
+ const event = new Press("pressup", pointerType, original);
414
+ options.onPressUp(event);
415
+ state.isTriggeringEvent = false;
416
+ return event.shouldStopPropagation;
417
+ };
418
+
419
+ const cancel = (original: EventLike): void => {
420
+ if (!state.isPressed || state.target === null) return;
421
+
422
+ if (state.didFirePressStart && state.pointerType !== null) {
423
+ triggerPressEnd(retarget(state.target, original), state.pointerType, false);
424
+ }
425
+ state.isPressed = false;
426
+ state.isOverTarget = false;
427
+ state.activePointerId = null;
428
+ state.pointerType = null;
429
+ listeners.removeAll();
430
+ if (!allowTextSelection()) restoreTextSelection(state.target);
431
+ for (const dispose of state.disposables) dispose();
432
+ state.disposables = [];
433
+ };
434
+
435
+ const cancelOnPointerExit = (original: EventLike): void => {
436
+ if (access(options.shouldCancelOnPointerExit) === true) cancel(original);
437
+ };
438
+
439
+ const triggerClick = (event: MouseEvent): void => {
440
+ if (isDisabled()) return;
441
+ options.onClick?.(event);
442
+ };
443
+
444
+ /**
445
+ * The click a keyboard or touch activation would have produced.
446
+ *
447
+ * The platform fires one for a `button` activated by Enter, and third-party
448
+ * code passing `onClick` rather than `onPress` has no other way to hear it.
449
+ */
450
+ const triggerSyntheticClick = (source: Event, target: Element): void => {
451
+ if (isDisabled() || options.onClick === undefined) return;
452
+ const event = new MouseEvent("click", source);
453
+ Object.defineProperty(event, "target", { value: target });
454
+ Object.defineProperty(event, "currentTarget", { value: target });
455
+ options.onClick(event);
456
+ };
457
+
458
+ // ---------------------------------------------------------------------
459
+ // Keyboard
460
+ // ---------------------------------------------------------------------
461
+
462
+ const onKeyUp = (event: KeyboardEvent): void => {
463
+ if (state.isPressed && state.target !== null && isActivationKey(event, state.target)) {
464
+ const target = targetElement(event);
465
+ if (shouldPreventDefaultKeyboard(target ?? state.target, event.key)) event.preventDefault();
466
+
467
+ const wasPressed = contains(state.target, target);
468
+ triggerPressEnd(retarget(state.target, event), "keyboard", wasPressed);
469
+ if (wasPressed) triggerSyntheticClick(event, state.target);
470
+ listeners.removeAll();
471
+
472
+ // A key other than Enter on an element whose role is `link` means the
473
+ // browser will not follow it, so this has to.
474
+ const marked = event as KeyboardEvent & { [LINK_CLICKED]?: boolean };
475
+ if (
476
+ event.key !== "Enter" &&
477
+ isAnchorLink(state.target) &&
478
+ contains(state.target, target) &&
479
+ marked[LINK_CLICKED] !== true
480
+ ) {
481
+ // Marked on the event, so two press hooks on one element open it once.
482
+ marked[LINK_CLICKED] = true;
483
+ openLink(state.target, event, false);
484
+ }
485
+
486
+ state.isPressed = false;
487
+ state.metaKeyEvents?.delete(event.key);
488
+ return;
489
+ }
490
+
491
+ if (event.key === "Meta" && state.metaKeyEvents !== undefined && state.metaKeyEvents.size > 0) {
492
+ // macOS fires no keyup while Meta is held. When Meta itself is released,
493
+ // act as though every key recorded since had been released too.
494
+ const recorded = state.metaKeyEvents;
495
+ state.metaKeyEvents = undefined;
496
+ for (const recordedEvent of recorded.values()) {
497
+ state.target?.dispatchEvent(new KeyboardEvent("keyup", recordedEvent));
498
+ }
499
+ }
500
+ };
501
+
502
+ const onKeyDown = (event: KeyboardEvent): void => {
503
+ const currentTarget = event.currentTarget as Element | null;
504
+ if (currentTarget === null) return;
505
+
506
+ if (!isActivationKey(event, currentTarget) || !contains(currentTarget, targetElement(event))) {
507
+ if (event.key === "Meta") state.metaKeyEvents = new Map();
508
+ return;
509
+ }
510
+
511
+ if (shouldPreventDefaultKeyboard(targetElement(event) ?? currentTarget, event.key)) {
512
+ event.preventDefault();
513
+ }
514
+
515
+ // A repeat may have begun on another element that then lost focus. Only
516
+ // the first keydown starts a press.
517
+ let stopPropagation = true;
518
+ if (!state.isPressed && !event.repeat) {
519
+ state.target = currentTarget;
520
+ state.isPressed = true;
521
+ state.pointerType = "keyboard";
522
+ stopPropagation = triggerPressStart(event, "keyboard");
523
+ }
524
+
525
+ // On the document, capturing: focus may move before the key is released,
526
+ // and a child's own keyboard handler may stop propagation before this
527
+ // element would have heard it.
528
+ const origin = currentTarget;
529
+ const pressUp = (keyUp: Event): void => {
530
+ const keyboardEvent = keyUp as KeyboardEvent;
531
+ if (
532
+ isActivationKey(keyboardEvent, origin) &&
533
+ !keyboardEvent.repeat &&
534
+ contains(origin, targetElement(keyboardEvent)) &&
535
+ state.target !== null
536
+ ) {
537
+ triggerPressUp(retarget(state.target, keyboardEvent), "keyboard");
538
+ }
539
+ onKeyUp(keyboardEvent);
540
+ };
541
+
542
+ listeners.add(ownerDocument(currentTarget), "keyup", pressUp, true);
543
+
544
+ if (stopPropagation) event.stopPropagation();
545
+
546
+ if (event.metaKey && isMac()) state.metaKeyEvents?.set(event.key, event);
547
+ };
548
+
549
+ // ---------------------------------------------------------------------
550
+ // Click
551
+ // ---------------------------------------------------------------------
552
+
553
+ const onClick = (event: MouseEvent): void => {
554
+ const currentTarget = event.currentTarget as Element | null;
555
+ if (currentTarget !== null && !contains(currentTarget, targetElement(event))) return;
556
+ if (event.button !== 0 || state.isTriggeringEvent || isOpeningLink()) return;
557
+
558
+ let stopPropagation = true;
559
+ if (isDisabled()) event.preventDefault();
560
+
561
+ if (!state.isPressed && (state.pointerType === "virtual" || isVirtualClick(event))) {
562
+ // A screen reader, or `element.click()`. There was no pointer sequence,
563
+ // so the whole press runs here.
564
+ const start = triggerPressStart(event, "virtual");
565
+ const up = triggerPressUp(event, "virtual");
566
+ const end = triggerPressEnd(event, "virtual");
567
+ triggerClick(event);
568
+ stopPropagation = start && up && end;
569
+ } else if (state.isPressed && state.pointerType !== "keyboard") {
570
+ const pointerType =
571
+ state.pointerType ?? ((event as PointerEvent).pointerType as PointerType) ?? "virtual";
572
+ const target = (currentTarget ?? state.target) as Element;
573
+ const up = triggerPressUp(retarget(target, event), pointerType);
574
+ const end = triggerPressEnd(retarget(target, event), pointerType, true);
575
+ stopPropagation = up && end;
576
+ state.isOverTarget = false;
577
+ triggerClick(event);
578
+ cancel(event);
579
+ }
580
+
581
+ if (stopPropagation) event.stopPropagation();
582
+ };
583
+
584
+ // ---------------------------------------------------------------------
585
+ // Pointer
586
+ // ---------------------------------------------------------------------
587
+
588
+ const onPointerUpGlobal = (event: Event): void => {
589
+ const pointer = event as PointerEvent;
590
+ if (
591
+ pointer.pointerId !== state.activePointerId ||
592
+ !state.isPressed ||
593
+ pointer.button !== 0 ||
594
+ state.target === null
595
+ ) {
596
+ return;
597
+ }
598
+
599
+ if (contains(state.target, targetElement(pointer)) && state.pointerType !== null) {
600
+ // The press fires from the click, not from here: the DOM may be mutated
601
+ // between the two, and third-party code listens for click.
602
+ //
603
+ // iOS and Android fire neither focus nor click after a long press, so a
604
+ // click is synthesised after a delay if the real one has not arrived.
605
+ // 32ms is the floor: WebKit on iOS delays the click on elements without
606
+ // certain roles, to emulate hover.
607
+ let clicked = false;
608
+ const timeout = setTimeout(() => {
609
+ if (!state.isPressed || !isStyledElement(state.target)) return;
610
+ if (clicked) {
611
+ cancel(pointer);
612
+ } else {
613
+ focusWithoutScrolling(state.target);
614
+ state.target.click();
615
+ }
616
+ }, 80);
617
+
618
+ // Capturing, because a handler in between may stop propagation.
619
+ listeners.add(
620
+ pointer.currentTarget as EventTarget,
621
+ "click",
622
+ () => {
623
+ clicked = true;
624
+ },
625
+ true,
626
+ );
627
+ state.disposables.push(() => clearTimeout(timeout));
628
+ } else {
629
+ cancel(pointer);
630
+ }
631
+
632
+ // Ignore the pointerleave iOS fires before the click.
633
+ state.isOverTarget = false;
634
+ };
635
+
636
+ const onPointerCancelGlobal = (event: Event): void => {
637
+ cancel(event as PointerEvent);
638
+ };
639
+
640
+ const onPointerDown = (event: PointerEvent): void => {
641
+ const currentTarget = event.currentTarget as Element | null;
642
+ if (event.button !== 0 || currentTarget === null) return;
643
+ if (!contains(currentTarget, targetElement(event))) return;
644
+
645
+ // iOS WebKit fires pointer events from VoiceOver with the wrong
646
+ // coordinates and target. The click handler takes it instead.
647
+ if (isVirtualPointerEvent(event)) {
648
+ state.pointerType = "virtual";
649
+ return;
650
+ }
651
+
652
+ state.pointerType = event.pointerType as PointerType;
653
+
654
+ let stopPropagation = true;
655
+ if (!state.isPressed) {
656
+ state.isPressed = true;
657
+ state.isOverTarget = true;
658
+ state.activePointerId = event.pointerId;
659
+ state.target = currentTarget;
660
+
661
+ if (!allowTextSelection()) disableTextSelection(state.target);
662
+
663
+ stopPropagation = triggerPressStart(event, state.pointerType);
664
+
665
+ // Releasing capture is what lets a touch leave the original target, so
666
+ // pointerenter and pointerleave fire at all.
667
+ const target = targetElement(event);
668
+ if (target !== null && "releasePointerCapture" in target) {
669
+ if (!("hasPointerCapture" in target) || target.hasPointerCapture(event.pointerId)) {
670
+ target.releasePointerCapture(event.pointerId);
671
+ }
672
+ }
673
+
674
+ const doc = ownerDocument(currentTarget);
675
+ listeners.add(doc, "pointerup", onPointerUpGlobal, false);
676
+ listeners.add(doc, "pointercancel", onPointerCancelGlobal, false);
677
+ }
678
+
679
+ if (stopPropagation) event.stopPropagation();
680
+ };
681
+
682
+ const onMouseDown = (event: MouseEvent): void => {
683
+ const currentTarget = event.currentTarget as Element | null;
684
+ if (currentTarget === null || !contains(currentTarget, targetElement(event))) return;
685
+ if (event.button !== 0) return;
686
+
687
+ if (access(options.preventFocusOnPress) === true) {
688
+ const dispose = preventFocus(targetElement(event));
689
+ if (dispose !== undefined) state.disposables.push(dispose);
690
+ }
691
+
692
+ event.stopPropagation();
693
+ };
694
+
695
+ const onPointerUp = (event: PointerEvent): void => {
696
+ const currentTarget = event.currentTarget as Element | null;
697
+ if (currentTarget === null || !contains(currentTarget, targetElement(event))) return;
698
+ // iOS reports a zero-sized pointerup, so the type recorded at pointerdown
699
+ // is the one to trust.
700
+ if (state.pointerType === "virtual") return;
701
+
702
+ // While pressed, the press ends at the click instead.
703
+ if (event.button === 0 && !state.isPressed) {
704
+ triggerPressUp(event, state.pointerType ?? (event.pointerType as PointerType));
705
+ }
706
+ };
707
+
708
+ const onPointerEnter = (event: PointerEvent): void => {
709
+ if (
710
+ event.pointerId === state.activePointerId &&
711
+ state.target !== null &&
712
+ !state.isOverTarget &&
713
+ state.pointerType !== null
714
+ ) {
715
+ state.isOverTarget = true;
716
+ triggerPressStart(retarget(state.target, event), state.pointerType);
717
+ }
718
+ };
719
+
720
+ const onPointerLeave = (event: PointerEvent): void => {
721
+ if (
722
+ event.pointerId === state.activePointerId &&
723
+ state.target !== null &&
724
+ state.isOverTarget &&
725
+ state.pointerType !== null
726
+ ) {
727
+ state.isOverTarget = false;
728
+ triggerPressEnd(retarget(state.target, event), state.pointerType, false);
729
+ cancelOnPointerExit(event);
730
+ }
731
+ };
732
+
733
+ const onDragStart = (event: DragEvent): void => {
734
+ const currentTarget = event.currentTarget as Element | null;
735
+ if (currentTarget === null || !contains(currentTarget, targetElement(event))) return;
736
+ // WebKit fires no pointercancel when a drag starts; the others do.
737
+ cancel(event);
738
+ };
739
+
740
+ // ---------------------------------------------------------------------
741
+ // Touch, for engines without pointer events
742
+ // ---------------------------------------------------------------------
743
+
744
+ const onScrollWhilePressed = (): void => {
745
+ if (!state.isPressed || state.target === null) return;
746
+ cancel({
747
+ currentTarget: state.target,
748
+ shiftKey: false,
749
+ ctrlKey: false,
750
+ metaKey: false,
751
+ altKey: false,
752
+ });
753
+ };
754
+
755
+ const onTouchStart = (event: TouchEvent): void => {
756
+ const currentTarget = event.currentTarget as Element | null;
757
+ if (currentTarget === null || !contains(currentTarget, targetElement(event))) return;
758
+
759
+ const touch = event.targetTouches[0];
760
+ if (touch === undefined) return;
761
+
762
+ state.activePointerId = touch.identifier;
763
+ state.isOverTarget = true;
764
+ state.isPressed = true;
765
+ state.target = currentTarget;
766
+ state.pointerType = "touch";
767
+
768
+ if (!allowTextSelection()) disableTextSelection(state.target);
769
+
770
+ if (triggerPressStart(fromTouchEvent(state.target, event), "touch")) event.stopPropagation();
771
+ listeners.add(ownerWindow(currentTarget), "scroll", onScrollWhilePressed, true);
772
+ };
773
+
774
+ const onTouchMove = (event: TouchEvent): void => {
775
+ const currentTarget = event.currentTarget as Element | null;
776
+ if (currentTarget === null || !contains(currentTarget, targetElement(event))) return;
777
+ if (!state.isPressed) {
778
+ event.stopPropagation();
779
+ return;
780
+ }
781
+
782
+ const touch = touchById(event, state.activePointerId);
783
+ let stopPropagation = true;
784
+ if (touch !== null && isOverTarget(touch, currentTarget)) {
785
+ if (!state.isOverTarget && state.pointerType !== null) {
786
+ state.isOverTarget = true;
787
+ stopPropagation = triggerPressStart(
788
+ fromTouchEvent(state.target as Element, event),
789
+ state.pointerType,
790
+ );
791
+ }
792
+ } else if (state.isOverTarget && state.pointerType !== null) {
793
+ state.isOverTarget = false;
794
+ stopPropagation = triggerPressEnd(
795
+ fromTouchEvent(state.target as Element, event),
796
+ state.pointerType,
797
+ false,
798
+ );
799
+ cancelOnPointerExit(fromTouchEvent(state.target as Element, event));
800
+ }
801
+
802
+ if (stopPropagation) event.stopPropagation();
803
+ };
804
+
805
+ const onTouchEnd = (event: TouchEvent): void => {
806
+ const currentTarget = event.currentTarget as Element | null;
807
+ if (currentTarget === null || !contains(currentTarget, targetElement(event))) return;
808
+ if (!state.isPressed) {
809
+ event.stopPropagation();
810
+ return;
811
+ }
812
+
813
+ const touch = touchById(event, state.activePointerId);
814
+ let stopPropagation = true;
815
+ const target = state.target as Element;
816
+ if (touch !== null && isOverTarget(touch, currentTarget) && state.pointerType !== null) {
817
+ triggerPressUp(fromTouchEvent(target, event), state.pointerType);
818
+ stopPropagation = triggerPressEnd(fromTouchEvent(target, event), state.pointerType);
819
+ triggerSyntheticClick(event, target);
820
+ } else if (state.isOverTarget && state.pointerType !== null) {
821
+ stopPropagation = triggerPressEnd(fromTouchEvent(target, event), state.pointerType, false);
822
+ }
823
+
824
+ if (stopPropagation) event.stopPropagation();
825
+
826
+ state.isPressed = false;
827
+ state.activePointerId = null;
828
+ state.isOverTarget = false;
829
+ if (state.target !== null && !allowTextSelection()) restoreTextSelection(state.target);
830
+ listeners.removeAll();
831
+ };
832
+
833
+ const onTouchCancel = (event: TouchEvent): void => {
834
+ const currentTarget = event.currentTarget as Element | null;
835
+ if (currentTarget === null || !contains(currentTarget, targetElement(event))) return;
836
+ event.stopPropagation();
837
+ if (state.isPressed) cancel(fromTouchEvent(state.target as Element, event));
838
+ };
839
+
840
+ // ---------------------------------------------------------------------
841
+
842
+ // A press in flight when the element is disabled has to be abandoned, or the
843
+ // pressed state sticks for as long as the element exists.
844
+ createEffect(isDisabled, (disabled) => {
845
+ if (disabled && state.isPressed && state.target !== null) {
846
+ cancel({
847
+ currentTarget: state.target,
848
+ shiftKey: false,
849
+ ctrlKey: false,
850
+ metaKey: false,
851
+ altKey: false,
852
+ });
853
+ }
854
+ });
855
+
856
+ if (!isServer && options.ref !== undefined) {
857
+ createEffect(
858
+ () => access(options.ref),
859
+ (element) => {
860
+ if (element === null || element === undefined) return;
861
+ installPressableStyle(ownerDocument(element));
862
+ },
863
+ );
864
+ }
865
+
866
+ tryCleanup(() => {
867
+ if (!allowTextSelection()) restoreTextSelection(state.target);
868
+ for (const dispose of state.disposables) dispose();
869
+ state.disposables = [];
870
+ });
871
+
872
+ const pressProps: DOMProps = {
873
+ [PRESSABLE_ATTRIBUTE]: true,
874
+ onKeyDown,
875
+ onClick,
876
+ };
877
+
878
+ if (typeof PointerEvent !== "undefined") {
879
+ pressProps.onPointerDown = onPointerDown;
880
+ pressProps.onMouseDown = onMouseDown;
881
+ pressProps.onPointerUp = onPointerUp;
882
+ pressProps.onPointerEnter = onPointerEnter;
883
+ pressProps.onPointerLeave = onPointerLeave;
884
+ pressProps.onDragStart = onDragStart;
885
+ } else {
886
+ pressProps.onMouseDown = onMouseDown;
887
+ pressProps.onTouchStart = onTouchStart;
888
+ pressProps.onTouchMove = onTouchMove;
889
+ pressProps.onTouchEnd = onTouchEnd;
890
+ pressProps.onTouchCancel = onTouchCancel;
891
+ pressProps.onDragStart = onDragStart;
892
+ }
893
+
894
+ return {
895
+ pressProps,
896
+ isPressed: () => access(options.isPressed) === true || pressed(),
897
+ };
898
+ }