@siberiacancode/reactuse 0.1.1 → 0.2.1

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/createReactiveContext/createReactiveContext.d.ts

@@ -0,0 +1,46 @@
+import { Context, Provider, RefObject } from 'react';
+/** The create reactive context options type */
+export interface CreateReactiveContextOptions {
+    /** 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 create reactive context return type */
+export interface CreateReactiveContextReturn<Value> {
+    /** The context instance */
+    instance: Context<ReactiveContextValue<Value>>;
+    /** The Provider component for the context */
+    Provider: Provider<Value>;
+    /** A hook to select a part of the context state */
+    useSelector: <Selected>(selector?: (state: Value) => Selected) => Selected;
+}
+type ContextListener<Value> = (value: Value) => void;
+interface ReactiveContextValue<Value> {
+    /** The listeners for the context */
+    listeners: Set<ContextListener<Value>>;
+    /** The value for the context */
+    value: RefObject<Value>;
+}
+/**
+ * @name createReactiveContext
+ * @description - Creates a typed context selector with optimized updates for state selection
+ * @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 {CreateReactiveContextOptions<Value>} [options] - Additional options for context creation
+ * @returns {CreateReactiveContextReturn<Value>} Object containing context utilities and components
+ *
+ * @example
+ * const { Provider, useSelector, instance } = createReactiveContext<number>(0);
+ */
+export declare const createReactiveContext: <Value extends Record<string, any>>(defaultValue?: Value | undefined, options?: CreateReactiveContextOptions) => {
+    instance: Context<ReactiveContextValue<Value>>;
+    Provider: Provider<Value>;
+    useSelector: {
+        (): Value;
+        <SelectedValue>(selector: (state: Value) => SelectedValue): SelectedValue;
+    };
+};
+export {};

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 const 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,3 @@
+export * from './createContext/createContext';
+export * from './createReactiveContext/createReactiveContext';
+export * from './createStore/createStore';

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

@@ -125,6 +125,7 @@ export * from './useTimeout/useTimeout';
 export * from './useTimer/useTimer';
 export * from './useToggle/useToggle';
 export * from './useUnmount/useUnmount';
+export * from './useUrlSearchParams/useUrlSearchParams';
 export * from './useVibrate/useVibrate';
 export * from './useWakeLock/useWakeLock';
 export * from './useWebSocket/useWebSocket';

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/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/useUrlSearchParams/useUrlSearchParams.d.ts

@@ -0,0 +1,39 @@
+export declare const getUrlSearchParams: (mode?: UrlSearchParamsMode) => URLSearchParams;
+export declare const createQueryString: (searchParams: URLSearchParams, mode: UrlSearchParamsMode) => string;
+export declare const setUrlSearchParams: <Params extends UrlParams>(mode: UrlSearchParamsMode, params: Partial<Params>, write?: "push" | "replace") => URLSearchParams;
+/** The url params type */
+export type UrlParams = Record<string, any>;
+/** The url search params mod */
+export type UrlSearchParamsMode = 'hash-params' | 'hash' | 'history';
+/** The use url search params set options type */
+export interface UseUrlSearchParamsSetOptions {
+    /** The mode to use for writing to the URL */
+    write?: 'push' | 'replace';
+}
+/** The use url search params options type */
+export interface UseUrlSearchParamsOptions {
+    /** The mode to use for writing to the URL */
+    mode?: UrlSearchParamsMode;
+    /** The mode to use for writing to the URL  */
+    write?: 'push' | 'replace';
+}
+/** The use url search params return type */
+export interface UseUrlSearchParamsReturn<Params extends UrlParams> {
+    value: Params;
+    set: (params: Partial<Params>) => void;
+}
+/**
+ * @name useUrlSearchParams
+ * @description - Hook that provides reactive URLSearchParams
+ * @category Browser
+ *
+ * @overload
+ * @template Value The type of the url param values
+ * @param {UrlSearchParamsMode} mode The URL mode
+ * @param {UseUrlSearchParamsOptions<Value>} [options] The URL mode
+ * @returns {UseUrlSearchParamsReturn<Value>} The object with value and function for change value
+ *
+ * @example
+ * const { value, set } = useUrlSearchParams('history');
+ */
+export declare const useUrlSearchParams: <Params extends UrlParams, SearchParams extends string | UrlParams | URLSearchParams = UrlParams>(initialValue?: SearchParams, options?: UseUrlSearchParamsOptions) => UseUrlSearchParamsReturn<Params>;

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.1",
+  "version": "0.2.1",
   "description": "The ultimate collection of react hooks",
   "author": {
     "name": "SIBERIA CAN CODE 🧊",
@@ -39,17 +39,6 @@
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "prepublishOnly": "pnpm unit-test run && pnpm build",
-    "build": "shx rm -rf dist && vite build",
-    "build:js": "tsc --project tsconfig.build.json && prettier --write src/bundle",
-    "lint": "eslint . --fix",
-    "lint-inspector": "npx @eslint/config-inspector@latest",
-    "format": "prettier --write .",
-    "pretty": "pnpm lint && pnpm format",
-    "unit-test": "vitest",
-    "lint-staged": "lint-staged"
-  },
   "peerDependencies": {
     "@types/react": "^18",
     "react": "^17 || ^18 || ^19",
@@ -68,22 +57,32 @@
     "@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.5",
+    "@types/react-dom": "^19.1.5",
     "@types/web-bluetooth": "^0.0.21",
-    "@vitejs/plugin-react": "^4.4.1",
-    "core-js": "^3.41.0",
+    "@vitejs/plugin-react": "^4.5.0",
+    "core-js": "^3.42.0",
     "react": "^19.1.0",
     "react-dom": "^19.1.0",
     "shx": "^0.4.0",
-    "vite": "^6.3.2",
-    "vite-plugin-dts": "^4.5.3",
-    "vitest": "^3.1.2"
+    "vite": "^6.3.5",
+    "vite-plugin-dts": "^4.5.4",
+    "vitest": "^3.1.4"
   },
   "lint-staged": {
     "*.{js,ts,tsx}": [
       "eslint --fix",
       "prettier --write"
     ]
+  },
+  "scripts": {
+    "build": "shx rm -rf dist && vite build",
+    "build:js": "tsc --project tsconfig.build.json && prettier --write src/bundle",
+    "lint": "eslint . --fix",
+    "lint-inspector": "npx @eslint/config-inspector@latest",
+    "format": "prettier --write .",
+    "pretty": "pnpm lint && pnpm format",
+    "unit-test": "vitest",
+    "lint-staged": "lint-staged"
   }
-}
+}