@proyecto-viviana/solidaria 0.4.2 → 0.6.0-rc.0

package/src/interactions/createKeyboard.ts

@@ -1,10 +1,31 @@
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-aria/src/interactions/useKeyboard.ts
+
 /**
  * createKeyboard - Handles keyboard interactions for a focusable element.
  *
  * This is a 1-1 port of React-Aria's useKeyboard hook adapted for SolidJS.
  */
 
-import { JSX } from "solid-js";
+import type { JSX } from "@solidjs/web";
+import { chain } from "../utils/events";
+import { getEventTarget, nodeContains } from "../utils/dom";
+import { access, type MaybeAccessor } from "../utils";
+import {
+  createKeyboardShortcutHandler,
+  type KeyboardShortcutBindings,
+} from "./createKeyboardShortcutHandler";
 
 /**
  * Keyboard event with continuePropagation support.
@@ -24,12 +45,18 @@ export interface KeyboardEvents {
 
 export interface CreateKeyboardProps extends KeyboardEvents {
   /** Whether the keyboard events should be disabled. */
-  isDisabled?: boolean;
+  isDisabled?: MaybeAccessor<boolean>;
+  /** Keyboard shortcuts to handle. */
+  shortcuts?: KeyboardShortcutBindings;
+  /** Whether shortcut handlers receive repeated keydown events. @default false */
+  allowRepeats?: boolean;
+  /** Whether shortcut handlers receive composing keydown events. @default false */
+  allowComposing?: boolean;
 }
 
 export interface KeyboardResult {
   /** Props to spread onto the target element. */
-  keyboardProps: JSX.HTMLAttributes<HTMLElement>;
+  keyboardProps: Pick<JSX.HTMLAttributes<HTMLElement>, "onKeyDown" | "onKeyUp">;
 }
 
 /**
@@ -77,16 +104,65 @@ function createEventHandler<T extends globalThis.KeyboardEvent>(
  * Based on react-aria's useKeyboard but adapted for SolidJS.
  */
 export function createKeyboard(props: CreateKeyboardProps = {}): KeyboardResult {
-  if (props.isDisabled) {
-    return {
-      keyboardProps: {},
-    };
+  let onKeyDown: ((event: globalThis.KeyboardEvent) => void) | undefined;
+  let onKeyUp: ((event: globalThis.KeyboardEvent) => void) | undefined;
+
+  if (props.shortcuts) {
+    const shortcutHandler = createKeyboardShortcutHandler(props.shortcuts);
+    const shortcutOnKeyDown = createEventHandler((event) => {
+      if (!nodeContains(event.currentTarget as Node | null, getEventTarget<Node>(event))) {
+        event.continuePropagation();
+        return;
+      }
+
+      if (
+        (event.repeat && !(props.allowRepeats ?? false)) ||
+        (event.isComposing && !(props.allowComposing ?? false))
+      ) {
+        event.continuePropagation();
+        return;
+      }
+
+      shortcutHandler(event);
+    });
+    const shortcutOnKeyUp = createEventHandler((event) => {
+      if (!nodeContains(event.currentTarget as Node | null, getEventTarget<Node>(event))) {
+        event.continuePropagation();
+        return;
+      }
+
+      if (
+        (event.repeat && !(props.allowRepeats ?? false)) ||
+        (event.isComposing && !(props.allowComposing ?? false))
+      ) {
+        event.continuePropagation();
+        return;
+      }
+
+      event.continuePropagation();
+    });
+
+    onKeyDown = props.onKeyDown
+      ? chain(props.onKeyDown as (event: globalThis.KeyboardEvent) => void, shortcutOnKeyDown)
+      : shortcutOnKeyDown;
+    onKeyUp = props.onKeyUp
+      ? chain(props.onKeyUp as (event: globalThis.KeyboardEvent) => void, shortcutOnKeyUp)
+      : shortcutOnKeyUp;
+  } else {
+    onKeyDown = createEventHandler(props.onKeyDown);
+    onKeyUp = createEventHandler(props.onKeyUp);
   }
 
   return {
     keyboardProps: {
-      onKeyDown: createEventHandler(props.onKeyDown),
-      onKeyUp: createEventHandler(props.onKeyUp),
+      get onKeyDown() {
+        return access(props.isDisabled) ? undefined : onKeyDown;
+      },
+      get onKeyUp() {
+        return access(props.isDisabled) ? undefined : onKeyUp;
+      },
     },
   };
 }
+
+export type { KeyboardShortcutBindings } from "./createKeyboardShortcutHandler";

package/src/interactions/createKeyboardShortcutHandler.ts

@@ -0,0 +1,157 @@
+/*
+ * Copyright 2025 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-aria/src/interactions/createKeyboardShortcutHandler.ts
+
+/**
+ * Keyboard shortcut parsing and exact-match dispatch.
+ *
+ * Port of React Aria's createKeyboardShortcutHandler.
+ */
+
+import { isMac } from "../utils/platform";
+import type { KeyboardEvent } from "./createKeyboard";
+
+export type KeyboardShortcutAction = (
+  event: KeyboardEvent,
+) =>
+  | void
+  | boolean
+  | Partial<{ shouldContinuePropagation?: boolean; shouldPreventDefault?: boolean }>;
+
+/** Maps shortcut strings such as `Mod+s` to handlers. */
+export type KeyboardShortcutBindings = Record<string, KeyboardShortcutAction>;
+
+const modifierNames = new Set(["shift", "alt", "control", "meta", "mod"]);
+const canonicalModifierOrder = ["Alt", "Control", "Meta", "Shift"] as const;
+
+export interface ParsedKeyboardShortcut {
+  shift: boolean;
+  alt: boolean;
+  ctrl: boolean;
+  meta: boolean;
+  mod: boolean;
+  key: string;
+}
+
+export function modifierSetFromParsed(parsed: ParsedKeyboardShortcut): Set<string> {
+  const modifiers = new Set<string>();
+  if (parsed.alt) modifiers.add("Alt");
+  if (parsed.shift) modifiers.add("Shift");
+  if (parsed.ctrl) modifiers.add("Control");
+  if (parsed.meta) modifiers.add("Meta");
+  if (parsed.mod) modifiers.add(isMac() ? "Meta" : "Control");
+  return modifiers;
+}
+
+export function modifierSetFromEvent(event: KeyboardEvent): Set<string> {
+  const modifiers = new Set<string>();
+  if (event.altKey) modifiers.add("Alt");
+  if (event.ctrlKey) modifiers.add("Control");
+  if (event.metaKey) modifiers.add("Meta");
+  if (event.shiftKey) modifiers.add("Shift");
+  return modifiers;
+}
+
+function sortedModifierTokens(modifiers: Set<string>): string[] {
+  return canonicalModifierOrder.filter((name) => modifiers.has(name));
+}
+
+/** Parses a shortcut. Modifier names are case-insensitive and order-independent. */
+export function parseKeyboardShortcut(specification: string): ParsedKeyboardShortcut {
+  const parsed = specification.split("+").reduce<ParsedKeyboardShortcut>(
+    (result, part) => {
+      const lowerPart = part.toLowerCase();
+      if (modifierNames.has(lowerPart)) {
+        if (lowerPart === "shift") result.shift = true;
+        else if (lowerPart === "alt") result.alt = true;
+        else if (lowerPart === "control") result.ctrl = true;
+        else if (lowerPart === "meta") result.meta = true;
+        else if (lowerPart === "mod") result.mod = true;
+      } else {
+        result.key = part;
+      }
+      return result;
+    },
+    { shift: false, alt: false, ctrl: false, meta: false, mod: false, key: "" },
+  );
+
+  if (parsed.key === "") {
+    throw new Error(
+      `Invalid keyboard shortcut: "${specification}". Must include exactly one non-modifier key (e.g. "a", "Enter", "ArrowDown"). Combine any of Shift, Alt, Ctrl, Meta, and Mod.`,
+    );
+  }
+
+  return parsed;
+}
+
+function normalizeEventKey(key: string): string {
+  return key.toLowerCase();
+}
+
+const keyAliases: Record<string, string> = {
+  space: " ",
+  esc: "escape",
+  del: "delete",
+  ins: "insert",
+  left: "arrowleft",
+  right: "arrowright",
+  up: "arrowup",
+  down: "arrowdown",
+  pageup: "pageup",
+  pagedown: "pagedown",
+};
+
+function canonicalKeyFromSpecification(key: string): string {
+  const normalizedKey = normalizeEventKey(key);
+  return keyAliases[normalizedKey] ?? normalizedKey;
+}
+
+export function canonicalKeyboardShortcut(parsed: ParsedKeyboardShortcut): string {
+  const modifiers = sortedModifierTokens(modifierSetFromParsed(parsed));
+  const key = canonicalKeyFromSpecification(parsed.key);
+  return modifiers.length > 0 ? `${modifiers.join("+")}+${key}` : key;
+}
+
+export function keyboardEventToCanonicalShortcut(event: KeyboardEvent): string {
+  const modifiers = sortedModifierTokens(modifierSetFromEvent(event));
+  const key = normalizeEventKey(event.key);
+  return modifiers.length > 0 ? `${modifiers.join("+")}+${key}` : key;
+}
+
+/** Returns a keydown handler that runs an action for an exact shortcut match. */
+export function createKeyboardShortcutHandler(
+  bindings: KeyboardShortcutBindings,
+): (event: KeyboardEvent) => void {
+  const actions = new Map<string, KeyboardShortcutAction>();
+  for (const [specification, action] of Object.entries(bindings)) {
+    actions.set(canonicalKeyboardShortcut(parseKeyboardShortcut(specification)), action);
+  }
+
+  return (event: KeyboardEvent) => {
+    const action = actions.get(keyboardEventToCanonicalShortcut(event));
+    let result = action?.(event);
+
+    if (result === undefined && action !== undefined) {
+      result = { shouldContinuePropagation: false, shouldPreventDefault: true };
+    } else if (typeof result === "boolean") {
+      result = { shouldContinuePropagation: !result, shouldPreventDefault: result };
+    }
+
+    if (result?.shouldPreventDefault) {
+      event.preventDefault();
+    }
+    if (!action || result?.shouldContinuePropagation) {
+      event.continuePropagation();
+    }
+  };
+}

package/src/interactions/createLongPress.ts

@@ -1,14 +1,28 @@
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-aria/src/interactions/useLongPress.ts
+
 /**
  * createLongPress - Handles long press interactions across mouse and touch.
  *
  * Port of @react-aria/interactions useLongPress, adapted for SolidJS.
  */
 
-import { JSX, onCleanup } from "solid-js";
+import { mergeProps, focusWithoutScrolling, createGlobalListeners, onOwnedCleanup } from "../utils";
+import type { JSX } from "@solidjs/web";
 import { createPress, type PressEvent } from "./createPress";
-import { mergeProps, focusWithoutScrolling, createGlobalListeners } from "../utils";
 import { createDescription } from "../utils/createDescription";
-import { type MaybeAccessor } from "../utils/reactivity";
+import { access, type MaybeAccessor } from "../utils/reactivity";
 
 export interface LongPressEvent {
   /** The type of long press event being fired. */
@@ -34,6 +48,8 @@ export interface LongPressEvent {
 export interface LongPressProps {
   /** Whether long press events should be disabled. */
   isDisabled?: MaybeAccessor<boolean>;
+  /** Which pointer type to listen for. By default, both mouse and touch are listened for. */
+  pointerType?: "mouse" | "touch";
   /** Handler that is called when a long press interaction starts. */
   onLongPressStart?: (e: LongPressEvent) => void;
   /**
@@ -55,7 +71,7 @@ export interface LongPressProps {
    * A description for assistive technology users indicating that a long press
    * action is available, e.g. "Long press to open menu".
    */
-  accessibilityDescription?: string;
+  accessibilityDescription?: MaybeAccessor<string | undefined>;
 }
 
 export interface LongPressResult {
@@ -89,21 +105,25 @@ function createLongPressEvent(type: LongPressEvent["type"], e: PressEvent): Long
 export function createLongPress(props: LongPressProps = {}): LongPressResult {
   const {
     isDisabled,
+    pointerType,
     onLongPressStart,
     onLongPressEnd,
     onLongPress,
     threshold = DEFAULT_THRESHOLD,
-    accessibilityDescription,
   } = props;
 
   let timeoutId: ReturnType<typeof setTimeout> | undefined;
   const { addGlobalListener } = createGlobalListeners();
+  const isAcceptedPointerType = (e: PressEvent) =>
+    pointerType
+      ? e.pointerType === pointerType
+      : e.pointerType === "mouse" || e.pointerType === "touch";
 
   const { pressProps } = createPress({
     isDisabled,
     onPressStart(e) {
       e.continuePropagation();
-      if (e.pointerType === "mouse" || e.pointerType === "touch") {
+      if (isAcceptedPointerType(e)) {
         onLongPressStart?.(createLongPressEvent("longpressstart", e));
 
         timeoutId = setTimeout(() => {
@@ -144,17 +164,19 @@ export function createLongPress(props: LongPressProps = {}): LongPressResult {
         timeoutId = undefined;
       }
 
-      if (onLongPressEnd && (e.pointerType === "mouse" || e.pointerType === "touch")) {
+      if (onLongPressEnd && isAcceptedPointerType(e)) {
         onLongPressEnd(createLongPressEvent("longpressend", e));
       }
     },
   });
 
   const descriptionProps = createDescription(() =>
-    onLongPress && !isDisabledValue(isDisabled) ? accessibilityDescription : undefined,
+    onLongPress && !isDisabledValue(props.isDisabled)
+      ? access(props.accessibilityDescription)
+      : undefined,
   );
 
-  onCleanup(() => {
+  onOwnedCleanup(() => {
     if (timeoutId) {
       clearTimeout(timeoutId);
       timeoutId = undefined;

package/src/interactions/createMove.ts

@@ -1,10 +1,25 @@
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-aria/src/interactions/useMove.ts
+
 /**
  * createMove - Handles move interactions across mouse, touch, pointer, and keyboard.
  *
  * Port of @react-aria/interactions useMove, adapted for SolidJS.
  */
 
-import { JSX, createSignal, createEffect, onCleanup } from "solid-js";
+import { createSignal, createTrackedEffect } from "solid-js";
+import type { JSX } from "@solidjs/web";
 import { disableTextSelection, restoreTextSelection, createGlobalListeners } from "../utils";
 
 export type PointerType = "mouse" | "pen" | "touch" | "keyboard";
@@ -115,7 +130,9 @@ export function createMove(props: MoveEvents = {}): MoveResult {
     }
   };
 
-  createEffect(() => {
+  createTrackedEffect(() => {
+    const _s2Cleanups: Array<() => void> = [];
+
     const activePointer = pointerDown();
     if (!activePointer) return;
 
@@ -148,7 +165,7 @@ export function createMove(props: MoveEvents = {}): MoveResult {
       addGlobalListener("pointermove", onPointerMove, { isWindow: true });
       addGlobalListener("pointerup", onPointerUp, { isWindow: true });
       addGlobalListener("pointercancel", onPointerUp, { isWindow: true });
-      onCleanup(() => {
+      _s2Cleanups.push(() => {
         removeGlobalListener("pointermove", onPointerMove, { isWindow: true });
         removeGlobalListener("pointerup", onPointerUp, { isWindow: true });
         removeGlobalListener("pointercancel", onPointerUp, { isWindow: true });
@@ -156,6 +173,10 @@ export function createMove(props: MoveEvents = {}): MoveResult {
     }
 
     // Mouse/touch listeners are attached directly in their handlers.
+
+    return () => {
+      for (const c of _s2Cleanups) c();
+    };
   });
 
   const start = () => {

package/src/interactions/createPress.ts

@@ -1,3 +1,17 @@
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-aria/src/interactions/usePress.ts
+
 /**
  * createPress - Handles press interactions across mouse, touch, keyboard, and virtual clicks.
  *
@@ -5,8 +19,6 @@
  * All behaviors, edge cases, and platform-specific handling are preserved.
  */
 
-import { createSignal, JSX, Accessor, onCleanup } from "solid-js";
-import { PressEvent, PointerType, createPressEvent, type PressEventSource } from "./PressEvent";
 import {
   nodeContains,
   getEventTarget,
@@ -26,7 +38,11 @@ import {
   createGlobalListeners,
   setEventTarget,
   focusWithoutScrolling,
+  onOwnedCleanup,
 } from "../utils";
+import { createSignal, Accessor } from "solid-js";
+import type { JSX } from "@solidjs/web";
+import { PressEvent, PointerType, createPressEvent, type PressEventSource } from "./PressEvent";
 
 export { PressEvent, type PointerType } from "./PressEvent";
 export type { IPressEvent, PressEventType } from "./PressEvent";
@@ -106,8 +122,13 @@ function eventPathContains(parent: EventTarget | null | undefined, event: Event)
   return false;
 }
 
-// Track which links have been programmatically clicked to avoid double activation
-const linkClickedSet = new WeakSet<HTMLElement>();
+// Marks the keyup event a link was already opened from, so several press
+// instances on one element do not each open it. Upstream keys this on the event
+// (react-aria 3.52.0 `usePress.mjs:102` `Symbol('linkClicked')`, set at `:317`)
+// rather than on the element, so the mark dies with the event rather than with a
+// timeout, and a later activation of the same link is never swallowed.
+const LINK_CLICKED = Symbol("linkClicked");
+type LinkClickedEvent = KeyboardEvent & { [LINK_CLICKED]?: boolean };
 
 // CSS for preventing double-tap zoom delay
 let pressableCSSInjected = false;
@@ -133,7 +154,7 @@ function injectPressableCSS(): void {
  */
 export function createPress(props: CreatePressProps = {}): PressResult {
   // Internal pressed state (for visual feedback)
-  const [internalIsPressed, setInternalIsPressed] = createSignal(false);
+  const [internalIsPressed, setInternalIsPressed] = createSignal(false, { ownedWrite: true });
 
   // Use controlled isPressed if provided, otherwise internal state
   const isPressed = (): boolean => {
@@ -148,7 +169,6 @@ export function createPress(props: CreatePressProps = {}): PressResult {
   let pressState = {
     isPressed: false,
     ignoreEmulatedMouseEvents: false,
-    ignoreClickAfterPress: false,
     didFirePressStart: false,
     isTriggeringEvent: false,
     activePointerId: null as number | null,
@@ -316,6 +336,12 @@ export function createPress(props: CreatePressProps = {}): PressResult {
 
     pressState.pointerType = e.pointerType as PointerType;
 
+    // RAC usePress always stopPropagates a handled pointerdown, even when this
+    // target is already pressed. Nested pressables (DatePicker calendar
+    // button inside the field group) rely on that so a second pointerdown —
+    // Playwright pressLocator's dispatched event after mouse.down — does not
+    // start the parent's press and run focusLast.
+    let shouldStopPropagation = true;
     if (!pressState.isPressed) {
       pressState.isPressed = true;
       pressState.isOverTarget = true;
@@ -326,15 +352,16 @@ export function createPress(props: CreatePressProps = {}): PressResult {
         disableTextSelection(pressState.target as HTMLElement);
       }
 
-      const shouldStopPropagation = triggerPressStart(e, pressState.pointerType);
-      if (shouldStopPropagation) {
-        e.stopPropagation();
-      }
+      shouldStopPropagation = triggerPressStart(e, pressState.pointerType);
 
       // Set up global listeners for pointer events
       addGlobalListener("pointerup", onPointerUp);
       addGlobalListener("pointercancel", onPointerCancel);
     }
+
+    if (shouldStopPropagation) {
+      e.stopPropagation();
+    }
   };
 
   // Mouse down handler when using pointer events - only prevents focus, doesn't trigger press
@@ -714,12 +741,6 @@ export function createPress(props: CreatePressProps = {}): PressResult {
       pressState.metaKeyEvents.set(e.key, e);
     }
 
-    // For Enter key on native buttons, the click fires on keydown
-    // Set flag to ignore it
-    if (e.key === "Enter") {
-      pressState.ignoreClickAfterPress = true;
-    }
-
     // Set up global keyup listener
     addGlobalListener("keyup", onKeyUp, { capture: true });
   };
@@ -777,22 +798,16 @@ export function createPress(props: CreatePressProps = {}): PressResult {
       e.key !== "Enter" &&
       isHTMLAnchorLink(target) &&
       wasPressed &&
-      !linkClickedSet.has(target as HTMLElement)
+      !(e as LinkClickedEvent)[LINK_CLICKED]
     ) {
-      linkClickedSet.add(target as HTMLElement);
-      openLink(target as HTMLAnchorElement, e);
-      // Clean up the marker
-      setTimeout(() => {
-        linkClickedSet.delete(target as HTMLElement);
-      }, 0);
-    }
-
-    // For Space key on non-native targets, the click fires after keyup.
-    // Set flag to ignore it when we already synthesized the click.
-    if (e.key === " " && wasPressed && shouldPreventDefaultKeyboard(target, e.key)) {
-      pressState.ignoreClickAfterPress = true;
-    } else if (e.key === "Enter") {
-      pressState.ignoreClickAfterPress = false;
+      // Store a hidden property on the event so we only trigger the link click
+      // once, even if there are multiple createPress instances on the element.
+      (e as LinkClickedEvent)[LINK_CLICKED] = true;
+      // `false`: this click is ours, not the consumer's, so `openLink.isOpening`
+      // must stay down and a collection item's click guard
+      // (`createSelectableItem`, upstream `useSelectableItem.mjs:254`) can
+      // suppress the navigation it did not ask for. Upstream `usePress.mjs:320`.
+      openLink(target as HTMLAnchorElement, e, false);
     }
 
     if (shouldStopPropagation && shouldStopPropagationEnd) {
@@ -808,15 +823,41 @@ export function createPress(props: CreatePressProps = {}): PressResult {
       return;
     }
 
-    // Only process left clicks that aren't from our own event triggers
-    if (e.button === 0 && !pressState.isTriggeringEvent) {
-      if (pressState.ignoreClickAfterPress) {
-        pressState.ignoreClickAfterPress = false;
+    // Only process left clicks that aren't from our own event triggers, and not
+    // the click `openLink` is dispatching right now (upstream
+    // `usePress.mjs:279`). Keyboard activation
+    // (isPressed + pointerType keyboard) skips press re-entry like RAC usePress,
+    // then still stopPropagates so document click interceptors do not run. Do
+    // not preventDefault an enabled <a href>.
+    if (
+      e.button === 0 &&
+      !pressState.isTriggeringEvent &&
+      !(openLink as { isOpening?: boolean }).isOpening
+    ) {
+      if (isDisabledValue(props.isDisabled)) {
+        e.preventDefault();
         return;
       }
 
-      if (isDisabledValue(props.isDisabled)) {
-        e.preventDefault();
+      const isCollectionItem =
+        e.currentTarget instanceof Element &&
+        (e.currentTarget.hasAttribute("data-collection") ||
+          e.currentTarget.matches('[role="row"], [role="gridcell"], [role="treeitem"]') ||
+          e.currentTarget.closest("[data-collection]") != null);
+
+      const closestInteractive =
+        isCollectionItem && e.target instanceof Element
+          ? e.target.closest(
+              'button, input, select, textarea, a[href], [data-solidaria-pressable], [role="button"], [role="checkbox"], [role="menuitem"]',
+            )
+          : null;
+
+      const isInteractiveChild =
+        closestInteractive != null &&
+        closestInteractive !== e.currentTarget &&
+        e.currentTarget.contains(closestInteractive);
+
+      if (isInteractiveChild) {
         return;
       }
 
@@ -870,13 +911,16 @@ export function createPress(props: CreatePressProps = {}): PressResult {
   // Conditionally use pointer events or mouse events based on browser support
   // This matches React-Aria's approach exactly
 
-  const pressProps: JSX.HTMLAttributes<HTMLElement> & { "data-solidaria-pressable": string } =
+  const pressProps: JSX.HTMLAttributes<HTMLElement> & {
+    "data-solidaria-pressable": string;
+    onClick: JSX.EventHandler<HTMLElement, MouseEvent>;
+  } =
     typeof PointerEvent !== "undefined"
       ? {
           // Keyboard events
           onKeyDown,
           onKeyUp,
-          onClick,
+          onClick: onClick,
           onDragStart,
           // Pointer events (preferred when available)
           onPointerDown,
@@ -897,7 +941,7 @@ export function createPress(props: CreatePressProps = {}): PressResult {
           // Keyboard events
           onKeyDown,
           onKeyUp,
-          onClick,
+          onClick: onClick,
           onDragStart,
           // Mouse events (fallback when PointerEvent not available)
           onMouseDown: onMouseDownFallback,
@@ -914,7 +958,7 @@ export function createPress(props: CreatePressProps = {}): PressResult {
         };
 
   // Clean up on unmount
-  onCleanup(() => {
+  onOwnedCleanup(() => {
     removeAllGlobalListeners();
     // Clean up click timeout/listener if pending
     if (pressState.clickCleanup) {

package/src/interactions/index.ts

@@ -83,4 +83,5 @@ export {
   type KeyboardResult,
   type KeyboardEvents,
   type KeyboardEvent,
+  type KeyboardShortcutBindings,
 } from "./createKeyboard";