@codeleap/hooks 6.2.3 → 6.8.0

package/dist/index.d.ts

@@ -0,0 +1,32 @@
+import { useEffect, useRef, useState, useImperativeHandle, useMemo, useCallback, useContext, useLayoutEffect, useDebugValue, useReducer } from 'react';
+export * from './useConditionalState';
+export * from './usePromise';
+export * from './useUncontrolled';
+export * from './useForceRender';
+export * from './useDebounce';
+export * from './useInterval';
+export * from './onMount';
+export * from './onUpdate';
+export * from './usePrevious';
+export * from './useToggle';
+export * from './useBooleanToggle';
+export * from './useModal';
+export * from './usePlaces';
+export * from './usePlacesAutocompleteUtils';
+export * from './useEffectOnce';
+export * from './useUnmount';
+export * from './useSearch';
+export * from './usePartialState';
+export * from './useIsMounted';
+export * from './useComponentTestId';
+export * from './useId';
+export * from './useDebounceCallback';
+export * from './useDerivedRef';
+export * from './useDerivedState';
+export * from './useFilteredList';
+export * from './useLazyStore';
+export * from './useStableReference';
+export * from './useOptions';
+export * from './useRenderCall';
+export { useEffect, useRef, useState, useImperativeHandle, useMemo, useCallback, useContext, useLayoutEffect, useDebugValue, useReducer, };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EACT,MAAM,EACN,QAAQ,EACR,mBAAmB,EACnB,OAAO,EACP,WAAW,EACX,UAAU,EACV,eAAe,EACf,aAAa,EACb,UAAU,EACX,MAAM,OAAO,CAAA;AAEd,cAAc,uBAAuB,CAAA;AACrC,cAAc,cAAc,CAAA;AAC5B,cAAc,mBAAmB,CAAA;AACjC,cAAc,kBAAkB,CAAA;AAChC,cAAc,eAAe,CAAA;AAC7B,cAAc,eAAe,CAAA;AAC7B,cAAc,WAAW,CAAA;AACzB,cAAc,YAAY,CAAA;AAC1B,cAAc,eAAe,CAAA;AAC7B,cAAc,aAAa,CAAA;AAC3B,cAAc,oBAAoB,CAAA;AAClC,cAAc,YAAY,CAAA;AAC1B,cAAc,aAAa,CAAA;AAC3B,cAAc,8BAA8B,CAAA;AAC5C,cAAc,iBAAiB,CAAA;AAC/B,cAAc,cAAc,CAAA;AAC5B,cAAc,aAAa,CAAA;AAC3B,cAAc,mBAAmB,CAAA;AACjC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,sBAAsB,CAAA;AACpC,cAAc,SAAS,CAAA;AACvB,cAAc,uBAAuB,CAAA;AACrC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,mBAAmB,CAAA;AACjC,cAAc,mBAAmB,CAAA;AACjC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,sBAAsB,CAAA;AACpC,cAAc,cAAc,CAAA;AAC5B,cAAc,iBAAiB,CAAA;AAE/B,OAAO,EACL,SAAS,EACT,MAAM,EACN,QAAQ,EACR,mBAAmB,EACnB,OAAO,EACP,WAAW,EACX,UAAU,EACV,eAAe,EACf,aAAa,EACb,UAAU,GACX,CAAA"}

package/dist/onMount.d.ts

@@ -0,0 +1,12 @@
+import { AnyFunction } from '@codeleap/types';
+/**
+ * Hook that runs a function once when the component mounts.
+ *
+ * @example
+ * onMount(() => {
+ *   console.log('Component mounted')
+ *   return () => console.log('Component unmounted')
+ * })
+ */
+export declare const onMount: (func: AnyFunction) => void;
+//# sourceMappingURL=onMount.d.ts.map

package/dist/onMount.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"onMount.d.ts","sourceRoot":"","sources":["../src/onMount.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAE7C;;;;;;;;GAQG;AACH,eAAO,MAAM,OAAO,GAAI,MAAM,WAAW,SAIxC,CAAA"}

package/dist/onUpdate.d.ts

@@ -0,0 +1,11 @@
+import { AnyFunction } from '@codeleap/types';
+/**
+ * Hook that runs a function when specified dependencies change.
+ *
+ * @example
+ * onUpdate(() => {
+ *   console.log('Count changed:', count)
+ * }, [count])
+ */
+export declare const onUpdate: (func: AnyFunction, listeners?: never[]) => void;
+//# sourceMappingURL=onUpdate.d.ts.map

package/dist/onUpdate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"onUpdate.d.ts","sourceRoot":"","sources":["../src/onUpdate.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAE7C;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ,GAAI,MAAM,WAAW,EAAE,mBAAc,SAIzD,CAAA"}

package/dist/useBooleanToggle.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Hook that manages a boolean state with toggle functionality.
+ *
+ * @example
+ * const [isOpen, toggleOpen] = useBooleanToggle(false)
+ * toggleOpen() // Toggles the value
+ * toggleOpen(true) // Sets to true
+ */
+export declare function useBooleanToggle(initial: boolean): readonly [boolean, (value?: boolean) => void];
+//# sourceMappingURL=useBooleanToggle.d.ts.map

package/dist/useBooleanToggle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useBooleanToggle.d.ts","sourceRoot":"","sources":["../src/useBooleanToggle.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,+BAGlB,OAAO,WASrC"}

package/dist/useComponentTestId.d.ts

@@ -0,0 +1,11 @@
+import { AnyRecord } from '@codeleap/types';
+/**
+ * Hook that generates a stable test ID for a component based on its props.
+ * Uses debugName if available, otherwise generates a hash from specified prop keys.
+ *
+ * @example
+ * const testId = useComponentTestId(Button, props, ['label', 'variant'])
+ * // Returns: "Button:debug-name" or "Button:123456"
+ */
+export declare const useComponentTestId: <P extends AnyRecord>(Component: any, props: P, keys: Array<keyof P>) => string;
+//# sourceMappingURL=useComponentTestId.d.ts.map

package/dist/useComponentTestId.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useComponentTestId.d.ts","sourceRoot":"","sources":["../src/useComponentTestId.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAmC3C;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,GAAI,CAAC,SAAS,SAAS,EACpD,WAAW,GAAG,EACd,OAAO,CAAC,EACR,MAAM,KAAK,CAAC,MAAM,CAAC,CAAC,WAIrB,CAAA"}

package/dist/useConditionalState.d.ts

@@ -0,0 +1,21 @@
+import { SetStateAction, Dispatch } from 'react';
+import { AnyFunction } from '@codeleap/types';
+type UseConditionalStateOptions<T> = {
+    initialValue?: T;
+    isBooleanToggle?: boolean;
+};
+type SetState<T> = Dispatch<SetStateAction<T>> & ((value: T) => void) & (() => void);
+/**
+ * Hook that uses external state if provided, otherwise creates internal state.
+ * Useful for creating controlled/uncontrolled component patterns.
+ *
+ * @example
+ * // Controlled mode
+ * const [value, setValue] = useConditionalState(props.value, props.onChange)
+ *
+ * // Uncontrolled mode
+ * const [value, setValue] = useConditionalState(undefined, undefined, { initialValue: 'default' })
+ */
+export declare const useConditionalState: <T>(value: T | undefined, setter: AnyFunction, options?: UseConditionalStateOptions<T>) => [T, SetState<T>];
+export {};
+//# sourceMappingURL=useConditionalState.d.ts.map

package/dist/useConditionalState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useConditionalState.d.ts","sourceRoot":"","sources":["../src/useConditionalState.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,cAAc,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAA;AAC1D,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAG7C,KAAK,0BAA0B,CAAC,CAAC,IAAI;IACnC,YAAY,CAAC,EAAE,CAAC,CAAA;IAChB,eAAe,CAAC,EAAE,OAAO,CAAA;CAC1B,CAAA;AAED,KAAK,QAAQ,CAAC,CAAC,IAAI,QAAQ,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC,GAAG,CAAC,MAAM,IAAI,CAAC,CAAA;AAEpF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB,GAAI,CAAC,EACnC,OAAO,CAAC,GAAG,SAAS,EACpB,QAAQ,WAAW,EACnB,UAAS,0BAA0B,CAAC,CAAC,CAAM,KAC1C,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,CAUjB,CAAA"}

package/dist/useDebounce.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Hook that debounces a value, updating it after a specified delay.
+ *
+ * @example
+ * const [debouncedSearch, resetDebounce] = useDebounce(searchTerm, 500)
+ * // debouncedSearch updates 500ms after searchTerm stops changing
+ */
+export declare function useDebounce<T>(value: T, debounce: number): [T, () => void];
+//# sourceMappingURL=useDebounce.d.ts.map

package/dist/useDebounce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDebounce.d.ts","sourceRoot":"","sources":["../src/useDebounce.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAC3B,KAAK,EAAE,CAAC,EACR,QAAQ,EAAE,MAAM,GACf,CAAC,CAAC,EAAE,MAAM,IAAI,CAAC,CAmBjB"}

package/dist/useDebounceCallback.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Hook that creates debounced, flush, and cancel functions for a callback.
+ *
+ * @example
+ * const { debounce, flush, cancel } = useDebounceCallback((value) => {
+ *   console.log(value)
+ * }, 500)
+ *
+ * debounce('hello') // Will call callback after 500ms
+ * flush('immediate') // Calls callback immediately
+ * cancel() // Cancels pending debounced call
+ */
+export declare function useDebounceCallback<T extends any[]>(callback: (...args: T) => void, delay?: number): {
+    debounce: (...args: T) => void;
+    flush: (...args: T) => void;
+    cancel: () => void;
+};
+//# sourceMappingURL=useDebounceCallback.d.ts.map

package/dist/useDebounceCallback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDebounceCallback.d.ts","sourceRoot":"","sources":["../src/useDebounceCallback.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,GAAG,EAAE,EACjD,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,IAAI,EAC9B,KAAK,SAAO;wBAI2B,CAAC;qBASJ,CAAC;;EAiBtC"}

package/dist/useDerivedRef.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Hook that creates a ref that automatically updates when a derived value changes.
+ *
+ * @example
+ * const userNameRef = useDerivedRef(user, (u) => u.name)
+ * // userNameRef.current will always contain the latest user name
+ */
+export declare const useDerivedRef: <T, D>(derivedValue: D, getValue: (derivedValue: D) => T) => React.MutableRefObject<T>;
+//# sourceMappingURL=useDerivedRef.d.ts.map

package/dist/useDerivedRef.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDerivedRef.d.ts","sourceRoot":"","sources":["../src/useDerivedRef.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,GAAI,CAAC,EAAE,CAAC,EAChC,cAAc,CAAC,EACf,UAAU,CAAC,YAAY,EAAE,CAAC,KAAK,CAAC,KAC/B,KAAK,CAAC,gBAAgB,CAAC,CAAC,CAQ1B,CAAA"}

package/dist/useDerivedState.d.ts

@@ -0,0 +1,17 @@
+type Options<T, D> = {
+    areEqual?: (currentState: T, derivedValue: D) => boolean;
+    transform?: (value: D | T) => any;
+    getValue?: (derivedValue: D) => T;
+};
+/**
+ * Hook that creates a state that synchronizes with a derived value, with customizable equality check.
+ *
+ * @example
+ * const [state, setState] = useDerivedState(props.value, {
+ *   getValue: (v) => v.id,
+ *   areEqual: (a, b) => a === b.id
+ * })
+ */
+export declare const useDerivedState: <T, D = T>(derivedValue: D, options?: Options<T, D>) => [T, React.Dispatch<React.SetStateAction<T>>];
+export {};
+//# sourceMappingURL=useDerivedState.d.ts.map

package/dist/useDerivedState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDerivedState.d.ts","sourceRoot":"","sources":["../src/useDerivedState.ts"],"names":[],"mappings":"AAGA,KAAK,OAAO,CAAC,CAAC,EAAE,CAAC,IAAI;IACnB,QAAQ,CAAC,EAAE,CAAC,YAAY,EAAE,CAAC,EAAE,YAAY,EAAE,CAAC,KAAK,OAAO,CAAA;IACxD,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC,KAAK,GAAG,CAAA;IACjC,QAAQ,CAAC,EAAE,CAAC,YAAY,EAAE,CAAC,KAAK,CAAC,CAAA;CAClC,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,GAAI,CAAC,EAAE,CAAC,GAAG,CAAC,EACtC,cAAc,CAAC,EACf,UAAS,OAAO,CAAC,CAAC,EAAE,CAAC,CAAM,KAC1B,CAAC,CAAC,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAoB7C,CAAA"}

package/dist/useEffectOnce.d.ts

@@ -0,0 +1,12 @@
+import { EffectCallback } from 'react';
+/**
+ * Hook that runs an effect only once when the component mounts.
+ *
+ * @example
+ * useEffectOnce(() => {
+ *   console.log('Runs only once on mount')
+ *   return () => console.log('Cleanup on unmount')
+ * })
+ */
+export declare const useEffectOnce: (effect: EffectCallback) => void;
+//# sourceMappingURL=useEffectOnce.d.ts.map

package/dist/useEffectOnce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEffectOnce.d.ts","sourceRoot":"","sources":["../src/useEffectOnce.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAa,MAAM,OAAO,CAAA;AAEjD;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,GAAI,QAAQ,cAAc,SAEnD,CAAA"}

package/dist/useFilteredList.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Hook that filters out the first item from a list that matches a predicate.
+ *
+ * @example
+ * const filteredUsers = useFilteredList(users, (user) => user.id === deletedId)
+ * // Returns users array without the first user matching the predicate
+ */
+export declare function useFilteredList<T>(list: T[], predicate: (item: T) => boolean): T[];
+//# sourceMappingURL=useFilteredList.d.ts.map

package/dist/useFilteredList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFilteredList.d.ts","sourceRoot":"","sources":["../src/useFilteredList.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,GAAG,CAAC,EAAE,CAWlF"}

package/dist/useForceRender.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Hook that returns a function to force a component re-render.
+ *
+ * @example
+ * const forceRender = useForceRender()
+ * forceRender() // Forces component to re-render
+ */
+export declare function useForceRender(): import("react").ActionDispatch<[]>;
+//# sourceMappingURL=useForceRender.d.ts.map

package/dist/useForceRender.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useForceRender.d.ts","sourceRoot":"","sources":["../src/useForceRender.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,wBAAgB,cAAc,uCAG7B"}

package/dist/useId.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Hook that returns a stable ID, using provided ID if available or generating one.
+ *
+ * @example
+ * const id = useId('custom-id') // Returns 'custom-id'
+ * const id = useId() // Returns generated ID like ':r1:'
+ */
+export declare function useId<T>(id?: T): string | NonNullable<T>;
+//# sourceMappingURL=useId.d.ts.map

package/dist/useId.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useId.d.ts","sourceRoot":"","sources":["../src/useId.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,2BAK9B"}

package/dist/useInterval.d.ts

@@ -0,0 +1,22 @@
+import { AnyFunction } from '@codeleap/types';
+type UseIntervalHandler = (clear: AnyFunction) => void;
+/**
+ * Hook that manages an interval with start and clear controls.
+ * The handler receives a clear function to stop the interval from within.
+ *
+ * @example
+ * const { start, clear } = useInterval((clearFn) => {
+ *   console.log('Tick')
+ *   if (shouldStop) clearFn()
+ * }, 1000)
+ *
+ * start() // Starts the interval
+ * clear() // Stops the interval
+ */
+export declare function useInterval(handler: UseIntervalHandler, interval: number): {
+    clear: () => void;
+    start: () => void;
+    interval: number | null;
+};
+export {};
+//# sourceMappingURL=useInterval.d.ts.map

package/dist/useInterval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useInterval.d.ts","sourceRoot":"","sources":["../src/useInterval.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAE7C,KAAK,kBAAkB,GAAG,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,CAAA;AAEtD;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,kBAAkB,EAAE,QAAQ,EAAE,MAAM;;;;EAoCxE"}

package/dist/useIsMounted.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Hook to check if the component has mounted. SSR safe.
+ *
+ * @example
+ * const isMounted = useIsMounted()
+ * if (isMounted) {
+ *   // Safe to use browser APIs
+ * }
+ */
+export declare function useIsMounted(): boolean;
+/**
+ * Hook to check if the code is running on the client-side.
+ * NOTE: This is just a mirror of `useIsMounted` for retrocompatibility reasons
+ *
+ * @example
+ * const { isClient } = useIsClient()
+ * if (isClient) {
+ *   // Safe to use browser APIs
+ * }
+ */
+export declare function useIsClient(): {
+    isClient: boolean;
+};
+//# sourceMappingURL=useIsMounted.d.ts.map

package/dist/useIsMounted.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useIsMounted.d.ts","sourceRoot":"","sources":["../src/useIsMounted.ts"],"names":[],"mappings":"AAOA;;;;;;;;GAQG;AACH,wBAAgB,YAAY,YAQ3B;AAED;;;;;;;;;GASG;AACH,wBAAgB,WAAW;;EAI1B"}

package/dist/useLazyStore.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Hook that lazily creates a global store with an initial value.
+ * The store is created only once and persists across re-renders.
+ *
+ * @example
+ * const counterStore = useLazyStore(0)
+ * // Store is created once and can be used across components
+ */
+export declare function useLazyStore<T>(initialValue: T): import("@codeleap/store").GlobalState<T>;
+//# sourceMappingURL=useLazyStore.d.ts.map

package/dist/useLazyStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLazyStore.d.ts","sourceRoot":"","sources":["../src/useLazyStore.ts"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,4CAM9C"}

package/dist/useModal.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Hook that manages modal visibility state with open, close, and toggle functions.
+ *
+ * @example
+ * const modal = useModal()
+ * modal.open() // Opens modal
+ * modal.close() // Closes modal
+ * modal.toggle() // Toggles visibility
+ * modal.toggle(true) // Forces open
+ */
+export declare function useModal(startsOpen?: boolean): {
+    visible: boolean;
+    toggle: (forceVisible?: boolean) => void;
+    open: () => void;
+    close: () => void;
+};
+//# sourceMappingURL=useModal.d.ts.map

package/dist/useModal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useModal.d.ts","sourceRoot":"","sources":["../src/useModal.ts"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CAAC,UAAU,UAAQ;;4BAWV,OAAO;;;EAUvC"}

package/dist/useOptions.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Hook that manages selected option state with boolean flags for each option.
+ *
+ * @example
+ * const { selectedOption, setSelectedOption, isSelected } = useOptions(['light', 'dark'] as const)
+ * // isSelected = { light: true, dark: false }
+ * setSelectedOption('dark')
+ * // isSelected = { light: false, dark: true }
+ */
+export declare function useOptions<T extends string>(options: readonly T[], initialOptions?: T): {
+    selectedOption: T;
+    setSelectedOption: import("react").Dispatch<import("react").SetStateAction<T>>;
+    isSelected: Record<T, boolean>;
+};
+//# sourceMappingURL=useOptions.d.ts.map

package/dist/useOptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useOptions.d.ts","sourceRoot":"","sources":["../src/useOptions.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,MAAM,EAAE,OAAO,EAAE,SAAS,CAAC,EAAE,EAAE,cAAc,GAAE,CAAc;;;;EAejG"}

package/dist/usePartialState.d.ts

@@ -0,0 +1,13 @@
+import { DeepPartial } from '@codeleap/types';
+type SetPartialStateCallback<T> = (value: T) => DeepPartial<T>;
+/**
+ * Hook that manages state with partial updates using deep merge.
+ *
+ * @example
+ * const [user, setUser] = usePartialState({ name: 'John', age: 30 })
+ * setUser({ age: 31 }) // Only updates age, keeps name
+ * setUser(prev => ({ age: prev.age + 1 })) // Functional update
+ */
+export declare function usePartialState<T extends object = any>(initial: T | (() => T)): readonly [T, (value: DeepPartial<T> | SetPartialStateCallback<T>) => void];
+export {};
+//# sourceMappingURL=usePartialState.d.ts.map

package/dist/usePartialState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePartialState.d.ts","sourceRoot":"","sources":["../src/usePartialState.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAG7C,KAAK,uBAAuB,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,WAAW,CAAC,CAAC,CAAC,CAAA;AAE9D;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,MAAM,GAAG,GAAG,EAAE,OAAO,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,wBAInE,WAAW,CAAC,CAAC,CAAC,GAAG,uBAAuB,CAAC,CAAC,CAAC,WAUrD"}

package/dist/usePlaces.d.ts

@@ -0,0 +1,29 @@
+type Params = {
+    input?: string;
+    key?: string;
+    showDetails?: boolean;
+};
+/**
+ * Retrieves detailed information for a specific Google Place.
+ */
+export declare const retrievePlaceDetails: (placeId: string, apiKey: string) => Promise<any>;
+/**
+ * Retrieves places from Google Places API or Geocoding API.
+ * Supports both text search and lat/lng coordinates.
+ */
+export declare const retrievePlaces: (params: Params) => Promise<any>;
+export type UsePlacesParams = Params;
+/**
+ * Hook that fetches Google Places using React Query.
+ * Automatically handles caching and refetching.
+ *
+ * @example
+ * const places = usePlaces({
+ *   input: 'New York',
+ *   key: 'YOUR_API_KEY',
+ *   showDetails: true
+ * })
+ */
+export declare const usePlaces: (params: Params) => import("@tanstack/react-query").UseQueryResult<any, Error>;
+export {};
+//# sourceMappingURL=usePlaces.d.ts.map

package/dist/usePlaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePlaces.d.ts","sourceRoot":"","sources":["../src/usePlaces.ts"],"names":[],"mappings":"AASA,KAAK,MAAM,GAAG;IACZ,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,WAAW,CAAC,EAAE,OAAO,CAAA;CACtB,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,oBAAoB,GAAU,SAAS,MAAM,EAAE,QAAQ,MAAM,iBASzE,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,cAAc,GAAU,QAAQ,MAAM,iBAyBlD,CAAA;AAED,MAAM,MAAM,eAAe,GAAG,MAAM,CAAA;AAEpC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,SAAS,GAAI,QAAQ,MAAM,+DAOvC,CAAA"}

package/dist/usePlacesAutocompleteUtils.d.ts

@@ -0,0 +1,31 @@
+import React from 'react';
+export type UsePlacesAutocompleteUtilsProps<T extends Record<string, any>> = {
+    debounce?: number;
+    onValueChange?: (address: string) => void;
+    onPress?: (address: string, item: T) => void;
+};
+/**
+ * Hook that manages address autocomplete state with debounced input handling.
+ * Useful for Google Places autocomplete implementations.
+ *
+ * @example
+ * const {
+ *   address,
+ *   handleChangeAddress,
+ *   handlePressAddress,
+ *   isTyping
+ * } = usePlacesAutocompleteUtils({
+ *   debounce: 500,
+ *   onValueChange: (addr) => fetchPlaces(addr),
+ *   onPress: (addr, item) => console.log('Selected:', item)
+ * })
+ */
+export declare const usePlacesAutocompleteUtils: <T extends Record<string, any>>(props: UsePlacesAutocompleteUtilsProps<T>) => {
+    handleChangeAddress: (address: string) => void;
+    handlePressAddress: (address: string, item: T) => void;
+    handleClearAddress: () => void;
+    address: string;
+    isTyping: boolean;
+    setIsTyping: React.Dispatch<React.SetStateAction<boolean>>;
+};
+//# sourceMappingURL=usePlacesAutocompleteUtils.d.ts.map

package/dist/usePlacesAutocompleteUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePlacesAutocompleteUtils.d.ts","sourceRoot":"","sources":["../src/usePlacesAutocompleteUtils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AAGzB,MAAM,MAAM,+BAA+B,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI;IAC3E,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,aAAa,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;IACzC,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,KAAK,IAAI,CAAA;CAC7C,CAAA;AAED;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,0BAA0B,GAAI,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,OAAO,+BAA+B,CAAC,CAAC,CAAC;mCAY3E,MAAM;kCAmBP,MAAM,QAAQ,CAAC;;;;;CAkBrD,CAAA"}

package/dist/usePrevious.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Hook that returns the previous value of a variable.
+ * The value is updated after render is committed to the DOM.
+ *
+ * @example
+ * const [count, setCount] = useState(0)
+ * const prevCount = usePrevious(count)
+ * // On first render: count=0, prevCount=null
+ * // After setCount(1): count=1, prevCount=0
+ */
+export declare const usePrevious: <T>(value: T) => T | null;
+//# sourceMappingURL=usePrevious.d.ts.map

package/dist/usePrevious.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePrevious.d.ts","sourceRoot":"","sources":["../src/usePrevious.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,EAAE,OAAO,CAAC,aAMtC,CAAA"}

package/dist/usePromise.d.ts

@@ -0,0 +1,26 @@
+type UsePromiseOptions<T = any> = {
+    onResolve?: (value: T) => void;
+    onReject?: (err: any) => void;
+    timeout?: number;
+    debugName?: string;
+};
+/**
+ * Hook that creates a deferred promise with manual resolve/reject control.
+ * Useful for coordinating asynchronous operations across component lifecycle.
+ *
+ * @example
+ * const promise = usePromise({ timeout: 5000 })
+ * const handleClick = async () => {
+ *   const result = await promise._await()
+ *   console.log(result)
+ * }
+ * // Later, from another callback:
+ * promise.resolve('success')
+ */
+export declare const usePromise: <T = any>(options?: UsePromiseOptions<T>) => {
+    _await: () => Promise<T>;
+    resolve: (value: T) => Promise<void>;
+    reject: (err: any) => Promise<void>;
+};
+export {};
+//# sourceMappingURL=usePromise.d.ts.map

package/dist/usePromise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePromise.d.ts","sourceRoot":"","sources":["../src/usePromise.ts"],"names":[],"mappings":"AAGA,KAAK,iBAAiB,CAAC,CAAC,GAAG,GAAG,IAAI;IAChC,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAA;IAC9B,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,IAAI,CAAA;IAC7B,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,UAAU,GAAI,CAAC,GAAG,GAAG,EAAE,UAAU,iBAAiB,CAAC,CAAC,CAAC;;qBAYlC,CAAC;kBAPJ,GAAG;CA+B/B,CAAA"}

package/dist/useRenderCall.d.ts

@@ -0,0 +1,3 @@
+/** Calls `fn` synchronously during render, capped at `maxRunCount` renders (default 1). Does not use effects — execution happens inline during the render phase. */
+export declare function useRenderCall(fn: () => void, maxRunCount?: number): void;
+//# sourceMappingURL=useRenderCall.d.ts.map

package/dist/useRenderCall.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRenderCall.d.ts","sourceRoot":"","sources":["../src/useRenderCall.ts"],"names":[],"mappings":"AAEA,oKAAoK;AACpK,wBAAgB,aAAa,CAAC,EAAE,EAAE,MAAM,IAAI,EAAE,WAAW,SAAI,QAM5D"}

package/dist/useSearch/index.d.ts

@@ -0,0 +1,36 @@
+import { useSearchParams } from './types';
+/**
+ * Hook that manages searchable select/autocomplete state with async loading support.
+ * Handles both local filtering and remote data fetching.
+ *
+ * @example
+ * const search = useSearch({
+ *   value: 'selected-value',
+ *   multiple: false,
+ *   defaultOptions: [...],
+ *   loadOptions: async (query) => fetchOptions(query),
+ *   filterItems: (query, opts) => opts.filter(o => o.label.includes(query))
+ * })
+ *
+ * search.onChangeSearch('query')
+ * search.load()
+ */
+export declare function useSearch<T extends string | number = string, Multi extends boolean = false>(props: useSearchParams<T, Multi>): {
+    loading: boolean;
+    setLoading: (value?: boolean) => void;
+    labelOptions: {
+        label: any;
+        value: T;
+    }[];
+    setLabelOptions: import("react").Dispatch<import("react").SetStateAction<{
+        label: any;
+        value: T;
+    }[]>>;
+    filteredOptions: {
+        label: any;
+        value: T;
+    }[];
+    load: () => Promise<void>;
+    onChangeSearch: (searchValue: string) => Promise<void>;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/useSearch/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/useSearch/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAGzC;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,GAAC,MAAM,GAAG,MAAM,EAAE,KAAK,SAAS,OAAO,GAAG,KAAK,EAAE,KAAK,EAAE,eAAe,CAAC,CAAC,EAAE,KAAK,CAAC;;;;;;;;;;;;;;;;kCA2C/E,MAAM;EAsBjD"}

package/dist/useSearch/types.d.ts

@@ -0,0 +1,17 @@
+export type AutocompleteValue<T, Multi extends boolean = false> = Multi extends true ? T[] : T;
+type Options<T> = {
+    label: any;
+    value: T;
+}[];
+export type useSearchParams<T, Multi extends boolean = false> = {
+    value: AutocompleteValue<T, Multi>;
+    multiple: Multi;
+    options: Options<T>;
+    filterItems: (search: string, items: Options<T>) => Options<T>;
+    debugName: string;
+    defaultOptions: Options<T>;
+    loadOptions: (search: string) => Promise<Options<T>>;
+    onLoadOptionsError: (error: any) => void;
+};
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/useSearch/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/useSearch/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,iBAAiB,CAAC,CAAC,EAAE,KAAK,SAAS,OAAO,GAAG,KAAK,IAAI,KAAK,SAAS,IAAI,GAAG,CAAC,EAAE,GAAG,CAAC,CAAA;AAE9F,KAAK,OAAO,CAAC,CAAC,IAAI;IAAE,KAAK,EAAE,GAAG,CAAC;IAAC,KAAK,EAAE,CAAC,CAAA;CAAE,EAAE,CAAA;AAE5C,MAAM,MAAM,eAAe,CAAC,CAAC,EAAE,KAAK,SAAS,OAAO,GAAG,KAAK,IAAI;IAC9D,KAAK,EAAE,iBAAiB,CAAC,CAAC,EAAE,KAAK,CAAC,CAAA;IAClC,QAAQ,EAAC,KAAK,CAAA;IACd,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,CAAA;IACnB,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAAA;IAC9D,SAAS,EAAE,MAAM,CAAA;IACjB,cAAc,EAAE,OAAO,CAAC,CAAC,CAAC,CAAA;IAC1B,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAA;IACpD,kBAAkB,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,CAAA;CACzC,CAAA"}

package/dist/useStableReference.d.ts

@@ -0,0 +1,3 @@
+/** Returns the previous ref value when the object is deeply equal to the last render, preventing unnecessary re-renders caused by referential inequality. */
+export declare function useStableReference<T extends Record<string, any>>(value: T): T;
+//# sourceMappingURL=useStableReference.d.ts.map

package/dist/useStableReference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useStableReference.d.ts","sourceRoot":"","sources":["../src/useStableReference.ts"],"names":[],"mappings":"AAGA,6JAA6J;AAC7J,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,KAAK,EAAE,CAAC,KAUzE"}

package/dist/useToggle.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Hook that toggles between two values.
+ *
+ * @example
+ * const [theme, toggleTheme] = useToggle(['light', 'dark'] as const, 'light')
+ * toggleTheme() // Switches to 'dark'
+ * toggleTheme('light') // Sets to 'light'
+ */
+export declare function useToggle<T extends readonly [any, any], V extends T[0] | T[1]>(options: T, initial: V): readonly [V, (newValue?: V) => void];
+//# sourceMappingURL=useToggle.d.ts.map

package/dist/useToggle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useToggle.d.ts","sourceRoot":"","sources":["../src/useToggle.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,SAAS,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAC5E,OAAO,EAAE,CAAC,EACV,OAAO,EAAE,CAAC,4BAI2B,CAAC,WAOvC"}

package/dist/useUncontrolled.d.ts

@@ -0,0 +1,23 @@
+export type UncontrolledMode = 'initial' | 'controlled' | 'uncontrolled';
+export interface UncontrolledOptions<T> {
+    value: T | null | undefined;
+    defaultValue: T | null | undefined;
+    finalValue: T | null;
+    onChange(value: T | null): void;
+    onValueUpdate?(value: T | null): void;
+    rule: (value: T | null | undefined) => boolean;
+}
+/**
+ * Hook that manages controlled/uncontrolled component pattern with smooth transitions.
+ *
+ * @example
+ * const [value, handleChange, mode] = useUncontrolled({
+ *   value: props.value,
+ *   defaultValue: 'default',
+ *   finalValue: '',
+ *   rule: (v) => v !== undefined,
+ *   onChange: (v) => props.onChange?.(v)
+ * })
+ */
+export declare function useUncontrolled<T>({ value, defaultValue, finalValue, rule, onChange, onValueUpdate, }: UncontrolledOptions<T>): readonly [T | null, (nextValue: T | null) => void, UncontrolledMode];
+//# sourceMappingURL=useUncontrolled.d.ts.map

package/dist/useUncontrolled.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useUncontrolled.d.ts","sourceRoot":"","sources":["../src/useUncontrolled.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,YAAY,GAAG,cAAc,CAAA;AAExE,MAAM,WAAW,mBAAmB,CAAC,CAAC;IACpC,KAAK,EAAE,CAAC,GAAG,IAAI,GAAG,SAAS,CAAA;IAC3B,YAAY,EAAE,CAAC,GAAG,IAAI,GAAG,SAAS,CAAA;IAClC,UAAU,EAAE,CAAC,GAAG,IAAI,CAAA;IACpB,QAAQ,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,GAAG,IAAI,CAAA;IAC/B,aAAa,CAAC,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,GAAG,IAAI,CAAA;IACrC,IAAI,EAAE,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,GAAG,SAAS,KAAK,OAAO,CAAA;CAC/C;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,EACjC,KAAK,EACL,YAAY,EACZ,UAAU,EACV,IAAI,EACJ,QAAQ,EACR,aAAa,GACd,EAAE,mBAAmB,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,GAAG,IAAI,EAAE,CAAC,SAAS,EAAE,CAAC,GAAG,IAAI,KAAK,IAAI,EAAE,gBAAgB,CAAC,CAgD/F"}

package/dist/useUnmount.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Hook that runs a cleanup function when the component unmounts.
+ * The function reference is updated on each render to always use the latest version.
+ *
+ * @example
+ * useUnmount(() => {
+ *   console.log('Component unmounting')
+ *   // Cleanup logic here
+ * })
+ */
+export declare const useUnmount: (fn: () => any) => void;
+//# sourceMappingURL=useUnmount.d.ts.map

package/dist/useUnmount.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useUnmount.d.ts","sourceRoot":"","sources":["../src/useUnmount.ts"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,eAAO,MAAM,UAAU,GAAI,IAAI,MAAM,GAAG,KAAG,IAO1C,CAAA"}

package/package.json

@@ -1,7 +1,20 @@
 {
   "name": "@codeleap/hooks",
-  "version": "6.2.3",
+  "version": "6.8.0",
   "main": "src/index.ts",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
   "license": "UNLICENSED",
   "repository": {
     "url": "https://github.com/codeleap-uk/internal-libs-monorepo.git",
@@ -9,22 +22,23 @@
     "directory": "packages/hooks"
   },
   "devDependencies": {
-    "@codeleap/config": "6.2.3",
-    "@codeleap/types": "6.2.3",
-    "@codeleap/utils": "6.2.3",
-    "@codeleap/logger": "6.2.3",
+    "@codeleap/config": "6.8.0",
+    "@codeleap/types": "6.8.0",
+    "@codeleap/utils": "6.8.0",
+    "@codeleap/logger": "6.8.0",
     "ts-node-dev": "1.1.8"
   },
   "scripts": {
-    "build": "echo 'No build needed'"
+    "build": "tsc --build tsconfig.build.json",
+    "typecheck": "bun tsc --noEmit -p ./tsconfig.json"
   },
   "peerDependencies": {
-    "@codeleap/types": "6.2.3",
-    "@codeleap/utils": "6.2.3",
-    "@codeleap/logger": "6.2.3",
+    "@codeleap/types": "6.8.0",
+    "@codeleap/utils": "6.8.0",
+    "@codeleap/logger": "6.8.0",
     "axios": "^1.7.9",
-    "typescript": "5.5.2",
+    "typescript": "6.0.3",
     "react": "19.1.0",
-    "@tanstack/react-query": "5.89.0"
+    "@tanstack/react-query": "5.100.9"
   }
-}
+}

package/src/index.ts

@@ -32,13 +32,14 @@ export * from './usePartialState'
 export * from './useIsMounted'
 export * from './useComponentTestId'
 export * from './useId'
-export * from './useAnimatedState'
 export * from './useDebounceCallback'
 export * from './useDerivedRef'
 export * from './useDerivedState'
 export * from './useFilteredList'
 export * from './useLazyStore'
+export * from './useStableReference'
 export * from './useOptions'
+export * from './useRenderCall'
 
 export {
   useEffect,

package/src/useDebounce.ts

@@ -13,7 +13,7 @@ export function useDebounce<T>(
 ): [T, () => void] {
   const [debouncedValue, setDebouncedValue] = useState(value)
 
-  const timeoutRef = useRef(null)
+  const timeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null)
 
   const reset = () => {
     if (timeoutRef.current) {

package/src/useDebounceCallback.ts

@@ -16,7 +16,7 @@ export function useDebounceCallback<T extends any[]>(
   callback: (...args: T) => void,
   delay = 1000,
 ) {
-  const timeoutRef = useRef(null)
+  const timeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null)
 
   const debounce = useCallback((...args: T) => {
     cancel()

package/src/useInterval.ts

@@ -17,7 +17,7 @@ type UseIntervalHandler = (clear: AnyFunction) => void
  * clear() // Stops the interval
  */
 export function useInterval(handler: UseIntervalHandler, interval: number) {
-  const intervalRef = useRef<NodeJS.Timer | null>(null)
+  const intervalRef = useRef<ReturnType<typeof setInterval> | null>(null)
   const handlerRef = useRef<UseIntervalHandler>(handler)
 
   useEffect(() => {

package/src/usePartialState.ts

@@ -12,7 +12,7 @@ type SetPartialStateCallback<T> = (value: T) => DeepPartial<T>
  * setUser({ age: 31 }) // Only updates age, keeps name
  * setUser(prev => ({ age: prev.age + 1 })) // Functional update
  */
-export function usePartialState<T= any>(initial: T | (() => T)) {
+export function usePartialState<T extends object = any>(initial: T | (() => T)) {
   const [state, setState] = useState(initial)
 
   function setPartial(

package/src/usePlaces.ts

@@ -33,7 +33,7 @@ export const retrievePlaceDetails = async (placeId: string, apiKey: string) => {
  */
 export const retrievePlaces = async (params: Params) => {
   let response
-  const inputWithoutSpaces = params?.input?.replace(/\s/g, '')
+  const inputWithoutSpaces = params?.input?.replace(/\s/g, '') ?? ''
   const isLatLng = latLngRegex?.test(inputWithoutSpaces)
 
   if (isLatLng) {
@@ -45,9 +45,9 @@ export const retrievePlaces = async (params: Params) => {
   let places = response?.data?.results || response?.data?.predictions
 
   if (params?.showDetails) {
-    const apiKey = params?.key
+    const apiKey = params?.key ?? ''
     places = await Promise.all(
-      places?.map(async (place) => {
+      places?.map(async (place: any) => {
         const placeId = place?.place_id
         const details = await retrievePlaceDetails(placeId, apiKey)
         return { ...place, details }

package/src/usePlacesAutocompleteUtils.ts

@@ -33,7 +33,7 @@ export const usePlacesAutocompleteUtils = <T extends Record<string, any>>(props:
   const [address, setAddress] = React.useState('')
   const [isTyping, setIsTyping] = React.useState(false)
 
-  const setSearchTimeout = React.useRef<NodeJS.Timer | null>(null)
+  const setSearchTimeout = React.useRef<ReturnType<typeof setTimeout> | null>(null)
 
   const handleChangeAddress = (address: string) => {
     setAddress(address)

package/src/usePromise.ts

@@ -24,7 +24,7 @@ type UsePromiseOptions<T = any> = {
 export const usePromise = <T = any>(options?: UsePromiseOptions<T>) => {
   const rejectRef = useRef<AnyFunction>(null)
   const resolveRef = useRef<(v:T) => any>(null)
-  const timeoutRef = useRef(null)
+  const timeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null)
 
   const reject = async (err: any) => {
     await rejectRef.current?.(err)

package/src/useRenderCall.ts

@@ -0,0 +1,10 @@
+import { useRef } from 'react'
+
+/** Calls `fn` synchronously during render, capped at `maxRunCount` renders (default 1). Does not use effects — execution happens inline during the render phase. */
+export function useRenderCall(fn: () => void, maxRunCount = 1) {
+  const callCount = useRef(0)
+  if (callCount.current < maxRunCount) {
+    callCount.current++
+    fn()
+  }
+}

package/src/useStableReference.ts

@@ -0,0 +1,15 @@
+import { deepEqual } from '@codeleap/utils'
+import { useRef } from 'react'
+
+/** Returns the previous ref value when the object is deeply equal to the last render, preventing unnecessary re-renders caused by referential inequality. */
+export function useStableReference<T extends Record<string, any>>(value: T) {
+  const ref = useRef(value)
+
+  const hasChanged = !deepEqual(ref.current, value)
+
+  if (hasChanged) {
+    ref.current = value
+  }
+
+  return ref.current
+}

package/src/useUncontrolled.ts

@@ -40,7 +40,7 @@ export function useUncontrolled<T>({
   const [uncontrolledValue, setUncontrolledValue] = useState(initialValue)
 
   // compute effective value
-  let effectiveValue = shouldBeControlled ? value : uncontrolledValue
+  let effectiveValue: T | null = (shouldBeControlled ? value : uncontrolledValue) ?? null
 
   if (!shouldBeControlled && modeRef.current === 'controlled') {
     // We are transitioning from controlled to uncontrolled

package/package.json.bak

@@ -1,30 +0,0 @@
-{
-  "name": "@codeleap/hooks",
-  "version": "6.2.3",
-  "main": "src/index.ts",
-  "license": "UNLICENSED",
-  "repository": {
-    "url": "https://github.com/codeleap-uk/internal-libs-monorepo.git",
-    "type": "git",
-    "directory": "packages/hooks"
-  },
-  "devDependencies": {
-    "@codeleap/config": "workspace:*",
-    "@codeleap/types": "workspace:*",
-    "@codeleap/utils": "workspace:*",
-    "@codeleap/logger": "workspace:*",
-    "ts-node-dev": "1.1.8"
-  },
-  "scripts": {
-    "build": "echo 'No build needed'"
-  },
-  "peerDependencies": {
-    "@codeleap/types": "workspace:*",
-    "@codeleap/utils": "workspace:*",
-    "@codeleap/logger": "workspace:*",
-    "axios": "^1.7.9",
-    "typescript": "5.5.2",
-    "react": "19.1.0",
-    "@tanstack/react-query": "5.89.0"
-  }
-}

package/src/useAnimatedState.ts

@@ -1,42 +0,0 @@
-import { useState, useCallback } from 'react'
-import { SharedValue, useSharedValue, useDerivedValue, runOnJS, isSharedValue } from 'react-native-reanimated'
-
-/**
- * Hook that synchronizes a React state with a Reanimated SharedValue.
- *
- * @example
- * const [value, setValue, sharedValue] = useAnimatedState(0)
- * setValue(10) // Updates both React state and SharedValue
- */
-export function useAnimatedState<T>(initialValue: SharedValue<T> | T) {
-  const sharedValue = isSharedValue(initialValue)
-    ? initialValue
-    : useSharedValue<T>(initialValue)
-
-  const [value, _setValue] = useState<T>(
-    isSharedValue(initialValue) ? initialValue.value : initialValue,
-  )
-
-  useDerivedValue(() => {
-    runOnJS(_setValue)(sharedValue.value)
-  })
-
-  const setValue = useCallback((newValue: T) => {
-    sharedValue.value = newValue
-    if (isSharedValue(initialValue)) initialValue.value = newValue
-    _setValue(newValue)
-  }, [])
-
-  return [value, setValue, sharedValue] as const
-}
-
-/**
- * Hook that extracts and synchronizes the value from a SharedValue.
- *
- * @example
- * const value = useAnimatedValue(sharedValue)
- */
-export function useAnimatedValue<T>(initialValue: SharedValue<T> | T): T {
-  const [value] = useAnimatedState(initialValue)
-  return value
-}