@bento/pressable 0.1.3 → 0.1.5

package/README.md

@@ -24,7 +24,7 @@ The following properties are available to be used on the `Pressable` primitive:
 
 | Prop | Type | Required | Description |
 |------|------|----------|------------|
-| `children` | `ReactElement<any, string \| JSXElementConstructor<any>>` | Yes | A single React element that will be made pressable. |
+| `children` | `React.ReactElement` | Yes | A single React element that will be made pressable. |
 | `onPress` | `(e: PressEvent) => void` | No | Handler that is called when the pressable is pressed.
 Similar to the standard `onClick` event, but normalized to handle all interaction methods consistently. |
 | `onPressStart` | `(e: PressEvent) => void` | No | Handler that is called when a press interaction starts. |
@@ -33,10 +33,6 @@ over the target or when the pointer leaves the target. |
 | `onPressChange` | `(isPressed: boolean) => void` | No | Handler that is called when the press state changes. |
 | `onPressUp` | `(e: PressEvent) => void` | No | Handler that is called when a press is released over the target, regardless of
 whether it started on the target or not. |
-| `slot` | `string` | No | A named part of a component that can be customized. This is implemented by the consuming component.
-The exposed slot names of a component are available in the components documentation. |
-| `slots` | `Record<string, object \| Function>` | No | An object that contains the customizations for the slots.
-The main way you interact with the slot system as a consumer. |
 
 For all other properties specified on the `Pressable` primitive, the component will pass them down to the direct child element of the component. Which would be the equivalent of you adding them directly to the child element.
 

package/dist/index.cjs

@@ -1,46 +1,85 @@
-'use strict';
-
-var reactAria = require('react-aria');
-var utils = require('@react-aria/utils');
-var useDataAttributes = require('@bento/use-data-attributes');
-var useProps = require('@bento/use-props');
-var slots = require('@bento/slots');
-var React = require('react');
-var style = require('./pressable.module-JXZDAJ3U.module.css');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-var React__default = /*#__PURE__*/_interopDefault(React);
-var style__default = /*#__PURE__*/_interopDefault(style);
-
-// src/index.tsx
-var Pressable = slots.withSlots("BentoPressable", function Pressable2(args) {
-  const { props, apply } = useProps.useProps(args);
-  const ref = React.useRef(null);
-  const { children, ...restProps } = props;
-  const child = React__default.default.Children.only(children);
-  const { focusableProps } = reactAria.useFocusable(restProps, ref);
-  const { focusProps, isFocused, isFocusVisible } = reactAria.useFocusRing(restProps);
-  const { hoverProps, isHovered } = reactAria.useHover(restProps);
-  const { pressProps, isPressed } = reactAria.usePress({ ...restProps, ref });
-  return React__default.default.cloneElement(child, {
-    ...apply(
-      {
-        ...reactAria.mergeProps(pressProps, focusProps, focusableProps, hoverProps),
-        className: style__default.default.pressable
-      },
-      ["onPress", "onPressStart", "onPressEnd", "onPressUp", "onPressChange", "children"]
-    ),
-    ...useDataAttributes.useDataAttributes({
-      pressed: isPressed,
-      hovered: isHovered,
-      focused: isFocused,
-      focusVisible: isFocusVisible
-    }),
-    ref: utils.mergeRefs(child.ref, ref)
-  });
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let react_aria = require("react-aria");
+let _react_aria_utils = require("@react-aria/utils");
+let _bento_use_data_attributes = require("@bento/use-data-attributes");
+let _bento_use_props = require("@bento/use-props");
+let _bento_slots = require("@bento/slots");
+let react = require("react");
+react = __toESM(react);
+//#region src/pressable.module.css
+var pressable_module_default = { "pressable": "rYyWlq_pressable" };
+//#endregion
+//#region src/index.tsx
+/**
+*
+* A behavioral primitive that can be used to make any element pressable while maintaining
+* consistent behavior across devices (mouse, touch, keyboard). It handles edge cases like
+* touch movement and quick releases, and provides proper ARIA attributes for accessibility.
+*
+* @example
+* ```tsx
+* // Make a div pressable
+* <Pressable onPress={handlePress}>
+*   <div>Click here</div>
+* </Pressable>
+* ```
+*/
+const Pressable = (0, _bento_slots.withSlots)("BentoPressable", function Pressable(args) {
+	const { props, apply } = (0, _bento_use_props.useProps)(args);
+	const ref = (0, react.useRef)(null);
+	const { children, ...restProps } = props;
+	const child = react.default.Children.only(children);
+	const { focusableProps } = (0, react_aria.useFocusable)(restProps, ref);
+	const { focusProps, isFocused, isFocusVisible } = (0, react_aria.useFocusRing)(restProps);
+	const { hoverProps, isHovered } = (0, react_aria.useHover)(restProps);
+	const { pressProps, isPressed } = (0, react_aria.usePress)({
+		...restProps,
+		ref
+	});
+	return react.default.cloneElement(child, {
+		...apply({
+			...(0, react_aria.mergeProps)(pressProps, focusProps, focusableProps, hoverProps),
+			className: pressable_module_default.pressable
+		}, [
+			"onPress",
+			"onPressStart",
+			"onPressEnd",
+			"onPressUp",
+			"onPressChange",
+			"children"
+		]),
+		...(0, _bento_use_data_attributes.useDataAttributes)({
+			pressed: isPressed,
+			hovered: isHovered,
+			focused: isFocused,
+			focusVisible: isFocusVisible
+		}),
+		ref: (0, _react_aria_utils.mergeRefs)(child.ref, ref)
+	});
 });
-
+//#endregion
 exports.Pressable = Pressable;
-//# sourceMappingURL=index.cjs.map
+
 //# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.tsx"],"names":["withSlots","Pressable","useProps","useRef","React","useFocusable","useFocusRing","useHover","usePress","mergeProps","style","useDataAttributes","mergeRefs"],"mappings":";;;;;;;;;;;;;;;;AA2DO,IAAM,SAAA,GAAYA,eAAA,CAAU,gBAAA,EAAkB,SAASC,WAAU,IAAA,EAAsB;AAC5F,EAAA,MAAM,EAAE,KAAA,EAAO,KAAA,EAAM,GAAIC,kBAAS,IAAI,CAAA;AACtC,EAAA,MAAM,GAAA,GAAMC,aAA2B,IAAI,CAAA;AAC3C,EAAA,MAAM,EAAE,QAAA,EAAU,GAAG,SAAA,EAAU,GAAI,KAAA;AACnC,EAAA,MAAM,KAAA,GAAQC,sBAAA,CAAM,QAAA,CAAS,IAAA,CAAK,QAAQ,CAAA;AAC1C,EAAA,MAAM,EAAE,cAAA,EAAe,GAAIC,sBAAA,CAAa,WAAW,GAAG,CAAA;AACtD,EAAA,MAAM,EAAE,UAAA,EAAY,SAAA,EAAW,cAAA,EAAe,GAAIC,uBAAa,SAAS,CAAA;AACxE,EAAA,MAAM,EAAE,UAAA,EAAY,SAAA,EAAU,GAAIC,mBAAS,SAAS,CAAA;AACpD,EAAA,MAAM,EAAE,YAAY,SAAA,EAAU,GAAIC,mBAAS,EAAE,GAAG,SAAA,EAAW,GAAA,EAAK,CAAA;AAEhE,EAAA,OAAOJ,sBAAA,CAAM,aAAa,KAAA,EAAO;AAAA,IAC/B,GAAG,KAAA;AAAA,MACD;AAAA,QACE,GAAGK,oBAAA,CAAW,UAAA,EAAY,UAAA,EAAY,gBAAgB,UAAU,CAAA;AAAA,QAChE,WAAWC,sBAAA,CAAM;AAAA,OACnB;AAAA,MACA,CAAC,SAAA,EAAW,cAAA,EAAgB,YAAA,EAAc,WAAA,EAAa,iBAAiB,UAAU;AAAA,KACpF;AAAA,IACA,GAAGC,mCAAA,CAAkB;AAAA,MACnB,OAAA,EAAS,SAAA;AAAA,MACT,OAAA,EAAS,SAAA;AAAA,MACT,OAAA,EAAS,SAAA;AAAA,MACT,YAAA,EAAc;AAAA,KACf,CAAA;AAAA,IACD,GAAA,EAAKC,eAAA,CAAW,KAAA,CAA2C,GAAA,EAAK,GAAG;AAAA,GACpE,CAAA;AACH,CAAC","file":"index.cjs","sourcesContent":["import {\n  usePress,\n  useFocusRing,\n  useHover,\n  mergeProps,\n  type PressProps,\n  useFocusable,\n  type PressEvent\n} from 'react-aria';\nimport { mergeRefs } from '@react-aria/utils';\nimport { useDataAttributes } from '@bento/use-data-attributes';\nimport { useProps } from '@bento/use-props';\nimport { withSlots } from '@bento/slots';\nimport React, { type HTMLAttributes, useRef } from 'react';\nimport style from './pressable.module.css';\n\nexport interface PressableProps extends PressProps, Omit<HTMLAttributes<HTMLElement>, keyof PressProps> {\n  /** A single React element that will be made pressable. */\n  children: React.ReactElement;\n\n  /**\n   * Handler that is called when the pressable is pressed.\n   * Similar to the standard `onClick` event, but normalized to handle all interaction methods consistently.\n   */\n  onPress?: (e: PressEvent) => void;\n\n  /** Handler that is called when a press interaction starts. */\n  onPressStart?: (e: PressEvent) => void;\n\n  /**\n   * Handler that is called when a press interaction ends, either\n   * over the target or when the pointer leaves the target.\n   */\n  onPressEnd?: (e: PressEvent) => void;\n\n  /** Handler that is called when the press state changes. */\n  onPressChange?: (isPressed: boolean) => void;\n\n  /**\n   * Handler that is called when a press is released over the target, regardless of\n   * whether it started on the target or not.\n   */\n  onPressUp?: (e: PressEvent) => void;\n}\n\n/**\n *\n * A behavioral primitive that can be used to make any element pressable while maintaining\n * consistent behavior across devices (mouse, touch, keyboard). It handles edge cases like\n * touch movement and quick releases, and provides proper ARIA attributes for accessibility.\n *\n * @example\n * ```tsx\n * // Make a div pressable\n * <Pressable onPress={handlePress}>\n *   <div>Click here</div>\n * </Pressable>\n * ```\n */\nexport const Pressable = withSlots('BentoPressable', function Pressable(args: PressableProps) {\n  const { props, apply } = useProps(args);\n  const ref = useRef<HTMLElement | null>(null);\n  const { children, ...restProps } = props;\n  const child = React.Children.only(children);\n  const { focusableProps } = useFocusable(restProps, ref);\n  const { focusProps, isFocused, isFocusVisible } = useFocusRing(restProps);\n  const { hoverProps, isHovered } = useHover(restProps);\n  const { pressProps, isPressed } = usePress({ ...restProps, ref });\n\n  return React.cloneElement(child, {\n    ...apply(\n      {\n        ...mergeProps(pressProps, focusProps, focusableProps, hoverProps),\n        className: style.pressable\n      },\n      ['onPress', 'onPressStart', 'onPressEnd', 'onPressUp', 'onPressChange', 'children']\n    ),\n    ...useDataAttributes({\n      pressed: isPressed,\n      hovered: isHovered,\n      focused: isFocused,\n      focusVisible: isFocusVisible\n    }),\n    ref: mergeRefs((child as { ref?: React.Ref<HTMLElement> }).ref, ref)\n  });\n});\n"]}
+{"version":3,"file":"index.cjs","names":["React","style"],"sources":["../src/pressable.module.css","../src/index.tsx"],"sourcesContent":[".pressable {\n  display: inline-flex;\n  appearance: none;\n}\n","import {\n  usePress,\n  useFocusRing,\n  useHover,\n  mergeProps,\n  type PressProps,\n  useFocusable,\n  type PressEvent\n} from 'react-aria';\nimport { mergeRefs } from '@react-aria/utils';\nimport { useDataAttributes } from '@bento/use-data-attributes';\nimport { useProps } from '@bento/use-props';\nimport { withSlots } from '@bento/slots';\nimport React, { type HTMLAttributes, useRef } from 'react';\nimport style from './pressable.module.css';\n\nexport interface PressableProps extends PressProps, Omit<HTMLAttributes<HTMLElement>, keyof PressProps> {\n  /** A single React element that will be made pressable. */\n  children: React.ReactElement;\n\n  /**\n   * Handler that is called when the pressable is pressed.\n   * Similar to the standard `onClick` event, but normalized to handle all interaction methods consistently.\n   */\n  onPress?: (e: PressEvent) => void;\n\n  /** Handler that is called when a press interaction starts. */\n  onPressStart?: (e: PressEvent) => void;\n\n  /**\n   * Handler that is called when a press interaction ends, either\n   * over the target or when the pointer leaves the target.\n   */\n  onPressEnd?: (e: PressEvent) => void;\n\n  /** Handler that is called when the press state changes. */\n  onPressChange?: (isPressed: boolean) => void;\n\n  /**\n   * Handler that is called when a press is released over the target, regardless of\n   * whether it started on the target or not.\n   */\n  onPressUp?: (e: PressEvent) => void;\n}\n\n/**\n *\n * A behavioral primitive that can be used to make any element pressable while maintaining\n * consistent behavior across devices (mouse, touch, keyboard). It handles edge cases like\n * touch movement and quick releases, and provides proper ARIA attributes for accessibility.\n *\n * @example\n * ```tsx\n * // Make a div pressable\n * <Pressable onPress={handlePress}>\n *   <div>Click here</div>\n * </Pressable>\n * ```\n */\nexport const Pressable = withSlots('BentoPressable', function Pressable(args: PressableProps) {\n  const { props, apply } = useProps(args);\n  const ref = useRef<HTMLElement | null>(null);\n  const { children, ...restProps } = props;\n  const child = React.Children.only(children);\n  const { focusableProps } = useFocusable(restProps, ref);\n  const { focusProps, isFocused, isFocusVisible } = useFocusRing(restProps);\n  const { hoverProps, isHovered } = useHover(restProps);\n  const { pressProps, isPressed } = usePress({ ...restProps, ref });\n\n  return React.cloneElement(child, {\n    ...apply(\n      {\n        ...mergeProps(pressProps, focusProps, focusableProps, hoverProps),\n        className: style.pressable\n      },\n      ['onPress', 'onPressStart', 'onPressEnd', 'onPressUp', 'onPressChange', 'children']\n    ),\n    ...useDataAttributes({\n      pressed: isPressed,\n      hovered: isHovered,\n      focused: isFocused,\n      focusVisible: isFocusVisible\n    }),\n    ref: mergeRefs((child as { ref?: React.Ref<HTMLElement> }).ref, ref)\n  });\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,IAAA,2BAAE,EAAA,aAAgB,mBAAA;;;;;;;;;;;;;;;;;ACyDlB,MAAa,aAAA,GAAA,aAAA,WAAsB,kBAAkB,SAAS,UAAU,MAAsB;CAC5F,MAAM,EAAE,OAAO,WAAA,GAAA,iBAAA,UAAmB,IAAI;CACtC,MAAM,OAAA,GAAA,MAAA,QAAiC,IAAI;CAC3C,MAAM,EAAE,UAAU,GAAG,cAAc;CACnC,MAAM,QAAQA,MAAAA,QAAM,SAAS,KAAK,QAAQ;CAC1C,MAAM,EAAE,oBAAA,GAAA,WAAA,cAAgC,WAAW,GAAG;CACtD,MAAM,EAAE,YAAY,WAAW,oBAAA,GAAA,WAAA,cAAgC,SAAS;CACxE,MAAM,EAAE,YAAY,eAAA,GAAA,WAAA,UAAuB,SAAS;CACpD,MAAM,EAAE,YAAY,eAAA,GAAA,WAAA,UAAuB;EAAE,GAAG;EAAW;CAAI,CAAC;CAEhE,OAAOA,MAAAA,QAAM,aAAa,OAAO;EAC/B,GAAG,MACD;GACE,IAAA,GAAA,WAAA,YAAc,YAAY,YAAY,gBAAgB,UAAU;GAChE,WAAWC,yBAAM;EACnB,GACA;GAAC;GAAW;GAAgB;GAAc;GAAa;GAAiB;EAAU,CACpF;EACA,IAAA,GAAA,2BAAA,mBAAqB;GACnB,SAAS;GACT,SAAS;GACT,SAAS;GACT,cAAc;EAChB,CAAC;EACD,MAAA,GAAA,kBAAA,WAAgB,MAA2C,KAAK,GAAG;CACrE,CAAC;AACH,CAAC"}

package/dist/index.d.cts

@@ -1,29 +1,29 @@
-import * as _bento_slots from '@bento/slots';
-import { PressProps, PressEvent } from 'react-aria';
-import React, { HTMLAttributes } from 'react';
+import { PressEvent, PressProps } from "react-aria";
+import React, { HTMLAttributes } from "react";
 
+//#region src/index.d.ts
 interface PressableProps extends PressProps, Omit<HTMLAttributes<HTMLElement>, keyof PressProps> {
-    /** A single React element that will be made pressable. */
-    children: React.ReactElement;
-    /**
-     * Handler that is called when the pressable is pressed.
-     * Similar to the standard `onClick` event, but normalized to handle all interaction methods consistently.
-     */
-    onPress?: (e: PressEvent) => void;
-    /** Handler that is called when a press interaction starts. */
-    onPressStart?: (e: PressEvent) => void;
-    /**
-     * Handler that is called when a press interaction ends, either
-     * over the target or when the pointer leaves the target.
-     */
-    onPressEnd?: (e: PressEvent) => void;
-    /** Handler that is called when the press state changes. */
-    onPressChange?: (isPressed: boolean) => void;
-    /**
-     * Handler that is called when a press is released over the target, regardless of
-     * whether it started on the target or not.
-     */
-    onPressUp?: (e: PressEvent) => void;
+  /** A single React element that will be made pressable. */
+  children: React.ReactElement;
+  /**
+   * Handler that is called when the pressable is pressed.
+   * Similar to the standard `onClick` event, but normalized to handle all interaction methods consistently.
+   */
+  onPress?: (e: PressEvent) => void;
+  /** Handler that is called when a press interaction starts. */
+  onPressStart?: (e: PressEvent) => void;
+  /**
+   * Handler that is called when a press interaction ends, either
+   * over the target or when the pointer leaves the target.
+   */
+  onPressEnd?: (e: PressEvent) => void;
+  /** Handler that is called when the press state changes. */
+  onPressChange?: (isPressed: boolean) => void;
+  /**
+   * Handler that is called when a press is released over the target, regardless of
+   * whether it started on the target or not.
+   */
+  onPressUp?: (e: PressEvent) => void;
 }
 /**
  *
@@ -39,6 +39,7 @@ interface PressableProps extends PressProps, Omit<HTMLAttributes<HTMLElement>, k
  * </Pressable>
  * ```
  */
-declare const Pressable: React.MemoExoticComponent<React.ComponentType<PressableProps & _bento_slots.Slots>>;
-
-export { Pressable, type PressableProps };
+declare const Pressable: React.MemoExoticComponent<React.ComponentType<any>>;
+//#endregion
+export { Pressable, PressableProps };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/index.tsx"],"mappings":";;;;UAgBiB,cAAA,SAAuB,UAAA,EAAY,IAAA,CAAK,cAAA,CAAe,WAAA,SAAoB,UAAA;;EAE1F,QAAA,EAAU,KAAA,CAAM,YAAA;EAFc;;;;EAQ9B,OAAA,IAAW,CAAA,EAAG,UAAA;EANJ;EASV,YAAA,IAAgB,CAAA,EAAG,UAAA;EAAA;;;;EAMnB,UAAA,IAAc,CAAA,EAAG,UAAA;EAjBqC;EAoBtD,aAAA,IAAiB,SAAA;EApBqB;;;;EA0BtC,SAAA,IAAa,CAAA,EAAG,UAAA;AAAA;;;;;;;;;;;;;;;cAiBL,SAAA,EAAS,KAAA,CAAA,mBAAA,CAAA,KAAA,CAAA,aAAA"}

package/dist/index.d.mts

@@ -0,0 +1,45 @@
+import { PressEvent, PressProps } from "react-aria";
+import React, { HTMLAttributes } from "react";
+
+//#region src/index.d.ts
+interface PressableProps extends PressProps, Omit<HTMLAttributes<HTMLElement>, keyof PressProps> {
+  /** A single React element that will be made pressable. */
+  children: React.ReactElement;
+  /**
+   * Handler that is called when the pressable is pressed.
+   * Similar to the standard `onClick` event, but normalized to handle all interaction methods consistently.
+   */
+  onPress?: (e: PressEvent) => void;
+  /** Handler that is called when a press interaction starts. */
+  onPressStart?: (e: PressEvent) => void;
+  /**
+   * Handler that is called when a press interaction ends, either
+   * over the target or when the pointer leaves the target.
+   */
+  onPressEnd?: (e: PressEvent) => void;
+  /** Handler that is called when the press state changes. */
+  onPressChange?: (isPressed: boolean) => void;
+  /**
+   * Handler that is called when a press is released over the target, regardless of
+   * whether it started on the target or not.
+   */
+  onPressUp?: (e: PressEvent) => void;
+}
+/**
+ *
+ * A behavioral primitive that can be used to make any element pressable while maintaining
+ * consistent behavior across devices (mouse, touch, keyboard). It handles edge cases like
+ * touch movement and quick releases, and provides proper ARIA attributes for accessibility.
+ *
+ * @example
+ * ```tsx
+ * // Make a div pressable
+ * <Pressable onPress={handlePress}>
+ *   <div>Click here</div>
+ * </Pressable>
+ * ```
+ */
+declare const Pressable: React.MemoExoticComponent<React.ComponentType<any>>;
+//#endregion
+export { Pressable, PressableProps };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.tsx"],"mappings":";;;;UAgBiB,cAAA,SAAuB,UAAA,EAAY,IAAA,CAAK,cAAA,CAAe,WAAA,SAAoB,UAAA;;EAE1F,QAAA,EAAU,KAAA,CAAM,YAAA;EAFc;;;;EAQ9B,OAAA,IAAW,CAAA,EAAG,UAAA;EANJ;EASV,YAAA,IAAgB,CAAA,EAAG,UAAA;EAAA;;;;EAMnB,UAAA,IAAc,CAAA,EAAG,UAAA;EAjBqC;EAoBtD,aAAA,IAAiB,SAAA;EApBqB;;;;EA0BtC,SAAA,IAAa,CAAA,EAAG,UAAA;AAAA;;;;;;;;;;;;;;;cAiBL,SAAA,EAAS,KAAA,CAAA,mBAAA,CAAA,KAAA,CAAA,aAAA"}

package/dist/index.mjs

@@ -0,0 +1,61 @@
+import { mergeProps, useFocusRing, useFocusable, useHover, usePress } from "react-aria";
+import { mergeRefs } from "@react-aria/utils";
+import { useDataAttributes } from "@bento/use-data-attributes";
+import { useProps } from "@bento/use-props";
+import { withSlots } from "@bento/slots";
+import React, { useRef } from "react";
+//#region src/pressable.module.css
+var pressable_module_default = { "pressable": "rYyWlq_pressable" };
+//#endregion
+//#region src/index.tsx
+/**
+*
+* A behavioral primitive that can be used to make any element pressable while maintaining
+* consistent behavior across devices (mouse, touch, keyboard). It handles edge cases like
+* touch movement and quick releases, and provides proper ARIA attributes for accessibility.
+*
+* @example
+* ```tsx
+* // Make a div pressable
+* <Pressable onPress={handlePress}>
+*   <div>Click here</div>
+* </Pressable>
+* ```
+*/
+const Pressable = withSlots("BentoPressable", function Pressable(args) {
+	const { props, apply } = useProps(args);
+	const ref = useRef(null);
+	const { children, ...restProps } = props;
+	const child = React.Children.only(children);
+	const { focusableProps } = useFocusable(restProps, ref);
+	const { focusProps, isFocused, isFocusVisible } = useFocusRing(restProps);
+	const { hoverProps, isHovered } = useHover(restProps);
+	const { pressProps, isPressed } = usePress({
+		...restProps,
+		ref
+	});
+	return React.cloneElement(child, {
+		...apply({
+			...mergeProps(pressProps, focusProps, focusableProps, hoverProps),
+			className: pressable_module_default.pressable
+		}, [
+			"onPress",
+			"onPressStart",
+			"onPressEnd",
+			"onPressUp",
+			"onPressChange",
+			"children"
+		]),
+		...useDataAttributes({
+			pressed: isPressed,
+			hovered: isHovered,
+			focused: isFocused,
+			focusVisible: isFocusVisible
+		}),
+		ref: mergeRefs(child.ref, ref)
+	});
+});
+//#endregion
+export { Pressable };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["style"],"sources":["../src/pressable.module.css","../src/index.tsx"],"sourcesContent":[".pressable {\n  display: inline-flex;\n  appearance: none;\n}\n","import {\n  usePress,\n  useFocusRing,\n  useHover,\n  mergeProps,\n  type PressProps,\n  useFocusable,\n  type PressEvent\n} from 'react-aria';\nimport { mergeRefs } from '@react-aria/utils';\nimport { useDataAttributes } from '@bento/use-data-attributes';\nimport { useProps } from '@bento/use-props';\nimport { withSlots } from '@bento/slots';\nimport React, { type HTMLAttributes, useRef } from 'react';\nimport style from './pressable.module.css';\n\nexport interface PressableProps extends PressProps, Omit<HTMLAttributes<HTMLElement>, keyof PressProps> {\n  /** A single React element that will be made pressable. */\n  children: React.ReactElement;\n\n  /**\n   * Handler that is called when the pressable is pressed.\n   * Similar to the standard `onClick` event, but normalized to handle all interaction methods consistently.\n   */\n  onPress?: (e: PressEvent) => void;\n\n  /** Handler that is called when a press interaction starts. */\n  onPressStart?: (e: PressEvent) => void;\n\n  /**\n   * Handler that is called when a press interaction ends, either\n   * over the target or when the pointer leaves the target.\n   */\n  onPressEnd?: (e: PressEvent) => void;\n\n  /** Handler that is called when the press state changes. */\n  onPressChange?: (isPressed: boolean) => void;\n\n  /**\n   * Handler that is called when a press is released over the target, regardless of\n   * whether it started on the target or not.\n   */\n  onPressUp?: (e: PressEvent) => void;\n}\n\n/**\n *\n * A behavioral primitive that can be used to make any element pressable while maintaining\n * consistent behavior across devices (mouse, touch, keyboard). It handles edge cases like\n * touch movement and quick releases, and provides proper ARIA attributes for accessibility.\n *\n * @example\n * ```tsx\n * // Make a div pressable\n * <Pressable onPress={handlePress}>\n *   <div>Click here</div>\n * </Pressable>\n * ```\n */\nexport const Pressable = withSlots('BentoPressable', function Pressable(args: PressableProps) {\n  const { props, apply } = useProps(args);\n  const ref = useRef<HTMLElement | null>(null);\n  const { children, ...restProps } = props;\n  const child = React.Children.only(children);\n  const { focusableProps } = useFocusable(restProps, ref);\n  const { focusProps, isFocused, isFocusVisible } = useFocusRing(restProps);\n  const { hoverProps, isHovered } = useHover(restProps);\n  const { pressProps, isPressed } = usePress({ ...restProps, ref });\n\n  return React.cloneElement(child, {\n    ...apply(\n      {\n        ...mergeProps(pressProps, focusProps, focusableProps, hoverProps),\n        className: style.pressable\n      },\n      ['onPress', 'onPressStart', 'onPressEnd', 'onPressUp', 'onPressChange', 'children']\n    ),\n    ...useDataAttributes({\n      pressed: isPressed,\n      hovered: isHovered,\n      focused: isFocused,\n      focusVisible: isFocusVisible\n    }),\n    ref: mergeRefs((child as { ref?: React.Ref<HTMLElement> }).ref, ref)\n  });\n});\n"],"mappings":";;;;;;;AAEA,IAAA,2BAAE,EAAA,aAAgB,mBAAA;;;;;;;;;;;;;;;;;ACyDlB,MAAa,YAAY,UAAU,kBAAkB,SAAS,UAAU,MAAsB;CAC5F,MAAM,EAAE,OAAO,UAAU,SAAS,IAAI;CACtC,MAAM,MAAM,OAA2B,IAAI;CAC3C,MAAM,EAAE,UAAU,GAAG,cAAc;CACnC,MAAM,QAAQ,MAAM,SAAS,KAAK,QAAQ;CAC1C,MAAM,EAAE,mBAAmB,aAAa,WAAW,GAAG;CACtD,MAAM,EAAE,YAAY,WAAW,mBAAmB,aAAa,SAAS;CACxE,MAAM,EAAE,YAAY,cAAc,SAAS,SAAS;CACpD,MAAM,EAAE,YAAY,cAAc,SAAS;EAAE,GAAG;EAAW;CAAI,CAAC;CAEhE,OAAO,MAAM,aAAa,OAAO;EAC/B,GAAG,MACD;GACE,GAAG,WAAW,YAAY,YAAY,gBAAgB,UAAU;GAChE,WAAWA,yBAAM;EACnB,GACA;GAAC;GAAW;GAAgB;GAAc;GAAa;GAAiB;EAAU,CACpF;EACA,GAAG,kBAAkB;GACnB,SAAS;GACT,SAAS;GACT,SAAS;GACT,cAAc;EAChB,CAAC;EACD,KAAK,UAAW,MAA2C,KAAK,GAAG;CACrE,CAAC;AACH,CAAC"}

package/dist/{pressable.module-JXZDAJ3U.module.css → style.css}

@@ -1,4 +1,4 @@
-.pressable {
-  display: inline-flex;
+.rYyWlq_pressable {
   appearance: none;
+  display: inline-flex;
 }

package/package.json

@@ -1,22 +1,21 @@
 {
   "name": "@bento/pressable",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Pressable primitive provides consistent press interactions and accessibility features for building interactive components",
   "type": "module",
   "main": "./dist/index.cjs",
-  "module": "./dist/index.js",
+  "module": "./dist/index.mjs",
   "scripts": {
-    "build": "tsup-node",
-    "lint": "biome lint && tsc",
-    "posttest": "npm run lint",
-    "prepublishOnly": "node ../../scripts/compile-readme.ts",
-    "pretest": "npm run build",
+    "build": "tsdown",
+    "lint": "biome lint && tsgo --noEmit",
+    "prepublishOnly": "node ../../../scripts/compile-readme.ts",
     "test": "vitest --run",
-    "test:watch": "vitest"
+    "test:watch": "vitest",
+    "typecheck": "tsgo --noEmit -p tsconfig.json"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/godaddy/bento.git"
+    "url": "git+https://github.com/godaddy/antares.git"
   },
   "keywords": [
     "accessibility",
@@ -31,20 +30,28 @@
   "author": "GoDaddy Operating Company, LLC",
   "license": "MIT",
   "bugs": {
-    "url": "https://github.com/godaddy/bento/issues"
+    "url": "https://github.com/godaddy/antares/issues"
   },
-  "homepage": "https://github.com/godaddy/bento#readme",
+  "homepage": "https://github.com/godaddy/antares#readme",
   "files": [
     "dist",
     "src",
     "package.json"
   ],
   "dependencies": {
-    "@bento/slots": "^0.2.0",
+    "@bento/slots": "^0.3.0",
     "@bento/use-data-attributes": "^0.1.1",
-    "@bento/use-props": "^0.2.0",
-    "@react-aria/utils": "^3.30.0",
-    "react-aria": "^3.44.0"
+    "@bento/use-props": "^0.2.3",
+    "@react-aria/utils": "^3.34.0",
+    "react-aria": "^3.48.0"
+  },
+  "devDependencies": {
+    "@types/react": "^19.2.15",
+    "@types/react-dom": "^19.2.3",
+    "tsdown": "^0.22.1",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.7",
+    "vitest-browser-react": "^2.2.0"
   },
   "peerDependencies": {
     "react": "18.x || 19.x",
@@ -53,8 +60,8 @@
   "exports": {
     ".": {
       "import": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
       },
       "require": {
         "types": "./dist/index.d.cts",

package/src/css-modules.d.ts

@@ -0,0 +1,4 @@
+declare module '*.module.css' {
+  const classes: { [key: string]: string };
+  export default classes;
+}

package/dist/index.d.ts

@@ -1,44 +0,0 @@
-import * as _bento_slots from '@bento/slots';
-import { PressProps, PressEvent } from 'react-aria';
-import React, { HTMLAttributes } from 'react';
-
-interface PressableProps extends PressProps, Omit<HTMLAttributes<HTMLElement>, keyof PressProps> {
-    /** A single React element that will be made pressable. */
-    children: React.ReactElement;
-    /**
-     * Handler that is called when the pressable is pressed.
-     * Similar to the standard `onClick` event, but normalized to handle all interaction methods consistently.
-     */
-    onPress?: (e: PressEvent) => void;
-    /** Handler that is called when a press interaction starts. */
-    onPressStart?: (e: PressEvent) => void;
-    /**
-     * Handler that is called when a press interaction ends, either
-     * over the target or when the pointer leaves the target.
-     */
-    onPressEnd?: (e: PressEvent) => void;
-    /** Handler that is called when the press state changes. */
-    onPressChange?: (isPressed: boolean) => void;
-    /**
-     * Handler that is called when a press is released over the target, regardless of
-     * whether it started on the target or not.
-     */
-    onPressUp?: (e: PressEvent) => void;
-}
-/**
- *
- * A behavioral primitive that can be used to make any element pressable while maintaining
- * consistent behavior across devices (mouse, touch, keyboard). It handles edge cases like
- * touch movement and quick releases, and provides proper ARIA attributes for accessibility.
- *
- * @example
- * ```tsx
- * // Make a div pressable
- * <Pressable onPress={handlePress}>
- *   <div>Click here</div>
- * </Pressable>
- * ```
- */
-declare const Pressable: React.MemoExoticComponent<React.ComponentType<PressableProps & _bento_slots.Slots>>;
-
-export { Pressable, type PressableProps };

package/dist/index.js

@@ -1,39 +0,0 @@
-import { useFocusable, useFocusRing, useHover, usePress, mergeProps } from 'react-aria';
-import { mergeRefs } from '@react-aria/utils';
-import { useDataAttributes } from '@bento/use-data-attributes';
-import { useProps } from '@bento/use-props';
-import { withSlots } from '@bento/slots';
-import React, { useRef } from 'react';
-import style from './pressable.module-JXZDAJ3U.module.css';
-
-// src/index.tsx
-var Pressable = withSlots("BentoPressable", function Pressable2(args) {
-  const { props, apply } = useProps(args);
-  const ref = useRef(null);
-  const { children, ...restProps } = props;
-  const child = React.Children.only(children);
-  const { focusableProps } = useFocusable(restProps, ref);
-  const { focusProps, isFocused, isFocusVisible } = useFocusRing(restProps);
-  const { hoverProps, isHovered } = useHover(restProps);
-  const { pressProps, isPressed } = usePress({ ...restProps, ref });
-  return React.cloneElement(child, {
-    ...apply(
-      {
-        ...mergeProps(pressProps, focusProps, focusableProps, hoverProps),
-        className: style.pressable
-      },
-      ["onPress", "onPressStart", "onPressEnd", "onPressUp", "onPressChange", "children"]
-    ),
-    ...useDataAttributes({
-      pressed: isPressed,
-      hovered: isHovered,
-      focused: isFocused,
-      focusVisible: isFocusVisible
-    }),
-    ref: mergeRefs(child.ref, ref)
-  });
-});
-
-export { Pressable };
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/index.tsx"],"names":["Pressable"],"mappings":";;;;;;;;;AA2DO,IAAM,SAAA,GAAY,SAAA,CAAU,gBAAA,EAAkB,SAASA,WAAU,IAAA,EAAsB;AAC5F,EAAA,MAAM,EAAE,KAAA,EAAO,KAAA,EAAM,GAAI,SAAS,IAAI,CAAA;AACtC,EAAA,MAAM,GAAA,GAAM,OAA2B,IAAI,CAAA;AAC3C,EAAA,MAAM,EAAE,QAAA,EAAU,GAAG,SAAA,EAAU,GAAI,KAAA;AACnC,EAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,QAAA,CAAS,IAAA,CAAK,QAAQ,CAAA;AAC1C,EAAA,MAAM,EAAE,cAAA,EAAe,GAAI,YAAA,CAAa,WAAW,GAAG,CAAA;AACtD,EAAA,MAAM,EAAE,UAAA,EAAY,SAAA,EAAW,cAAA,EAAe,GAAI,aAAa,SAAS,CAAA;AACxE,EAAA,MAAM,EAAE,UAAA,EAAY,SAAA,EAAU,GAAI,SAAS,SAAS,CAAA;AACpD,EAAA,MAAM,EAAE,YAAY,SAAA,EAAU,GAAI,SAAS,EAAE,GAAG,SAAA,EAAW,GAAA,EAAK,CAAA;AAEhE,EAAA,OAAO,KAAA,CAAM,aAAa,KAAA,EAAO;AAAA,IAC/B,GAAG,KAAA;AAAA,MACD;AAAA,QACE,GAAG,UAAA,CAAW,UAAA,EAAY,UAAA,EAAY,gBAAgB,UAAU,CAAA;AAAA,QAChE,WAAW,KAAA,CAAM;AAAA,OACnB;AAAA,MACA,CAAC,SAAA,EAAW,cAAA,EAAgB,YAAA,EAAc,WAAA,EAAa,iBAAiB,UAAU;AAAA,KACpF;AAAA,IACA,GAAG,iBAAA,CAAkB;AAAA,MACnB,OAAA,EAAS,SAAA;AAAA,MACT,OAAA,EAAS,SAAA;AAAA,MACT,OAAA,EAAS,SAAA;AAAA,MACT,YAAA,EAAc;AAAA,KACf,CAAA;AAAA,IACD,GAAA,EAAK,SAAA,CAAW,KAAA,CAA2C,GAAA,EAAK,GAAG;AAAA,GACpE,CAAA;AACH,CAAC","file":"index.js","sourcesContent":["import {\n  usePress,\n  useFocusRing,\n  useHover,\n  mergeProps,\n  type PressProps,\n  useFocusable,\n  type PressEvent\n} from 'react-aria';\nimport { mergeRefs } from '@react-aria/utils';\nimport { useDataAttributes } from '@bento/use-data-attributes';\nimport { useProps } from '@bento/use-props';\nimport { withSlots } from '@bento/slots';\nimport React, { type HTMLAttributes, useRef } from 'react';\nimport style from './pressable.module.css';\n\nexport interface PressableProps extends PressProps, Omit<HTMLAttributes<HTMLElement>, keyof PressProps> {\n  /** A single React element that will be made pressable. */\n  children: React.ReactElement;\n\n  /**\n   * Handler that is called when the pressable is pressed.\n   * Similar to the standard `onClick` event, but normalized to handle all interaction methods consistently.\n   */\n  onPress?: (e: PressEvent) => void;\n\n  /** Handler that is called when a press interaction starts. */\n  onPressStart?: (e: PressEvent) => void;\n\n  /**\n   * Handler that is called when a press interaction ends, either\n   * over the target or when the pointer leaves the target.\n   */\n  onPressEnd?: (e: PressEvent) => void;\n\n  /** Handler that is called when the press state changes. */\n  onPressChange?: (isPressed: boolean) => void;\n\n  /**\n   * Handler that is called when a press is released over the target, regardless of\n   * whether it started on the target or not.\n   */\n  onPressUp?: (e: PressEvent) => void;\n}\n\n/**\n *\n * A behavioral primitive that can be used to make any element pressable while maintaining\n * consistent behavior across devices (mouse, touch, keyboard). It handles edge cases like\n * touch movement and quick releases, and provides proper ARIA attributes for accessibility.\n *\n * @example\n * ```tsx\n * // Make a div pressable\n * <Pressable onPress={handlePress}>\n *   <div>Click here</div>\n * </Pressable>\n * ```\n */\nexport const Pressable = withSlots('BentoPressable', function Pressable(args: PressableProps) {\n  const { props, apply } = useProps(args);\n  const ref = useRef<HTMLElement | null>(null);\n  const { children, ...restProps } = props;\n  const child = React.Children.only(children);\n  const { focusableProps } = useFocusable(restProps, ref);\n  const { focusProps, isFocused, isFocusVisible } = useFocusRing(restProps);\n  const { hoverProps, isHovered } = useHover(restProps);\n  const { pressProps, isPressed } = usePress({ ...restProps, ref });\n\n  return React.cloneElement(child, {\n    ...apply(\n      {\n        ...mergeProps(pressProps, focusProps, focusableProps, hoverProps),\n        className: style.pressable\n      },\n      ['onPress', 'onPressStart', 'onPressEnd', 'onPressUp', 'onPressChange', 'children']\n    ),\n    ...useDataAttributes({\n      pressed: isPressed,\n      hovered: isHovered,\n      focused: isFocused,\n      focusVisible: isFocusVisible\n    }),\n    ref: mergeRefs((child as { ref?: React.Ref<HTMLElement> }).ref, ref)\n  });\n});\n"]}