@shopgate/engage 7.32.0-beta.10 → 7.32.0-beta.12

package/core/hooks/events/appEvents.d.ts

@@ -2,82 +2,67 @@
  * Additional options for app event hooks.
  */
 export interface AppEventOptions {
-  /**
-   * When false, no listener is registered.
-   * @default true
-   */
-  enabled?: boolean;
-  /**
-   * When true, the callback is removed after first call.
-   * @default false
-   */
-  once?: boolean;
+    /**
+     * When false, no listener is registered.
+     * @default true
+     */
+    enabled?: boolean;
+    /**
+     * When true, the callback is removed after first call.
+     * @default false
+     */
+    once?: boolean;
 }
-
 /**
  * Extended options for return-from-background hook.
  */
 export interface ReturnFromBackgroundOptions extends AppEventOptions {
-  /**
-   * If true, requires a new background event to re-arm before firing again.
-   * If false, remains armed until disabled or unmounted.
-   * @default true
-   */
-  resetAfterFire?: boolean;
+    /**
+     * If true, requires a new background event to re-arm before firing again.
+     * If false, remains armed until disabled or unmounted.
+     * @default true
+     */
+    resetAfterFire?: boolean;
 }
-
 /**
  * Registers a callback for a given event from the Shopgate app event bus.
  *
  * Automatically unsubscribes on unmount. Can optionally run only once.
- *
  * @param name The event name to subscribe to.
  * @param callback The function to call when the event fires.
  * @param options Additional options.
  */
-export declare function useAppEvent(
-  name: string,
-  callback: () => void,
-  options?: AppEventOptions
-): void;
-
+export declare function useAppEvent(name: string, callback: () => void, options?: AppEventOptions): void;
 /**
- * Registers a callback that fires when the app will enter foreground.
- *
- * Automatically unsubscribes on unmount.
+ * Registers a callback that fires when the app will enter foreground
+ * (`applicationWillEnterForeground`).
  *
+ * Automatically unsubscribes on unmount. Accepts same options as `useAppEvent`.
  * @param callback The callback to run when entering foreground.
  * @param options Additional options.
  */
-export declare function useAppEventOnEnterForeground(
-  callback: () => void,
-  options?: AppEventOptions
-): void;
-
+export declare function useAppEventOnEnterForeground(callback: () => void, options?: AppEventOptions): void;
 /**
- * Registers a callback that fires when the app did enter background.
- *
- * Automatically unsubscribes on unmount.
+ * Registers a callback that fires when the app did enter background
+ * (`applicationDidEnterBackground`).
  *
+ * Automatically unsubscribes on unmount. Accepts same options as `useAppEvent`.
  * @param callback The callback to run when entering background.
  * @param options Additional options.
  */
-export declare function useAppEventOnDidEnterBackground(
-  callback: () => void,
-  options?: AppEventOptions
-): void;
-
+export declare function useAppEventOnDidEnterBackground(callback: () => void, options?: AppEventOptions): void;
 /**
  * Invokes a callback only after the app was first sent to background and then
- * returns to the foreground — i.e. a complete background → foreground cycle.
+ * returns to the foreground - i.e. a complete background to foreground cycle.
  *
  * Common use case: user leaves the app to open system settings and returns, so you
  * can re-check permissions or refresh data.
  *
+ * Internally, this subscribes to both background and foreground events:
+ * - Arms itself when entering background
+ * - Fires on next foreground if armed
  * @param callback The callback to run after returning from background.
  * @param options Additional options.
  */
-export declare function useAppEventOnReturnFromBackground(
-  callback: () => void,
-  options?: ReturnFromBackgroundOptions
-): void;
+export declare function useAppEventOnReturnFromBackground(callback: () => void, options?: ReturnFromBackgroundOptions): void;
+//# sourceMappingURL=appEvents.d.ts.map

package/core/hooks/events/appEvents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"appEvents.d.ts","sourceRoot":"","sources":["../../../../core/hooks/events/appEvents.ts"],"names":[],"mappings":"AAOA;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;OAGG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,2BAA4B,SAAQ,eAAe;IAClE;;;;OAIG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAkBD;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,IAAI,EAAE,OAAO,GAAE,eAAoB,QAiB5F;AAED;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAAC,QAAQ,EAAE,MAAM,IAAI,EAAE,OAAO,CAAC,EAAE,eAAe,QAE3F;AAED;;;;;;;GAOG;AACH,wBAAgB,+BAA+B,CAAC,QAAQ,EAAE,MAAM,IAAI,EAAE,OAAO,CAAC,EAAE,eAAe,QAE9F;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iCAAiC,CAC/C,QAAQ,EAAE,MAAM,IAAI,EACpB,OAAO,GAAE,2BAAgC,QAsB1C"}

package/core/hooks/events/appEvents.js

@@ -2,15 +2,22 @@ import { useEffect, useRef } from 'react';
 import { APP_EVENT_APPLICATION_WILL_ENTER_FOREGROUND, APP_EVENT_APPLICATION_DID_ENTER_BACKGROUND } from '@shopgate/engage/core/constants';
 import { event } from '@shopgate/engage/core/classes';
 
+/**
+ * Additional options for app event hooks.
+ */
+
+/**
+ * Extended options for return-from-background hook.
+ */
+
 /**
  * Returns a stable reference to the given callback, preserving the same function identity
  * across renders, while still always calling the latest version of the callback.
  *
  * Useful when passing callbacks into event listeners or effects so they don't re-subscribe
  * on every render but still access up-to-date props/state.
- *
- * @param {Function} fn The callback function whose latest version should be retained.
- * @returns {Function} A stable function reference that always invokes the latest callback.
+ * @param fn The callback function whose latest version should be retained.
+ * @returns A stable function reference that always invokes the latest callback.
  */
 function useStableCallback(fn) {
   const ref = useRef(fn);
@@ -18,16 +25,14 @@ function useStableCallback(fn) {
   const stable = useRef((...args) => ref.current?.(...args));
   return stable.current;
 }
+
 /**
  * Registers a callback for a given event from the Shopgate app event bus.
  *
  * Automatically unsubscribes on unmount. Can optionally run only once.
- *
- * @param {string} name The event name to subscribe to.
- * @param {Function} callback The function to call when the event fires.
- * @param {Object} [options] Additional options.
- * @param {boolean} [options.enabled=true] When false, no listener is registered.
- * @param {boolean} [options.once=false] When true, the callback is removed after first call.
+ * @param name The event name to subscribe to.
+ * @param callback The function to call when the event fires.
+ * @param options Additional options.
  */
 export function useAppEvent(name, callback, options = {}) {
   const {
@@ -37,7 +42,10 @@ export function useAppEvent(name, callback, options = {}) {
   const latest = useStableCallback(callback);
   useEffect(() => {
     if (!enabled) return undefined;
-    // eslint-disable-next-line require-jsdoc
+
+    /**
+     * Invokes the callback, and unsubscribes again when the event was only wanted once.
+     */
     const handler = () => {
       latest();
       if (once) event.removeCallback(name, handler);
@@ -52,11 +60,8 @@ export function useAppEvent(name, callback, options = {}) {
  * (`applicationWillEnterForeground`).
  *
  * Automatically unsubscribes on unmount. Accepts same options as `useAppEvent`.
- *
- * @param {Function} callback The callback to run when entering foreground.
- * @param {Object} [options] Additional options.
- * @param {boolean} [options.enabled=true] When false, the listener is not registered.
- * @param {boolean} [options.once=false] Remove after first call.
+ * @param callback The callback to run when entering foreground.
+ * @param options Additional options.
  */
 export function useAppEventOnEnterForeground(callback, options) {
   useAppEvent(APP_EVENT_APPLICATION_WILL_ENTER_FOREGROUND, callback, options);
@@ -65,12 +70,10 @@ export function useAppEventOnEnterForeground(callback, options) {
 /**
  * Registers a callback that fires when the app did enter background
  * (`applicationDidEnterBackground`).
- ** Automatically unsubscribes on unmount. Accepts same options as `useAppEvent`.
  *
- * @param {Function} callback The callback to run when entering background.
- * @param {Object} [options] Additional options.
- * @param {boolean} [options.enabled=true] When false, the listener is not registered.
- * @param {boolean} [options.once=false] Remove after first call.
+ * Automatically unsubscribes on unmount. Accepts same options as `useAppEvent`.
+ * @param callback The callback to run when entering background.
+ * @param options Additional options.
  */
 export function useAppEventOnDidEnterBackground(callback, options) {
   useAppEvent(APP_EVENT_APPLICATION_DID_ENTER_BACKGROUND, callback, options);
@@ -78,7 +81,7 @@ export function useAppEventOnDidEnterBackground(callback, options) {
 
 /**
  * Invokes a callback only after the app was first sent to background and then
- * returns to the foreground — i.e. a complete background → foreground cycle.
+ * returns to the foreground - i.e. a complete background to foreground cycle.
  *
  * Common use case: user leaves the app to open system settings and returns, so you
  * can re-check permissions or refresh data.
@@ -86,14 +89,8 @@ export function useAppEventOnDidEnterBackground(callback, options) {
  * Internally, this subscribes to both background and foreground events:
  * - Arms itself when entering background
  * - Fires on next foreground if armed
- *
- * @param {Function} callback The callback to run after returning from background.
- * @param {Object} [options] Additional options.
- * @param {boolean} [options.enabled=true] When false, no listener behavior is active.
- * @param {boolean} [options.once=false] When true, callback fires only for the first cycle.
- * @param {boolean} [options.resetAfterFire=true]
- *        If true, requires a new background event to re-arm before firing again.
- *        If false, remains armed until disabled or unmounted.
+ * @param callback The callback to run after returning from background.
+ * @param options Additional options.
  */
 export function useAppEventOnReturnFromBackground(callback, options = {}) {
   const {

package/core/hooks/events/index.d.ts

@@ -1,5 +1,5 @@
-export * from "./appEvents";
-export { default as usePressHandler } from "./usePressHandler";
-export { default as useLongPress } from "./useLongPress";
-export { default as useScrollDirectionChange } from "./useScrollDirectionChange";
+export * from './appEvents';
+export { default as usePressHandler } from './usePressHandler';
+export { default as useLongPress } from './useLongPress';
+export { default as useScrollDirectionChange } from './useScrollDirectionChange';
 //# sourceMappingURL=index.d.ts.map

package/core/hooks/events/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../core/hooks/events/index.js"],"names":[],"mappings":""}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../core/hooks/events/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAC/D,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACzD,OAAO,EAAE,OAAO,IAAI,wBAAwB,EAAE,MAAM,4BAA4B,CAAC"}

package/core/hooks/events/useLongPress.d.ts

@@ -1,68 +1,65 @@
-import { MouseEvent as ReactMouseEvent, TouchEvent as ReactTouchEvent } from 'react';
-
+import type { MouseEvent as ReactMouseEvent, TouchEvent as ReactTouchEvent } from 'react';
+/**
+ * The events a long press interaction can originate from. The handlers below are spread onto an
+ * element, so these are React's synthetic events rather than the DOM ones.
+ */
+export type LongPressEvent = ReactMouseEvent | ReactTouchEvent;
+/**
+ * Event handlers to spread onto the element that should react to a long press.
+ */
 export interface LongPressHandlers {
-  /**
-   * Attach to `onMouseDown` event.
-   */
-  onMouseDown: (e: ReactMouseEvent | TouchEvent) => void;
-
-  /**
-   * Attach to `onTouchStart` event.
-   */
-  onTouchStart: (e: ReactTouchEvent | TouchEvent) => void;
-
-  /**
-   * Attach to `onMouseUp` event.
-   */
-  onMouseUp: (e: ReactMouseEvent | TouchEvent) => void;
-
-  /**
-   * Attach to `onMouseLeave` event.
-   */
-  onMouseLeave: (e: ReactMouseEvent | TouchEvent) => void;
-
-  /**
-   * Attach to `onTouchEnd` event.
-   */
-  onTouchEnd: (e: ReactTouchEvent | TouchEvent) => void;
-
-  /**
-   * Attach to `onContextMenu` event to prevent the native context menu.
-   */
-  onContextMenu: (e: MouseEvent) => void;
+    /**
+     * Attach to `onMouseDown` event.
+     */
+    onMouseDown: (e: LongPressEvent) => void;
+    /**
+     * Attach to `onTouchStart` event.
+     */
+    onTouchStart: (e: LongPressEvent) => void;
+    /**
+     * Attach to `onMouseUp` event.
+     */
+    onMouseUp: (e: LongPressEvent) => void;
+    /**
+     * Attach to `onMouseLeave` event.
+     */
+    onMouseLeave: (e: LongPressEvent) => void;
+    /**
+     * Attach to `onTouchEnd` event.
+     */
+    onTouchEnd: (e: LongPressEvent) => void;
+    /**
+     * Attach to `onContextMenu` event to prevent the native context menu.
+     */
+    onContextMenu: (e: ReactMouseEvent) => void;
 }
-
+/**
+ * Configuration and lifecycle callbacks for a long press interaction.
+ */
 export interface UseLongPressOptions {
-  /**
-   * Duration in milliseconds to trigger long press.
-   * @default 1000
-   */
-  threshold?: number;
-
-  /**
-   * Called when the press starts.
-   */
-  onStart?: (e: ReactMouseEvent | ReactTouchEvent) => void;
-
-  /**
-   * Called when the long press completes.
-   */
-  onFinish?: (e: ReactMouseEvent | ReactTouchEvent) => void;
-
-  /**
-   * Called when the press is cancelled before the threshold.
-   */
-  onCancel?: (e: ReactMouseEvent | ReactTouchEvent) => void;
+    /**
+     * Duration in milliseconds to trigger long press.
+     * @default 1000
+     */
+    threshold?: number;
+    /**
+     * Called when the press starts.
+     */
+    onStart?: (e: LongPressEvent) => void;
+    /**
+     * Called when the long press completes.
+     */
+    onFinish?: (e: LongPressEvent) => void;
+    /**
+     * Called when the press is cancelled before the threshold.
+     */
+    onCancel?: (e: LongPressEvent) => void;
 }
-
 /**
  * Custom hook to handle long press interactions.
- *
  * @param callback Function to call on long press.
  * @param options Configuration and lifecycle callbacks.
  * @returns An object containing event handlers for mouse and touch events.
  */
-export default function useLongPress(
-  callback: (e: ReactMouseEvent | ReactTouchEvent) => void,
-  options?: UseLongPressOptions
-): LongPressHandlers;
+export default function useLongPress(callback: (e: LongPressEvent) => void, options?: UseLongPressOptions): LongPressHandlers;
+//# sourceMappingURL=useLongPress.d.ts.map

package/core/hooks/events/useLongPress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLongPress.d.ts","sourceRoot":"","sources":["../../../../core/hooks/events/useLongPress.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,IAAI,eAAe,EAAE,UAAU,IAAI,eAAe,EAAE,MAAM,OAAO,CAAC;AAE1F;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG,eAAe,GAAG,eAAe,CAAC;AAE/D;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC;;OAEG;IACH,WAAW,EAAE,CAAC,CAAC,EAAE,cAAc,KAAK,IAAI,CAAC;IAEzC;;OAEG;IACH,YAAY,EAAE,CAAC,CAAC,EAAE,cAAc,KAAK,IAAI,CAAC;IAE1C;;OAEG;IACH,SAAS,EAAE,CAAC,CAAC,EAAE,cAAc,KAAK,IAAI,CAAC;IAEvC;;OAEG;IACH,YAAY,EAAE,CAAC,CAAC,EAAE,cAAc,KAAK,IAAI,CAAC;IAE1C;;OAEG;IACH,UAAU,EAAE,CAAC,CAAC,EAAE,cAAc,KAAK,IAAI,CAAC;IAExC;;OAEG;IACH,aAAa,EAAE,CAAC,CAAC,EAAE,eAAe,KAAK,IAAI,CAAC;CAC7C;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,OAAO,CAAC,EAAE,CAAC,CAAC,EAAE,cAAc,KAAK,IAAI,CAAC;IAEtC;;OAEG;IACH,QAAQ,CAAC,EAAE,CAAC,CAAC,EAAE,cAAc,KAAK,IAAI,CAAC;IAEvC;;OAEG;IACH,QAAQ,CAAC,EAAE,CAAC,CAAC,EAAE,cAAc,KAAK,IAAI,CAAC;CACxC;AAUD;;;;;GAKG;AACH,MAAM,CAAC,OAAO,UAAU,YAAY,CAClC,QAAQ,EAAE,CAAC,CAAC,EAAE,cAAc,KAAK,IAAI,EACrC,OAAO,GAAE,mBAAwB,GAChC,iBAAiB,CA4CnB"}

package/core/hooks/events/useLongPress.js

@@ -1,32 +1,39 @@
-// @ts-check
 import { useRef, useCallback } from 'react';
 
-/** @typedef {import('./useLongPress').LongPressHandlers} LongPressHandlers */
-/** @typedef {import('./useLongPress').UseLongPressOptions} UseLongPressOptions */
+/**
+ * The events a long press interaction can originate from. The handlers below are spread onto an
+ * element, so these are React's synthetic events rather than the DOM ones.
+ */
+
+/**
+ * Event handlers to spread onto the element that should react to a long press.
+ */
+
+/**
+ * Configuration and lifecycle callbacks for a long press interaction.
+ */
 
 /**
  * Prevents the default context menu from appearing on long press.
- * @param {MouseEvent} e The event object.
+ * @param e The event object.
  */
 const preventContextMenu = e => {
   e.preventDefault();
 };
 
-// eslint-disable-next-line valid-jsdoc
 /**
  * Custom hook to handle long press interactions.
- *
- * @param {(e: Event) => void} callback - Function to call on long press.
- * @param {UseLongPressOptions} [options={}] - Configuration and lifecycle callbacks.
- * @returns {LongPressHandlers} An object containing event handlers for mouse and touch events.
+ * @param callback Function to call on long press.
+ * @param options Configuration and lifecycle callbacks.
+ * @returns An object containing event handlers for mouse and touch events.
  */
-export default function useLongPress(callback, {
-  threshold = 1000,
-  onStart,
-  onFinish,
-  onCancel
-} = {}) {
-  /** @type {import('react').MutableRefObject<number | undefined>} */
+export default function useLongPress(callback, options = {}) {
+  const {
+    threshold = 1000,
+    onStart,
+    onFinish,
+    onCancel
+  } = options;
   const timerRef = useRef(undefined);
   const triggeredRef = useRef(false);
   const start = useCallback(e => {

package/core/hooks/events/usePressHandler.d.ts

@@ -1,30 +1,43 @@
-export default usePressHandler;
-export type PressHandlers = {
+import type { KeyboardEvent as ReactKeyboardEvent, MouseEvent as ReactMouseEvent } from 'react';
+/**
+ * The events that can activate a pressable element.
+ */
+export type PressEvent = ReactMouseEvent | ReactKeyboardEvent;
+/**
+ * Event handlers to spread onto the element that should react to a press.
+ */
+export interface PressHandlers {
     /**
-     * - Click event handler.
+     * Click event handler.
      */
-    onClick: Function;
+    onClick: (e: ReactMouseEvent) => void;
     /**
-     * - Keydown handler for Enter/Space.
+     * Keydown handler for Enter/Space.
      */
-    onKeyDown: Function;
-};
+    onKeyDown: (e: ReactKeyboardEvent) => void;
+}
 /**
- * @typedef {Object} PressHandlers
- * @property {Function} onClick - Click event handler.
- * @property {Function} onKeyDown - Keydown handler for Enter/Space.
+ * Optional configuration for the press handlers.
  */
+export interface UsePressHandlerOptions {
+    /**
+     * Whether Space triggers the callback.
+     * @default true
+     */
+    triggerOnSpace?: boolean;
+    /**
+     * Whether Enter triggers the callback.
+     * @default false
+     */
+    triggerOnEnter?: boolean;
+}
 /**
  * Improves development for accessibility by simplifying registration of multiple
  * listeners (click, Enter, Space) to invoke the a callback when an element is
  * interacted with.
- *
- * @param {Function} onPress Callback to run when the element is interacted with
- * @param {Object} [options] Optional configuration
- * @param {boolean} [options.triggerOnSpace=true] Whether Space triggers onActivate
- * @param {boolean} [options.triggerOnEnter=false] Whether Enter triggers onActivate
- * @returns {PressHandlers} handlers - Event handlers to spread onto an element
- *
+ * @param onPress Callback to run when the element is interacted with.
+ * @param options Optional configuration.
+ * @returns Event handlers to spread onto an element.
  * @example
  * ```js
  * function MyPressableButton({ onActivate }) {
@@ -46,8 +59,6 @@ export type PressHandlers = {
  * }
  * ```
  */
-declare function usePressHandler(onPress: Function, options?: {
-    triggerOnSpace?: boolean | undefined;
-    triggerOnEnter?: boolean | undefined;
-}): PressHandlers;
+declare function usePressHandler(onPress: (e: PressEvent) => void, options?: UsePressHandlerOptions): PressHandlers;
+export default usePressHandler;
 //# sourceMappingURL=usePressHandler.d.ts.map

package/core/hooks/events/usePressHandler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"usePressHandler.d.ts","sourceRoot":"","sources":["../../../../core/hooks/events/usePressHandler.js"],"names":[],"mappings":";;;;;;;;;;;AAEA;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,8DAzBG;IAA0B,cAAc;IACd,cAAc;CACxC,GAAU,aAAa,CA2DzB"}
+{"version":3,"file":"usePressHandler.d.ts","sourceRoot":"","sources":["../../../../core/hooks/events/usePressHandler.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,IAAI,kBAAkB,EAAE,UAAU,IAAI,eAAe,EAAE,MAAM,OAAO,CAAC;AAEhG;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,eAAe,GAAG,kBAAkB,CAAC;AAE9D;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B;;OAEG;IACH,OAAO,EAAE,CAAC,CAAC,EAAE,eAAe,KAAK,IAAI,CAAC;IACtC;;OAEG;IACH,SAAS,EAAE,CAAC,CAAC,EAAE,kBAAkB,KAAK,IAAI,CAAC;CAC5C;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,iBAAS,eAAe,CACtB,OAAO,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,IAAI,EAChC,OAAO,GAAE,sBAA2B,GACnC,aAAa,CAoCf;AAED,eAAe,eAAe,CAAC"}

package/core/hooks/events/usePressHandler.js

@@ -1,22 +1,24 @@
 import { useCallback } from 'react';
 
 /**
- * @typedef {Object} PressHandlers
- * @property {Function} onClick - Click event handler.
- * @property {Function} onKeyDown - Keydown handler for Enter/Space.
+ * The events that can activate a pressable element.
+ */
+
+/**
+ * Event handlers to spread onto the element that should react to a press.
+ */
+
+/**
+ * Optional configuration for the press handlers.
  */
 
 /**
  * Improves development for accessibility by simplifying registration of multiple
  * listeners (click, Enter, Space) to invoke the a callback when an element is
  * interacted with.
- *
- * @param {Function} onPress Callback to run when the element is interacted with
- * @param {Object} [options] Optional configuration
- * @param {boolean} [options.triggerOnSpace=true] Whether Space triggers onActivate
- * @param {boolean} [options.triggerOnEnter=false] Whether Enter triggers onActivate
- * @returns {PressHandlers} handlers - Event handlers to spread onto an element
- *
+ * @param onPress Callback to run when the element is interacted with.
+ * @param options Optional configuration.
+ * @returns Event handlers to spread onto an element.
  * @example
  * ```js
  * function MyPressableButton({ onActivate }) {