@koobiq/react-primitives 0.0.1-beta.3 → 0.0.1-beta.30

package/dist/behaviors/useButton.d.ts

@@ -2,11 +2,11 @@ import type { RefObject } from 'react';
 import type { ButtonOptions } from '../types';
 export type UseButtonProps = ButtonOptions;
 export declare function useButton(props: UseButtonProps, ref: RefObject<Element | null>): {
-    pressed: boolean;
-    hovered: boolean;
-    focused: boolean;
-    disabled: boolean | undefined;
-    buttonProps: import("@react-types/shared").DOMAttributes<import("@react-types/shared").FocusableElement>;
-    focusVisible: boolean;
+    isPressed: boolean;
+    isHovered: boolean;
+    isFocused: boolean;
+    isDisabled: boolean | undefined;
+    buttonProps: import("@react-types/shared").DOMAttributes<import("@react-types/shared").FocusableElement> & import("@react-types/shared").DOMAttributes<import("@react-types/shared").FocusableElement>;
+    isFocusVisible: boolean;
 };
 export type UseButtonReturn = ReturnType<typeof useButton>;

package/dist/behaviors/useButton.js

@@ -2,34 +2,23 @@
 import { useFocusRing, useHover, mergeProps } from "@koobiq/react-core";
 import { useButton as useButton$1 } from "@react-aria/button";
 function useButton(props, ref) {
-  const { onClick, onPress, disabled, ...otherProps } = props;
-  const {
-    focusProps,
-    isFocused: focused,
-    isFocusVisible: focusVisible
-  } = useFocusRing({
+  const { isDisabled } = props;
+  const { focusProps, isFocused, isFocusVisible } = useFocusRing({
     within: true
   });
-  const { hoverProps, isHovered: hovered } = useHover({
-    ...props,
-    isDisabled: disabled
-  });
-  const { buttonProps: commonButtonProps, isPressed: pressed } = useButton$1(
-    {
-      ...otherProps,
-      onPress: onPress || onClick,
-      isDisabled: disabled
-    },
+  const { hoverProps, isHovered } = useHover(props);
+  const { buttonProps: commonButtonProps, isPressed } = useButton$1(
+    props,
     ref
   );
   const buttonProps = mergeProps(commonButtonProps, focusProps, hoverProps);
   return {
-    pressed,
-    hovered,
-    focused,
-    disabled,
+    isPressed,
+    isHovered,
+    isFocused,
+    isDisabled,
     buttonProps,
-    focusVisible
+    isFocusVisible
   };
 }
 export {

package/dist/behaviors/useCheckbox.d.ts

@@ -1,56 +1,21 @@
 import type { RefObject } from 'react';
-import type { ExtendableProps } from '@koobiq/react-core';
 import type { AriaCheckboxProps } from '@react-aria/checkbox';
-export type UseCheckboxProps = ExtendableProps<{
-    /**
-     * If `true`, the component will indicate an error.
-     * @default false
-     * */
-    error?: boolean;
-    /**
-     * If `true`, the component is checked.
-     * @default false
-     * */
-    checked?: boolean;
-    /** It prevents the user from changing the value of the checkbox.
-     * @default false
-     */
-    readonly?: boolean;
-    /**
-     * If `true`, the component is disabled.
-     * @default false
-     * */
-    disabled?: boolean;
-    /**
-     * If `true`, the input element is required.
-     * @default false
-     * */
-    required?: boolean;
-    /**
-     * If `true`, the component appears indeterminate.
-     * @default false
-     * */
-    indeterminate?: boolean;
-    /** The default checked state. Use when the component is not controlled. */
-    defaultChecked?: boolean;
-    /** Callback fired when the state is changed. */
-    onChange?: (checked: boolean) => void;
-}, Omit<AriaCheckboxProps, 'onChange' | 'isRequired' | 'isInvalid' | 'isReadOnly' | 'isSelected' | 'isDisabled' | 'isIndeterminate' | 'defaultSelected'>>;
+export type UseCheckboxProps = AriaCheckboxProps;
 export declare function useCheckbox(props: UseCheckboxProps, inputRef: RefObject<HTMLInputElement | null>): {
     validationErrors: string[];
     validationDetails: ValidityState;
+    isInvalid: boolean;
+    isPressed: boolean;
+    isHovered: boolean;
+    isFocused: boolean;
+    isSelected: boolean;
+    isDisabled: boolean;
+    isReadOnly: boolean;
     labelProps: import("@react-types/shared").DOMAttributes<import("@react-types/shared").FocusableElement> & import("react").LabelHTMLAttributes<HTMLLabelElement>;
     inputProps: import("@react-types/shared").DOMAttributes<import("@react-types/shared").FocusableElement> & import("react").InputHTMLAttributes<HTMLInputElement> & {
         ref: RefObject<HTMLInputElement | null>;
     };
-    indeterminate: boolean | undefined;
-    error: boolean;
-    pressed: boolean;
-    hovered: boolean;
-    focused: boolean;
-    checked: boolean;
-    disabled: boolean;
-    readonly: boolean;
-    focusVisible: boolean;
+    isFocusVisible: boolean;
+    isIndeterminate: boolean | undefined;
 };
 export type UseCheckboxReturn = ReturnType<typeof useCheckbox>;

package/dist/behaviors/useCheckbox.js

@@ -1,24 +1,12 @@
 "use client";
-import { useToggleState, useHover, useFocusRing, mergeProps } from "@koobiq/react-core";
+import { useHover, useFocusRing, mergeProps } from "@koobiq/react-core";
 import { useCheckbox as useCheckbox$1 } from "@react-aria/checkbox";
+import { useToggleState } from "@react-stately/toggle";
 function useCheckbox(props, inputRef) {
-  const {
-    error,
-    checked,
-    disabled,
-    readonly,
-    required,
-    indeterminate,
-    defaultChecked,
-    onChange
-  } = props;
-  const state = useToggleState({
-    isSelected: checked,
-    defaultSelected: defaultChecked,
-    onChange
-  });
+  const { isDisabled: isDisabledProp, isIndeterminate: isIndeterminateProp } = props;
+  const state = useToggleState(props);
   const { hoverProps, isHovered } = useHover({
-    isDisabled: disabled
+    isDisabled: isDisabledProp
   });
   const { focusProps, isFocused, isFocusVisible } = useFocusRing();
   const {
@@ -30,34 +18,23 @@ function useCheckbox(props, inputRef) {
     isReadOnly,
     isPressed,
     ...other
-  } = useCheckbox$1(
-    {
-      ...props,
-      isInvalid: error,
-      isDisabled: disabled,
-      isIndeterminate: indeterminate,
-      isReadOnly: readonly,
-      isRequired: required
-    },
-    state,
-    inputRef
-  );
+  } = useCheckbox$1(props, state, inputRef);
   const labelProps = mergeProps(hoverProps, commonLabelProps);
   const inputProps = mergeProps(focusProps, commonInputProps, {
     ref: inputRef
   });
   return {
+    isInvalid,
+    isPressed,
+    isHovered,
+    isFocused,
+    isSelected,
+    isDisabled,
+    isReadOnly,
     labelProps,
     inputProps,
-    indeterminate,
-    error: isInvalid,
-    pressed: isPressed,
-    hovered: isHovered,
-    focused: isFocused,
-    checked: isSelected,
-    disabled: isDisabled,
-    readonly: isReadOnly,
-    focusVisible: isFocusVisible,
+    isFocusVisible,
+    isIndeterminate: isIndeterminateProp,
     ...other
   };
 }

package/dist/behaviors/useLink.d.ts

@@ -1,15 +1,11 @@
 import type { RefObject } from 'react';
-import type { ExtendableProps } from '@koobiq/react-core';
 import type { AriaLinkOptions } from '@react-aria/link';
-export type UseLinkProps = ExtendableProps<{
-    disabled?: boolean;
-    onClick?: AriaLinkOptions['onPress'];
-}, Omit<AriaLinkOptions, 'isDisabled'>>;
+export type UseLinkProps = AriaLinkOptions;
 export declare function useLink(props: UseLinkProps, ref: RefObject<HTMLElement | null>): {
     linkProps: import("@react-types/shared").DOMAttributes<import("@react-types/shared").FocusableElement>;
-    pressed: boolean;
-    hovered: boolean;
-    focused: boolean;
-    focusVisible: boolean;
+    isPressed: boolean;
+    isHovered: boolean;
+    isFocused: boolean;
+    isFocusVisible: boolean;
 };
 export type UseLinkReturn = ReturnType<typeof useLink>;

package/dist/behaviors/useLink.js

@@ -2,32 +2,23 @@
 import { useHover, useFocusRing, mergeProps } from "@koobiq/react-core";
 import { useLink as useLink$1 } from "@react-aria/link";
 function useLink(props, ref) {
-  const { disabled, onClick, ...otherProps } = props;
-  const { hoverProps, isHovered } = useHover({
-    ...otherProps,
-    isDisabled: disabled
-  });
+  const { hoverProps, isHovered } = useHover(props);
   const { focusProps, isFocused, isFocusVisible } = useFocusRing();
   const { linkProps: commonLinkProps, isPressed } = useLink$1(
-    {
-      ...otherProps,
-      onPress: onClick,
-      isDisabled: disabled
-    },
+    props,
     ref
   );
   const linkProps = mergeProps(
-    { disabled },
+    commonLinkProps,
     focusProps,
-    hoverProps,
-    commonLinkProps
+    hoverProps
   );
   return {
     linkProps,
-    pressed: isPressed,
-    hovered: isHovered,
-    focused: isFocused,
-    focusVisible: isFocusVisible
+    isPressed,
+    isHovered,
+    isFocused,
+    isFocusVisible
   };
 }
 export {