@astryxdesign/core 0.7.5-canary.fccd771 → 0.7.5

package/dist/utils/interactionOverlay.stylex.js

@@ -31,7 +31,10 @@
  * dropped and the press is written by the touch press controller
  * (`utils/pressFeedback.ts`) as `data-astryx-press="on"` once the press is
  * believed (150 ms, no travel, no scroll) and `data-astryx-press="fading"` for the
- * 200 ms release. The two arms paint those through ONE number:
+ * 200 ms release. The query reads the PRIMARY pointer, so on a phone or tablet
+ * a mouse, trackpad or Space-key press loses `:active` too; the controller
+ * writes the same attribute for those, at once. The two arms paint those
+ * through ONE number:
  *
  *  - `--astryx-press-alpha` is the press's strength, 0 to 1. It is a
  *    registered custom property (`@property`, syntax `<number>`, declared once

package/dist/utils/pressFeedback.d.ts

@@ -6,7 +6,11 @@
  * {@link PRESSED_ATTRIBUTE} in its styles.
  */
 export declare const PRESSABLE_ATTRIBUTE = "data-astryx-pressable";
-/** `on` while the press is believed and the finger is down; `fading` for the release's exit. */
+/**
+ * `on` while the press is believed and the finger (or, where the controller
+ * paints them, the mouse button or Space key) is down; `fading` for the
+ * release's exit.
+ */
 export declare const PRESSED_ATTRIBUTE = "data-astryx-press";
 /** Spread onto the element that paints the press. */
 export declare const pressableProps: {

package/dist/utils/pressFeedback.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pressFeedback.d.ts","sourceRoot":"","sources":["../../src/utils/pressFeedback.ts"],"names":[],"mappings":"AA4CA;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,0BAA0B,CAAC;AAE3D,gGAAgG;AAChG,eAAO,MAAM,iBAAiB,sBAAsB,CAAC;AAErD,qDAAqD;AACrD,eAAO,MAAM,cAAc,EAAE;IAAC,QAAQ,CAAC,CAAC,mBAAmB,CAAC,EAAE,EAAE,CAAA;CAE/D,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,OAAO,CAAC;AAmW5C;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,IAAI,CAyBjD"}
+{"version":3,"file":"pressFeedback.d.ts","sourceRoot":"","sources":["../../src/utils/pressFeedback.ts"],"names":[],"mappings":"AAyDA;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,0BAA0B,CAAC;AAE3D;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,sBAAsB,CAAC;AAErD,qDAAqD;AACrD,eAAO,MAAM,cAAc,EAAE;IAAC,QAAQ,CAAC,CAAC,mBAAmB,CAAC,EAAE,EAAE,CAAA;CAE/D,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,OAAO,CAAC;AA6kB5C;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,IAAI,CA0BjD"}

package/dist/utils/pressFeedback.js

@@ -3,7 +3,7 @@
 /**
  * @file pressFeedback.ts
  * @input The press state machine (pressGesture.ts) and the document's pointer,
- *   scroll and visibility events
+ *   keyboard, scroll and visibility events
  * @output Exports PRESSABLE_ATTRIBUTE, PRESSED_ATTRIBUTE, pressableProps and
  *   installPressFeedback
  * @position The DOM half of the touch press model: one delegated controller
@@ -18,21 +18,34 @@
  * Why a delegated document-level controller and not a hook on the element: a
  * virtualized list can carry more than a thousand rows, and four listeners
  * plus a state hook per row is not a cost a list like that can pay. This is
- * six listeners for the whole document, and a press costs one attribute write
- * on one element: no React render, no subscription, no per-element anything.
- * It also makes the behaviour uniform for free: every component that paints a
- * press carries {@link PRESSABLE_ATTRIBUTE}, so all of them change together.
+ * a handful of listeners for the whole document, and a press costs one
+ * attribute write on one element: no React render, no subscription, no
+ * per-element anything. It also makes the behaviour uniform for free: every
+ * component that paints a press carries {@link PRESSABLE_ATTRIBUTE}, so all of
+ * them change together.
  *
- * Under a mouse the controller does nothing and CSS `:active` keeps the press,
- * as it always has. Under a finger the `:active` arm is dropped by the CSS
- * (`@media (pointer: coarse)`) and this writes `data-astryx-press="on"` when the
- * press is believed and `data-astryx-press="fading"` for the release's exit.
+ * Where the primary pointer is fine (a desktop), the controller ignores the
+ * mouse and the keyboard: CSS `:active` keeps their press, as it always has,
+ * and the mouse path costs nothing. Under a finger the `:active` arm is
+ * dropped by the CSS (`@media (pointer: coarse)`) and this writes
+ * `data-astryx-press="on"` when the press is believed and
+ * `data-astryx-press="fading"` for the release's exit.
+ *
+ * That query reads the PRIMARY pointer, so on a phone or a tablet the
+ * stylesheet drops `:active` for every press, including a mouse or trackpad
+ * click and a Space press on a focused button. There, the controller paints
+ * those too: at once (no scroller can claim a mouse button or a key, so
+ * nothing waits), held while the button or key is down, and faded at the
+ * release, the way a finger's press leaves. The query is the stylesheet's
+ * own, so the two cannot disagree about which presses are the controller's.
  *
  * SYNC: When modified, update pressGesture.ts, hooks/usePressFeedback.ts,
- * utils/interactionOverlay.stylex.ts and pressFeedback.test.ts.
+ * hooks/usePressFeedback.doc.mjs, utils/interactionOverlay.stylex.ts and
+ * pressFeedback.test.ts.
  */
 
 import { idlePressGesture, PRESS_FADE_MS, PRESS_FLASH_MS, PRESS_ONSET_MS, PRESS_SCROLL_BRAKE_MS, pressGestureStep } from "./pressGesture.js";
+import { TOUCH_QUERY } from "./touchPresentation.js";
 
 /**
  * The marker the controller finds with `closest()`. Every Astryx component
@@ -43,7 +56,11 @@ import { idlePressGesture, PRESS_FADE_MS, PRESS_FLASH_MS, PRESS_ONSET_MS, PRESS_
  */
 export const PRESSABLE_ATTRIBUTE = 'data-astryx-pressable';
 
-/** `on` while the press is believed and the finger is down; `fading` for the release's exit. */
+/**
+ * `on` while the press is believed and the finger (or, where the controller
+ * paints them, the mouse button or Space key) is down; `fading` for the
+ * release's exit.
+ */
 export const PRESSED_ATTRIBUTE = 'data-astryx-press';
 
 /** Spread onto the element that paints the press. */
@@ -61,9 +78,41 @@ export const PRESS_GESTURE_MEMORY_MS = 3000;
 
 /** A surface that is not enabled does not press, however it is touched. */
 const DISABLED = ':disabled, [aria-disabled="true"]';
-let live = null;
+
+/**
+ * The `<input>` types a Space press activates as a button. Browsers hold
+ * `:active` on these (and on `<button>`) while Space is down; on a link or a
+ * `role="button"` element Space does nothing, so neither paints there. A
+ * checkbox or radio is left out: its pressable surface is the row around it,
+ * and desktop Chromium and WebKit leave that row at rest for a Space press
+ * (only the input matches `:active`), so it paints nothing here either.
+ */
+const SPACE_ACTIVATED_INPUT_TYPES = new Set(['button', 'image', 'reset', 'submit']);
+
+/**
+ * A menu's own highlight is its only paint (`module:DropdownMenu/useMenuPress`
+ * FR6, DEC-6): a press held on one row while the highlight follows the
+ * pointer to another would light two rows.
+ */
+const MENU_PRESS_ROOT = '[data-astryx-menu-press]';
+
+/**
+ * One tracking slot. A finger's press runs the whole machine (the delay, the
+ * slop, the scroll that takes it away). A mouse button's or the Space key's
+ * press is believed at once and only waits for its release, so it has a slot
+ * of its own: a finger landing never ends it, and it never swallows a
+ * finger's press.
+ */
+
+const finger = {
+  live: null
+};
+const button = {
+  live: null
+};
 /** How many callers hold the controller installed; listeners exist while > 0. */
 let holders = 0;
+/** Whether the stylesheet left mouse and keyboard presses to the controller; read at the first one. */
 /**
  * When a scroller last moved UNDER A FINGER OF ITS OWN, and which one.
  *
@@ -94,10 +143,10 @@ function paintElement(element, paint) {
   }
   element.setAttribute(PRESSED_ATTRIBUTE, paint);
 }
-function clearTimer() {
-  if (live?.timer != null) {
-    clearTimeout(live.timer);
-    live.timer = null;
+function clearTimer(slot) {
+  if (slot.live?.timer != null) {
+    clearTimeout(slot.live.timer);
+    slot.live.timer = null;
   }
 }
 
@@ -121,18 +170,19 @@ function clearTimer() {
  *    controller's single tracking slot, holding a reference to an element a
  *    virtualized list may already have unmounted.
  */
-function apply(step) {
+function apply(slot, step) {
+  const live = slot.live;
   if (live == null) {
     return;
   }
   const phaseMoved = step.gesture.phase !== live.gesture.phase;
   if (step.timer != null || phaseMoved) {
-    clearTimer();
+    clearTimer(slot);
   }
   live.gesture = step.gesture;
   paintElement(live.element, step.paint);
   if (step.gesture.phase === 'idle') {
-    live = null;
+    slot.live = null;
     return;
   }
   if (step.timer != null) {
@@ -141,10 +191,10 @@ function apply(step) {
     // while a scroll runs, so a frame-based delay would fire late, after the
     // scroll, and paint a control nobody is pressing any more.
     live.timer = setTimeout(() => {
-      if (live != null) {
-        live.timer = null;
+      if (slot.live != null) {
+        slot.live.timer = null;
       }
-      apply(pressGestureStep(live?.gesture ?? idlePressGesture(), {
+      apply(slot, pressGestureStep(slot.live?.gesture ?? idlePressGesture(), {
         kind: TIMER_EVENT[kind]
       }));
     }, TIMER_MS[kind]);
@@ -199,48 +249,135 @@ function scrollerIsBraking(element) {
 }
 
 /**
- * Let go of the controller's one tracking slot once the gesture is over.
+ * Let go of a slot once its gesture is over.
  *
  * A gesture that became a scroll ends in `pointercancel`, not `pointerup`, so
  * without this the dead gesture holds the slot for ever and every press after
  * the first scroll is swallowed.
  */
-function releaseIfDead() {
-  if (live?.gesture.phase === 'dead') {
-    clearTimer();
-    live = null;
+function releaseIfDead(slot) {
+  if (slot.live?.gesture.phase === 'dead') {
+    clearTimer(slot);
+    slot.live = null;
   }
 }
 
 /** Drop the paint and forget the gesture, without running the machine. */
-function finish() {
+function finish(slot) {
+  const live = slot.live;
   if (live == null) {
     return;
   }
-  clearTimer();
+  clearTimer(slot);
   live.element.removeAttribute(PRESSED_ATTRIBUTE);
-  live = null;
+  slot.live = null;
+  if (slot === button) {
+    holdKey(false);
+  }
+}
+
+/** A new press on an element owns its paint: the other slot's gesture there ends. */
+function takeOver(other, element) {
+  if (other.live?.element === element) {
+    finish(other);
+  }
+}
+
+/**
+ * Whether presses with a mouse or a key are the controller's to paint here.
+ * Asked at each such press: rendering a pressable never queries the pointer,
+ * so a layout that must not depend on it stays independent.
+ */
+function stylesheetDroppedActive() {
+  // The shared touch resolver's key (`spec:AST-012` FR2): the condition the
+  // stylesheet drops `:active` under (`COARSE` in
+  // interactionOverlay.stylex.ts), read once per press.
+  return typeof window.matchMedia === 'function' && window.matchMedia(TOUCH_QUERY).matches;
+}
+
+/**
+ * The surface a mouse button's or the Space key's press paints, if any: the
+ * innermost marked surface, outside a menu. A key's press paints only a
+ * focused element that is itself the surface, as `:active` does.
+ */
+function buttonSurfaceAt(target, pointerId) {
+  const element = surfaceAt(target);
+  if (element == null || element.closest(MENU_PRESS_ROOT) != null) {
+    return null;
+  }
+  if (pointerId == null && element !== target) {
+    return null;
+  }
+  return element;
+}
+
+/** Start a mouse button's or the Space key's press on the surface, if there is one. */
+function pressButton(target, pointerId) {
+  // A press still fading elsewhere goes now: the new one owns the slot.
+  finish(button);
+  const element = buttonSurfaceAt(target, pointerId);
+  if (element == null) {
+    return;
+  }
+  takeOver(finger, element);
+  button.live = {
+    element,
+    gesture: idlePressGesture(),
+    pointerId,
+    timer: null
+  };
+  holdKey(pointerId == null);
+  apply(button, pressGestureStep(button.live.gesture, {
+    kind: 'buttonDown'
+  }));
+}
+
+/** The mouse button or the key came up: the press fades like a finger's. */
+function releaseButton() {
+  holdKey(false);
+  if (button.live == null) {
+    return;
+  }
+  apply(button, pressGestureStep(button.live.gesture, {
+    kind: 'up'
+  }));
+}
+
+/** The platform took the mouse's press away: the paint goes at once. */
+function cancelButton() {
+  holdKey(false);
+  if (button.live == null) {
+    return;
+  }
+  apply(button, pressGestureStep(button.live.gesture, {
+    kind: 'cancel'
+  }));
+  releaseIfDead(button);
 }
 function onPointerDown(event) {
-  // A mouse already has hover and keeps `:active`; the treatment's CSS is
-  // inside `@media (pointer: coarse)`. Not tracking it keeps desktop identical
-  // and costs the mouse path nothing.
   if (event.pointerType === 'mouse') {
+    // A mouse already has hover and keeps `:active` where the primary pointer
+    // is fine; the touch treatment's CSS is inside `@media (pointer: coarse)`.
+    // Not tracking it there keeps desktop identical and costs the mouse path
+    // nothing. Only the primary button: that is the press `:active` paints.
+    if (event.button === 0 && stylesheetDroppedActive()) {
+      pressButton(event.target, event.pointerId);
+    }
     return;
   }
-  if (live != null) {
-    const fingerIsUp = live.gesture.phase === 'fading' || live.gesture.phase === 'flash';
+  if (finger.live != null) {
+    const fingerIsUp = finger.live.gesture.phase === 'fading' || finger.live.gesture.phase === 'flash';
     // A finger still down means a SECOND finger: a pinch or a two-finger
     // scroll is not a press, so the first gesture ends and the second paints
     // nothing.
     if (!fingerIsUp) {
-      finish();
+      finish(finger);
       return;
     }
     // A finger already up means the last tap is still fading. The new touch
     // owns the surface from here; swallowing it would make the second of two
     // quick taps answer with nothing.
-    finish();
+    finish(finger);
   }
   const element = surfaceAt(event.target);
   // The touch clock is stamped AFTER the brake reads it, deliberately: the
@@ -253,23 +390,25 @@ function onPointerDown(event) {
   if (element == null || braking) {
     return;
   }
-  live = {
+  takeOver(button, element);
+  finger.live = {
     element,
     gesture: idlePressGesture(),
     pointerId: event.pointerId,
     timer: null
   };
-  apply(pressGestureStep(live.gesture, {
+  apply(finger, pressGestureStep(finger.live.gesture, {
     kind: 'down',
     x: event.clientX,
     y: event.clientY
   }));
 }
 function onPointerMove(event) {
+  const live = finger.live;
   if (live == null || live.pointerId != null && event.pointerId !== live.pointerId) {
     return;
   }
-  apply(pressGestureStep(live.gesture, {
+  apply(finger, pressGestureStep(live.gesture, {
     kind: 'move',
     x: event.clientX,
     y: event.clientY
@@ -282,6 +421,9 @@ function onPointerUp(event) {
   // press landing inside the brake window. A coarse pointer and a mouse can
   // both be present on one device.
   if (event.pointerType === 'mouse') {
+    if (button.live != null && button.live.pointerId === event.pointerId) {
+      releaseButton();
+    }
     return;
   }
   // The lift is when momentum starts, so it is the clock the brake wants most.
@@ -289,13 +431,14 @@ function onPointerUp(event) {
   if (event.target instanceof Node) {
     lastTouchTarget = event.target;
   }
+  const live = finger.live;
   if (live == null || live.pointerId != null && event.pointerId !== live.pointerId) {
     return;
   }
-  apply(pressGestureStep(live.gesture, {
+  apply(finger, pressGestureStep(live.gesture, {
     kind: 'up'
   }));
-  releaseIfDead();
+  releaseIfDead(finger);
 }
 
 /**
@@ -306,16 +449,36 @@ function onPointerUp(event) {
  * against +47 ms on a fling), which is what puts this cancel one frame ahead
  * of the list's motion, the way UIKit's `touchesCancelled` is.
  */
-function onCancel() {
+function onCancel(event) {
+  // A cancelled mouse pointer ends the mouse's press, not a finger's.
+  const pointer = event;
+  if (pointer?.pointerType === 'mouse') {
+    if (button.live != null && button.live.pointerId === pointer.pointerId) {
+      cancelButton();
+    }
+    return;
+  }
+  const live = finger.live;
   if (live == null) {
     return;
   }
-  apply(pressGestureStep(live.gesture, {
+  apply(finger, pressGestureStep(live.gesture, {
     kind: 'cancel'
   }));
   // The pointer is gone: a scroll-claimed gesture sends no further pointer
   // events, so nothing else would ever free the slot.
-  releaseIfDead();
+  releaseIfDead(finger);
+}
+
+/**
+ * `dragstart`, and NOT `contextmenu`: a press that becomes a drag has taken
+ * the gesture, whatever pressed it, but a right-click is a mouse act this
+ * controller never tracks, and listening for it would read as a takeover of
+ * the browser's own menu.
+ */
+function onDragStart() {
+  onCancel();
+  cancelButton();
 }
 
 /** A scroll anywhere above the pressed element, caught in the capture phase. */
@@ -329,11 +492,13 @@ function onScroll(event) {
     lastScrollAt = Date.now();
     lastScroller = scroller;
   }
+  const live = finger.live;
   if (live == null) {
     return;
   }
   // The CANCEL arm is deliberately wider than the brake: any scroll above the
-  // pressed element takes the gesture, driven by a finger or not.
+  // pressed element takes the gesture, driven by a finger or not. A mouse's
+  // or a key's press is not a finger's and keeps going, as `:active` does.
   const reaches = scroller === document || scroller.contains(live.element);
   if (!reaches) {
     return;
@@ -341,6 +506,42 @@ function onScroll(event) {
   onCancel();
 }
 
+/** Whether a Space press on this element is an activation browsers paint as `:active`. */
+function activatesOnSpace(target) {
+  if (target instanceof HTMLButtonElement) {
+    return true;
+  }
+  return target instanceof HTMLInputElement && SPACE_ACTIVATED_INPUT_TYPES.has(target.type);
+}
+
+/**
+ * Space went down on a focused button that is itself a pressable surface.
+ * Heard in the BUBBLE phase, after the page's own handlers, so a press the
+ * page cancelled (`preventDefault`) paints nothing, exactly as `:active` does
+ * not engage for one.
+ */
+function onKeyDown(event) {
+  if (event.key !== ' ' || event.repeat || event.isComposing || event.defaultPrevented || !activatesOnSpace(event.target) || !stylesheetDroppedActive()) {
+    return;
+  }
+  pressButton(event.target, null);
+}
+function onKeyUp(event) {
+  if (event.key === ' ' && button.live != null && button.live.pointerId == null) {
+    releaseButton();
+  }
+}
+
+/**
+ * Focus left the pressed button, or the window lost focus: the key's release
+ * may never arrive here, so the press ends now, with its fade.
+ */
+function onBlur() {
+  if (button.live != null && button.live.pointerId == null) {
+    releaseButton();
+  }
+}
+
 /**
  * The backstop: a surface that leaves the document while it is painted must
  * not come back painted. A virtualized list mounts and unmounts rows as they
@@ -350,28 +551,31 @@ function onScroll(event) {
  */
 function onVisibilityChange() {
   if (document.visibilityState === 'hidden') {
-    finish();
+    finish(finger);
+    finish(button);
   }
 }
 const PASSIVE_CAPTURE = {
   capture: true,
   passive: true
 };
+const PASSIVE = {
+  passive: true
+};
 function addListeners() {
   window.addEventListener('pointerdown', onPointerDown, PASSIVE_CAPTURE);
   window.addEventListener('pointermove', onPointerMove, PASSIVE_CAPTURE);
   window.addEventListener('pointerup', onPointerUp, PASSIVE_CAPTURE);
   window.addEventListener('pointercancel', onCancel, PASSIVE_CAPTURE);
   window.addEventListener('touchcancel', onCancel, PASSIVE_CAPTURE);
-  // `dragstart`, and NOT `contextmenu`: a long press that becomes a drag has
-  // taken the gesture, but a right-click is a mouse act this controller never
-  // tracks, and listening for it would read as a takeover of the browser's
-  // own menu.
-  window.addEventListener('dragstart', onCancel, PASSIVE_CAPTURE);
+  window.addEventListener('dragstart', onDragStart, PASSIVE_CAPTURE);
   // `scroll` does not bubble, so the capture phase is the only way one
   // listener hears every scroller in the document.
   document.addEventListener('scroll', onScroll, PASSIVE_CAPTURE);
   document.addEventListener('visibilitychange', onVisibilityChange);
+  // Only Space's press needs the key's release and focus loss, so those two
+  // are attached while it is held (holdKey).
+  window.addEventListener('keydown', onKeyDown, PASSIVE);
 }
 function removeListeners() {
   window.removeEventListener('pointerdown', onPointerDown, PASSIVE_CAPTURE);
@@ -379,9 +583,35 @@ function removeListeners() {
   window.removeEventListener('pointerup', onPointerUp, PASSIVE_CAPTURE);
   window.removeEventListener('pointercancel', onCancel, PASSIVE_CAPTURE);
   window.removeEventListener('touchcancel', onCancel, PASSIVE_CAPTURE);
-  window.removeEventListener('dragstart', onCancel, PASSIVE_CAPTURE);
+  window.removeEventListener('dragstart', onDragStart, PASSIVE_CAPTURE);
   document.removeEventListener('scroll', onScroll, PASSIVE_CAPTURE);
   document.removeEventListener('visibilitychange', onVisibilityChange);
+  window.removeEventListener('keydown', onKeyDown);
+  holdKey(false);
+}
+
+/** Whether the key-release listeners are attached. */
+let keyHeld = false;
+
+/**
+ * Attach the key's release and focus-loss listeners while Space holds a
+ * press, and take them down when it ends: at rest the key path costs one
+ * `keydown` listener.
+ */
+function holdKey(held) {
+  if (held === keyHeld) {
+    return;
+  }
+  keyHeld = held;
+  if (held) {
+    window.addEventListener('keyup', onKeyUp, PASSIVE);
+    // `blur` does not bubble: the capture phase hears the element losing
+    // focus and the window losing it.
+    window.addEventListener('blur', onBlur, PASSIVE_CAPTURE);
+  } else {
+    window.removeEventListener('keyup', onKeyUp);
+    window.removeEventListener('blur', onBlur, PASSIVE_CAPTURE);
+  }
 }
 
 /**
@@ -416,7 +646,8 @@ export function installPressFeedback() {
       return;
     }
     removeListeners();
-    finish();
+    finish(finger);
+    finish(button);
     lastScrollAt = 0;
     lastScroller = null;
     lastTouchAt = 0;

package/dist/utils/pressGesture.d.ts

@@ -53,8 +53,12 @@ export type PressPaint = 'none' | 'on' | 'fading';
  * until the finger lifts and a new one starts, so a finger that stops moving,
  * or comes back to the control it started on, paints nothing. That is the
  * difference between this and `:active`.
+ *
+ * `buttonHeld` is a press made with a mouse button or the Space key. No
+ * scroller can claim one, so it paints at once, travel does not end it, and
+ * only the release does.
  */
-export type PressPhase = 'idle' | 'armed' | 'pressed' | 'flash' | 'fading' | 'dead';
+export type PressPhase = 'idle' | 'armed' | 'pressed' | 'buttonHeld' | 'flash' | 'fading' | 'dead';
 export interface PressGesture {
     readonly phase: PressPhase;
     /** Where the finger landed, in client coordinates. */
@@ -66,6 +70,14 @@ export type PressEvent = {
     x: number;
     y: number;
 }
+/**
+ * A mouse button or the Space key went down on the surface. The
+ * controller sends this only where the stylesheet has dropped `:active`
+ * (a coarse primary pointer), which would otherwise paint it.
+ */
+ | {
+    kind: 'buttonDown';
+}
 /** A touch point moved. Coordinates are client-space, like the origin. */
  | {
     kind: 'move';

package/dist/utils/pressGesture.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pressGesture.d.ts","sourceRoot":"","sources":["../../src/utils/pressGesture.ts"],"names":[],"mappings":"AAiCA;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc,MAAM,CAAC;AAElC;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,KAAK,CAAC;AAEhC;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,MAAM,CAAC;AAElC;;;;;GAKG;AACH,eAAO,MAAM,aAAa,EAAE,MAA8B,CAAC;AAE3D;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,MAAM,CAAC;AAEzC,2EAA2E;AAC3E,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,IAAI,GAAG,QAAQ,CAAC;AAElD;;;;;;;GAOG;AACH,MAAM,MAAM,UAAU,GACpB,MAAM,GAAG,OAAO,GAAG,SAAS,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,CAAC;AAE7D,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAC3B,sDAAsD;IACtD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,MAAM,UAAU,GAClB;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAC;AACtC,0EAA0E;GACxE;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAC,GACpC;IAAC,IAAI,EAAE,IAAI,CAAA;CAAC;AACd,4FAA4F;GAC1F;IAAC,IAAI,EAAE,QAAQ,CAAA;CAAC;AAClB,iEAAiE;GAC/D;IAAC,IAAI,EAAE,OAAO,CAAA;CAAC;AACjB,yDAAyD;GACvD;IAAC,IAAI,EAAE,UAAU,CAAA;CAAC;AACpB,wDAAwD;GACtD;IAAC,IAAI,EAAE,SAAS,CAAA;CAAC,CAAC;AAEtB,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAC;IAC/B,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAC3B;;;;;;;;;OASG;IACH,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,GAAG,MAAM,GAAG,IAAI,CAAC;CACnD;AAkBD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,YAAY,EACrB,KAAK,EAAE,UAAU,GAChB,SAAS,CAsFX;AAED,wBAAgB,gBAAgB,IAAI,YAAY,CAE/C"}
+{"version":3,"file":"pressGesture.d.ts","sourceRoot":"","sources":["../../src/utils/pressGesture.ts"],"names":[],"mappings":"AAsCA;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc,MAAM,CAAC;AAElC;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,KAAK,CAAC;AAEhC;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,MAAM,CAAC;AAElC;;;;;GAKG;AACH,eAAO,MAAM,aAAa,EAAE,MAA8B,CAAC;AAE3D;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,MAAM,CAAC;AAEzC,2EAA2E;AAC3E,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,IAAI,GAAG,QAAQ,CAAC;AAElD;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,UAAU,GACpB,MAAM,GAAG,OAAO,GAAG,SAAS,GAAG,YAAY,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,CAAC;AAE5E,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAC3B,sDAAsD;IACtD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,MAAM,UAAU,GAClB;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAC;AACtC;;;;GAIG;GACD;IAAC,IAAI,EAAE,YAAY,CAAA;CAAC;AACtB,0EAA0E;GACxE;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAC,GACpC;IAAC,IAAI,EAAE,IAAI,CAAA;CAAC;AACd,4FAA4F;GAC1F;IAAC,IAAI,EAAE,QAAQ,CAAA;CAAC;AAClB,iEAAiE;GAC/D;IAAC,IAAI,EAAE,OAAO,CAAA;CAAC;AACjB,yDAAyD;GACvD;IAAC,IAAI,EAAE,UAAU,CAAA;CAAC;AACpB,wDAAwD;GACtD;IAAC,IAAI,EAAE,SAAS,CAAA;CAAC,CAAC;AAEtB,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAC;IAC/B,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAC3B;;;;;;;;;OASG;IACH,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,GAAG,MAAM,GAAG,IAAI,CAAC;CACnD;AAkBD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,YAAY,EACrB,KAAK,EAAE,UAAU,GAChB,SAAS,CA6GX;AAED,wBAAgB,gBAAgB,IAAI,YAAY,CAE/C"}