@jamsrui/hooks 0.0.17 → 0.0.18

package/dist/index.d.mts

@@ -0,0 +1,13 @@
+export { useControlled } from './use-controlled.mjs';
+export { useControlledState } from './use-controlled-state.mjs';
+export { useIsDisabled } from './use-disabled.mjs';
+export { useDisclosure } from './use-disclosure.mjs';
+export { useFocus } from './use-focus.mjs';
+export { useFocusVisible } from './use-focus-visible.mjs';
+export { useHover } from './use-hover.mjs';
+export { useMergeRefs } from './use-merge-refs.mjs';
+export { useIsMobile } from './use-mobile.mjs';
+export { usePress } from './use-press.mjs';
+export { useRenderElement } from './use-render-element.mjs';
+import 'react';
+import '@jamsrui/utils';

package/dist/use-callback-ref.d.mts

@@ -0,0 +1,7 @@
+/**
+ * A custom hook that converts a callback to a ref to avoid triggering re-renders when passed as a
+ * prop or avoid re-executing effects when passed as a dependency
+ */
+declare function useCallbackRef<T extends (...args: any[]) => any>(callback: T | undefined): T;
+
+export { useCallbackRef };

package/dist/use-controlled-state.d.mts

@@ -0,0 +1,9 @@
+import * as react from 'react';
+
+declare function useControlledState<T>({ defaultProp, onChange, prop, }: {
+    defaultProp?: T;
+    prop?: T;
+    onChange?: (state: T) => void;
+}): readonly [T, react.Dispatch<react.SetStateAction<T>>];
+
+export { useControlledState };

package/dist/use-controlled.d.mts

@@ -0,0 +1,21 @@
+interface UseControlledProps<T = unknown> {
+    /**
+     * Holds the component value when it's controlled.
+     */
+    controlled: T | undefined;
+    /**
+     * The default value when uncontrolled.
+     */
+    default: T | undefined;
+    /**
+     * The component name displayed in warnings.
+     */
+    name: string;
+    /**
+     * The name of the state variable displayed in warnings.
+     */
+    state?: string;
+}
+declare function useControlled<T = unknown>({ controlled, default: defaultProp, name, state, }: UseControlledProps<T>): [T, (newValue: T | ((prevValue: T) => T)) => void];
+
+export { type UseControlledProps, useControlled };

package/dist/use-disabled.d.mts

@@ -0,0 +1,12 @@
+import * as react from 'react';
+
+type UseIsDisableProps = {
+    isDisabled: boolean;
+    isFormControl: boolean;
+};
+declare const useIsDisabled: <T extends HTMLElement>(props: UseIsDisableProps) => {
+    ref: react.RefObject<T | null>;
+    isDisabled: boolean;
+};
+
+export { useIsDisabled };

package/dist/use-disclosure.d.mts

@@ -0,0 +1,11 @@
+import * as react from 'react';
+
+declare const useDisclosure: (defaultOpen?: boolean) => {
+    onToggle: () => void;
+    isOpen: boolean;
+    setIsOpen: react.Dispatch<react.SetStateAction<boolean>>;
+    onOpen: () => void;
+    onClose: () => void;
+};
+
+export { useDisclosure };

package/dist/use-focus-visible.d.mts

@@ -0,0 +1,11 @@
+import * as react from 'react';
+
+type UseFocusVisibleOptions = {
+    isDisabled?: boolean;
+};
+declare const useFocusVisible: <T extends HTMLElement>(options?: UseFocusVisibleOptions) => {
+    ref: react.RefObject<T | null>;
+    isFocusVisible: boolean;
+};
+
+export { type UseFocusVisibleOptions, useFocusVisible };

package/dist/use-focus.d.mts

@@ -0,0 +1,13 @@
+import * as react from 'react';
+
+declare const useFocus: <T extends HTMLElement>(props: useFocus.Props) => {
+    ref: react.RefObject<T | null>;
+    isFocused: boolean;
+};
+declare namespace useFocus {
+    interface Props {
+        isDisabled?: boolean;
+    }
+}
+
+export { useFocus };

package/dist/use-hover.d.mts

@@ -0,0 +1,13 @@
+import * as react from 'react';
+
+type UseHoverOptions = {
+    enterDelay?: number;
+    exitDelay?: number;
+    isDisabled?: boolean;
+};
+declare const useHover: <T extends HTMLElement>(options?: UseHoverOptions) => {
+    ref: react.RefObject<T | null>;
+    isHovered: boolean;
+};
+
+export { type UseHoverOptions, useHover };

package/dist/use-merge-refs.d.mts

@@ -0,0 +1,6 @@
+/**
+ * Merges an array of refs into a single memoized callback ref or `null`.
+ */
+declare function useMergeRefs<Instance>(refs: Array<React.Ref<Instance> | undefined>): null | React.RefCallback<Instance>;
+
+export { useMergeRefs };

package/dist/use-mobile.d.mts

@@ -0,0 +1,3 @@
+declare function useIsMobile(): boolean;
+
+export { useIsMobile };

package/dist/use-press.d.mts

@@ -0,0 +1,16 @@
+import * as react from 'react';
+
+declare function usePress(props?: {
+    isDisabled?: boolean;
+}): {
+    isPressed: boolean;
+    ref: react.RefObject<HTMLElement | null>;
+    isPressing: boolean;
+};
+declare namespace usePress {
+    interface UsePressProps {
+        isDisabled?: boolean;
+    }
+}
+
+export { usePress };

package/dist/use-render-element.d.mts

@@ -0,0 +1,15 @@
+import react__default from 'react';
+import { UIProps } from '@jamsrui/utils';
+
+declare const useRenderElement: <TagName extends keyof react__default.JSX.IntrinsicElements>(element: TagName, params: useRenderElement.Parameters<TagName>) => react__default.ReactElement;
+declare namespace useRenderElement {
+    interface Parameters<TagName extends keyof react__default.JSX.IntrinsicElements> {
+        props: UIProps<TagName> | UIProps<TagName>[];
+    }
+    interface ComponentProps {
+        className?: string;
+        render?: react__default.ReactElement;
+    }
+}
+
+export { useRenderElement };

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@jamsrui/hooks",
-  "version": "0.0.17",
+  "version": "0.0.18",
   "peerDependencies": {
     "react": ">=19"
   },
   "dependencies": {
-    "@jamsrui/utils": "^0.0.17"
+    "@jamsrui/utils": "^0.0.18"
   },
   "exports": {
     ".": {