@siberiacancode/reactuse 0.1.0 → 0.2.0

package/dist/esm/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/types/helpers/createContext/createContext.d.ts

@@ -0,0 +1,48 @@
+import { JSX, ReactNode } from 'react';
+/** The create context options type */
+export interface CreateContextOptions {
+    /** Display name for the context (useful for debugging) */
+    name?: string;
+    /** Whether to throw an error if context is used outside of Provider */
+    strict?: boolean;
+}
+/** The context value type */
+export interface ContextValue<Value> {
+    /** The context value */
+    value: Value | undefined;
+    /** The context set function */
+    set: (value: Value) => void;
+}
+/** The provider props type */
+export interface ProviderProps<Value> {
+    /** The children */
+    children: ReactNode;
+    /** The initial value */
+    initialValue?: Value;
+}
+/** The create context return type */
+export interface CreateContextReturn<Value> {
+    /** The context instance */
+    instance: React.Context<ContextValue<Value>>;
+    /** The provider component */
+    Provider: (props: ProviderProps<Value>) => JSX.Element;
+    /** The selector hook */
+    useSelect: {
+        <Selected>(selector: (value: Value) => Selected): Selected;
+        (): ContextValue<Value>;
+    };
+}
+/**
+ * @name createContext
+ * @description - Creates a typed context with additional utilities
+ * @category Helpers
+ *
+ * @template Value - The type of value that will be stored in the context
+ * @param {Value | undefined} [defaultValue] - Default value for the context
+ * @param {CreateContextOptions<Value>} [options] - Additional options for context creation
+ * @returns {CreateContextReturn<Value>} Object containing context utilities and components
+ *
+ * @example
+ * const { useSelect, instance, Provider } = createContext<number>(0);
+ */
+export declare const createContext: <Value>(defaultValue?: Value | undefined, options?: CreateContextOptions) => CreateContextReturn<Value>;

package/dist/types/helpers/createStore/createStore.d.ts

@@ -0,0 +1,31 @@
+type SetStateAction<Value> = ((prev: Value) => Value) | Value;
+type StateCreator<Value> = (set: (action: SetStateAction<Value>) => void, get: () => Value) => Value;
+export interface StoreApi<Value> {
+    getInitialState: () => Value;
+    getState: () => Value;
+    setState: (action: SetStateAction<Value>) => void;
+    subscribe: (listener: (state: Value, prevState: Value) => void) => () => void;
+}
+/**
+ * @name createStore
+ * @description - Creates a store with state management capabilities
+ * @category Helpers
+ *
+ * @template Value - The type of the store state
+ *
+ * @param {StateCreator<Value>} createState - Function that initializes the store state
+ * @returns {StoreApi<Value>} - Object containing store methods and hook for accessing state
+ *
+ * @example
+ * const { set, get, use, subscribe } = createStore((set) => ({
+ *   count: 0,
+ *   increment: () => set(state => ({ count: state.count + 1 }))
+ * }));
+ */
+export declare function createStore<Value>(createState: StateCreator<Value> | Value): {
+    set: (action: SetStateAction<Value>) => void;
+    get: () => Value;
+    use: <Selected>(selector: (state: Value) => Selected) => Selected;
+    subscribe: (listener: (state: Value, prevState: Value) => void) => () => boolean;
+};
+export {};

package/dist/types/helpers/index.d.ts

@@ -0,0 +1,2 @@
+export * from './createContext/createContext';
+export * from './createStore/createStore';

package/dist/types/hooks/index.d.ts

@@ -26,9 +26,11 @@ export * from './useDocumentEvent/useDocumentEvent';
 export * from './useDocumentTitle/useDocumentTitle';
 export * from './useDocumentVisibility/useDocumentVisibility';
 export * from './useDoubleClick/useDoubleClick';
+export * from './useDropZone/useDropZone';
 export * from './useElementSize/useElementSize';
 export * from './useEvent/useEvent';
 export * from './useEventListener/useEventListener';
+export * from './useEventSource/useEventSource';
 export * from './useEyeDropper/useEyeDropper';
 export * from './useFavicon/useFavicon';
 export * from './useField/useField';

package/dist/types/hooks/useClipboard/useClipboard.d.ts

@@ -21,6 +21,6 @@ export interface UseCopyToClipboardParams {
  * @returns {UseCopyToClipboardReturn} An object containing the boolean state value and utility functions to manipulate the state
  *
  * @example
- * const { supported, value, copy } = useClipboard();
+ * const { value, copy } = useClipboard();
  */
 export declare const useClipboard: (params?: UseCopyToClipboardParams) => UseCopyToClipboardReturn;

package/dist/types/hooks/useDropZone/useDropZone.d.ts

@@ -0,0 +1,80 @@
+import { HookTarget } from '../../utils/helpers';
+import { StateRef } from '../useRefState/useRefState';
+export type DropZoneDataTypes = ((types: string[]) => boolean) | string[];
+export interface UseDropZoneOptions {
+    /** The data types for drop zone */
+    dataTypes?: DropZoneDataTypes;
+    /** The multiple mode for drop zone */
+    multiple?: boolean;
+    /** The on drop callback */
+    onDrop?: (files: File[] | null, event: DragEvent) => void;
+    /** The on enter callback */
+    onEnter?: (event: DragEvent) => void;
+    /** The on leave callback */
+    onLeave?: (event: DragEvent) => void;
+    /** The on over callback */
+    onOver?: (event: DragEvent) => void;
+}
+export interface UseDropZoneReturn {
+    /** The files that was dropped in drop zone */
+    files: File[] | null;
+    /** The over drop zone status */
+    overed: boolean;
+}
+export interface UseDropZone {
+    (target: HookTarget, callback?: (files: File[] | null, event: DragEvent) => void): UseDropZoneReturn;
+    <Target extends Element>(callback?: (files: File[] | null, event: DragEvent) => void, target?: never): UseDropZoneReturn & {
+        ref: StateRef<Target>;
+    };
+    (target: HookTarget, options?: UseDropZoneOptions): UseDropZoneReturn;
+    <Target extends Element>(options?: UseDropZoneOptions, target?: never): UseDropZoneReturn & {
+        ref: StateRef<Target>;
+    };
+}
+/**
+ * @name useDropZone
+ * @description - Hook that provides drop zone functionality
+ * @category Elements
+ *
+ * @overload
+ * @template Target The target element
+ * @param {Target} target The target element drop zone's
+ * @param {DataTypes} [options.dataTypes] The data types
+ * @param {boolean} [options.multiple] The multiple mode
+ * @param {(files: File[] | null, event: DragEvent) => void} [options.onDrop] The on drop callback function
+ * @param {(event: DragEvent) => void} [options.onEnter] The on enter callback function
+ * @param {(event: DragEvent) => void} [options.onLeave] The on leave callback function
+ * @param {(event: DragEvent) => void} [options.onOver] The on over callback function
+ * @returns {[boolean, File[] | null]} The object with drop zone states
+ *
+ * @example
+ * const { overed, files } = useDropZone(ref, options);
+ *
+ * @overload
+ * @param {Target} target The target element drop zone's
+ * @param {(files: File[] | null, event: DragEvent) => void} [callback] The callback function to be invoked on drop
+ * @returns {[boolean, File[] | null]} The object with drop zone states
+ *
+ * @example
+ * const { overed, files } = useDropZone(ref, () => console.log('callback'));
+ *
+ * @overload
+ * @param {DataTypes} [options.dataTypes] The data types
+ * @param {boolean} [options.multiple] The multiple mode
+ * @param {(files: File[] | null, event: DragEvent) => void} [options.onDrop] The on drop callback function
+ * @param {(event: DragEvent) => void} [options.onEnter] The on enter callback function
+ * @param {(event: DragEvent) => void} [options.onLeave] The on leave callback function
+ * @param {(event: DragEvent) => void} [options.onOver] The on over callback function
+ * @returns {[StateRef<Target>, boolean, File[] | null]} The object with drop zone states and ref
+ *
+ * @example
+ * const { ref, overed, files } = useDropZone(options);
+ *
+ * @overload
+ * @param {(files: File[] | null, event: DragEvent) => void} [callback] The callback function to be invoked on drop
+ * @returns {[StateRef<Target>, boolean, File[] | null]} The object with drop zone states and ref
+ *
+ * @example
+ * const { ref, overed, files } = useDropZone(() => console.log('callback'));
+ */
+export declare const useDropZone: UseDropZone;

package/dist/types/hooks/useEventSource/useEventSource.d.ts

@@ -0,0 +1,47 @@
+/** The use event source options type */
+export interface UseEventSourceOptions<QueryData, Data> extends EventSourceInit {
+    /** Immediately open the connection when calling this hook */
+    immediately?: boolean;
+    placeholderData?: (() => Data) | Data;
+    retry?: boolean | number;
+    retryDelay?: ((retry: number, event: Event) => number) | number;
+    onError?: (error: Event) => void;
+    onMessage?: (event: Event & {
+        data?: Data;
+    }) => void;
+    onOpen?: () => void;
+    select?: (data: QueryData) => Data;
+}
+/** The use event source return type */
+interface UseEventSourceReturn<Data = any> {
+    /** The latest data received via the EventSource */
+    data?: Data;
+    /** The current error */
+    error?: Event;
+    /** The instance of the EventSource */
+    instance?: EventSource;
+    isConnecting: boolean;
+    isError: boolean;
+    isOpen: boolean;
+    /** Closes the EventSource connection gracefully */
+    close: () => void;
+    /** Reopen the EventSource connection */
+    open: () => void;
+}
+/**
+ * @name useEventSource
+ * @description - Hook that provides a reactive wrapper for event source
+ * @category Browser
+ *
+ * @browserapi EventSource https://developer.mozilla.org/en-US/docs/Web/API/EventSource
+ *
+ * @param {string | URL} url The URL of the EventSource
+ * @param {string[]} [events=[]] List of events to listen to
+ * @param {UseEventSourceOptions} [options={}] Configuration options
+ * @returns {UseEventSourceReturn<Data>} The EventSource state and controls
+ *
+ * @example
+ * const { instance, data, isConnecting, isOpen, isError, close, open } = useEventSource('url', ['message']);
+ */
+export declare const useEventSource: <QueryData = any, Data = QueryData>(url: string | URL, events?: string[], options?: UseEventSourceOptions<QueryData, Data>) => UseEventSourceReturn<Data>;
+export {};

package/dist/types/hooks/useHover/useHover.d.ts

@@ -7,11 +7,18 @@ export interface UseHoverOptions {
     /** The on leave callback */
     onLeave?: (event: Event) => void;
 }
+export interface UseHoverReturn {
+    value: boolean;
+}
 export interface UseHover {
     (target: HookTarget, callback?: (event: Event) => void): boolean;
     (target: HookTarget, options?: UseHoverOptions): boolean;
-    <Target extends Element>(callback?: (event: Event) => void, target?: never): [StateRef<Target>, boolean];
-    <Target extends Element>(options?: UseHoverOptions, target?: never): [StateRef<Target>, boolean];
+    <Target extends Element>(callback?: (event: Event) => void, target?: never): {
+        ref: StateRef<Target>;
+    } & UseHoverReturn;
+    <Target extends Element>(options?: UseHoverOptions, target?: never): {
+        ref: StateRef<Target>;
+    } & UseHoverReturn;
 }
 /**
  * @name useHover
@@ -38,7 +45,7 @@ export interface UseHover {
  * @overload
  * @template Target The target element
  * @param {(event: Event) => void} [callback] The callback function to be invoked on mouse enter
- * @returns {UseHoverReturn<Target>} The state of the hover
+ * @returns {{ ref: StateRef<Target> } & UseHoverReturn} The state of the hover
  *
  * @example
  * const [ref, hovering] = useHover(() => console.log('callback'));
@@ -47,7 +54,7 @@ export interface UseHover {
  * @template Target The target element
  * @param {(event: Event) => void} [options.onEntry] The callback function to be invoked on mouse enter
  * @param {(event: Event) => void} [options.onLeave] The callback function to be invoked on mouse leave
- * @returns {UseHoverReturn<Target>} The state of the hover
+ * @returns {{ ref: StateRef<Target> } & UseHoverReturn} The state of the hover
  *
  * @example
  * const [ref, hovering] = useHover(options);

package/dist/types/hooks/useIntersectionObserver/useIntersectionObserver.d.ts

@@ -29,7 +29,7 @@ export interface UseIntersectionObserver {
  * @param {boolean} [options.enabled=true] The IntersectionObserver options
  * @param {((entries: IntersectionObserverEntry[], observer: IntersectionObserver) => void) | undefined} [options.onChange] The callback to execute when intersection is detected
  * @param {HookTarget} [options.root] The root element to observe
- * @returns {UseIntersectionObserverReturn} An object containing the state and the supported status
+ * @returns {UseIntersectionObserverReturn} An object containing the state
  *
  * @example
  * const { ref, entry, inView } = useIntersectionObserver();

package/dist/types/hooks/useQuery/useQuery.d.ts

@@ -1,7 +1,6 @@
 import { DependencyList } from 'react';
 export interface UseQueryOptions<QueryData, Data> {
     enabled?: boolean;
-    initialData?: (() => Data) | Data;
     keys?: DependencyList;
     placeholderData?: (() => Data) | Data;
     refetchInterval?: number;

package/dist/types/index.d.ts

@@ -1,2 +1,3 @@
+export * from './helpers';
 export * from './hooks';
 export * from './utils/helpers';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@siberiacancode/reactuse",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "The ultimate collection of react hooks",
   "author": {
     "name": "SIBERIA CAN CODE 🧊",
@@ -68,24 +68,20 @@
     "@testing-library/dom": "^10.4.0",
     "@testing-library/react": "^16.3.0",
     "@types/dom-speech-recognition": "^0.0.6",
-    "@types/react": "^19.1.2",
-    "@types/react-dom": "^19.1.2",
+    "@types/react": "^19.1.3",
+    "@types/react-dom": "^19.1.3",
     "@types/web-bluetooth": "^0.0.21",
     "@vitejs/plugin-react": "^4.4.1",
-    "core-js": "^3.41.0",
+    "core-js": "^3.42.0",
     "react": "^19.1.0",
     "react-dom": "^19.1.0",
     "shx": "^0.4.0",
-    "vite": "^6.3.2",
+    "vite": "^6.3.5",
     "vite-plugin-dts": "^4.5.3",
-    "vitest": "^3.1.2"
+    "vitest": "^3.1.3"
   },
   "lint-staged": {
-    "*.js": [
-      "eslint --fix",
-      "prettier --write"
-    ],
-    "*.ts": [
+    "*.{js,ts,tsx}": [
       "eslint --fix",
       "prettier --write"
     ]