@zayne-labs/toolkit-react 0.9.46 → 0.9.47

package/dist/esm/index-DeDvIi3X.d.ts

@@ -0,0 +1,277 @@
+import { AnyFunction, CallbackFn, NonEmptyArray, Prettify, SelectorFn } from "@zayne-labs/toolkit-type-helpers";
+import * as react5 from "react";
+import * as react12 from "react";
+import * as react19 from "react";
+import { RefCallback, useEffect } from "react";
+import * as _zayne_labs_toolkit_core7 from "@zayne-labs/toolkit-core";
+import * as _zayne_labs_toolkit_core17 from "@zayne-labs/toolkit-core";
+import * as _zayne_labs_toolkit_core21 from "@zayne-labs/toolkit-core";
+import { AnimationIntervalOptions, LocationInfo, LocationStoreApi, LocationStoreOptions, ScrollObserverOptions, StorageOptions, StorageStoreApi, StoreApi, URLSearchParamsInit } from "@zayne-labs/toolkit-core";
+
+//#region src/hooks/createCustomContext.d.ts
+declare class ContextError extends Error {
+  name: string;
+  constructor(...args: Parameters<typeof Error>);
+}
+declare const getErrorMessage: (hook: string, provider: string) => string;
+type CustomContextOptions<TContextValue, TStrict extends boolean> = {
+  defaultValue?: TContextValue | null;
+  errorMessage?: string;
+  extension?: (contextValue: NoInfer<TContextValue> | null) => TContextValue | null;
+  hookName?: string;
+  name?: string;
+  providerName?: string;
+  strict?: TStrict;
+};
+type UseCustomContextResult<TContextValue, TStrict extends boolean> = TStrict extends true ? TContextValue : TContextValue | null;
+declare const createCustomContext: <TContextValue, TStrict extends boolean = true>(options?: CustomContextOptions<TContextValue, TStrict>) => [react5.Context<TContextValue | null>, () => UseCustomContextResult<TContextValue, TStrict>] & {
+  "~inferredUnion": react5.Context<TContextValue | null> | (() => UseCustomContextResult<TContextValue, TStrict>);
+};
+
+//#endregion
+//#region src/hooks/effects/useAfterMountEffect.d.ts
+declare const useAfterMountEffect: typeof useEffect;
+
+//#endregion
+//#region src/hooks/effects/useAsyncEffect.d.ts
+declare function useAsyncEffect(effect: () => Promise<ReturnType<React.EffectCallback>>, deps?: React.DependencyList): void;
+
+//#endregion
+//#region src/hooks/effects/useEffectOnce.d.ts
+declare const useEffectOnce: (callBackFn: React.EffectCallback) => void;
+
+//#endregion
+//#region src/hooks/effects/useLifeCycle.d.ts
+type Destructor = ReturnType<React.EffectCallback>;
+type LifeCycleOptions = {
+  onMount?: () => void;
+  onUnmount?: Destructor;
+};
+declare const useLifeCycle: ({
+  onMount,
+  onUnmount
+}: LifeCycleOptions) => void;
+
+//#endregion
+//#region src/hooks/effects/useMountEffect.d.ts
+declare const useMountEffect: (callBackFn: () => void) => void;
+
+//#endregion
+//#region src/hooks/effects/useUnMountEffect.d.ts
+declare const useUnmountEffect: (cleanUpFn: Destructor) => void;
+
+//#endregion
+//#region src/hooks/useAnimateElementRefs.d.ts
+type ElementsInfoArray<TTargetElement extends string> = NonEmptyArray<{
+  animationClass: string;
+  targetElement: TTargetElement;
+}>;
+/**
+ * This is a custom React hook that adds and removes animation classes to specified HTML elements.
+ * @param elementsInfoArray - An array of objects that contain information about the animation class and the target HTML element.
+ * @returns - An object containing the refs of the animated elements and a function to handle the initiation and removal animation.
+ */
+declare const useAnimateElementRefs: <TTargetElement extends string>(elementsInfoArray: ElementsInfoArray<TTargetElement>) => {
+  animatedElements: Record<TTargetElement, HTMLElement | null>;
+  handleElementsAnimation: () => void;
+};
+
+//#endregion
+//#region src/hooks/useAnimationInterval.d.ts
+type AnimationOptions = Prettify<AnimationIntervalOptions & {
+  intervalDuration: number | null;
+  onAnimation: () => void;
+}>;
+declare const useAnimationInterval: (options: AnimationOptions) => {
+  start: () => void;
+  stop: () => void;
+};
+
+//#endregion
+//#region src/hooks/useCallbackRef.d.ts
+/**
+ * Returns a stable function that always points to the latest version of the callback function.
+ * @param callbackFn - The function to reference
+ * @returns a stable function that always points to the latest version of the callback function
+ */
+declare const useCallbackRef: <TCallback = AnyFunction>(callbackFn: TCallback | undefined) => TCallback;
+
+//#endregion
+//#region src/hooks/useClickOutside.d.ts
+type UseClickOutsideOptions = {
+  enabled?: boolean;
+};
+declare const useClickOutside: <TElement extends HTMLElement>(refOrRefArray: Array<React.RefObject<TElement>> | React.RefObject<TElement>, callback: (event: MouseEvent | TouchEvent) => void, options?: UseClickOutsideOptions) => void;
+
+//#endregion
+//#region src/hooks/useConstant.d.ts
+declare const useConstant: <TResult>(initCallbackFn: () => TResult) => TResult;
+
+//#endregion
+//#region src/hooks/useCopyToClipboard.d.ts
+declare const useCopyToClipboard: () => {
+  copiedValue: string;
+  handleCopy: (value: string) => void;
+};
+
+//#endregion
+//#region src/hooks/useDebounce.d.ts
+declare const useDebouncedFn: <TParams>(callBackFn: CallbackFn<TParams>, delay: number | undefined) => {
+  (...params: TParams[]): void;
+  (params: TParams | TParams[], overrideOptions: {
+    $delay: number;
+  }): void;
+  cancel: () => void;
+  cancelMaxWait(): void;
+};
+declare const useDebouncedState: <TValue>(defaultValue: TValue, delay: number | undefined) => readonly [TValue, {
+  (...params: react12.SetStateAction<TValue>[]): void;
+  (params: react12.SetStateAction<TValue> | react12.SetStateAction<TValue>[], overrideOptions: {
+    $delay: number;
+  }): void;
+  cancel: () => void;
+  cancelMaxWait(): void;
+}, react12.Dispatch<react12.SetStateAction<TValue>>];
+
+//#endregion
+//#region src/hooks/useDisclosure.d.ts
+type DisclosureOptions = {
+  hasScrollControl?: boolean;
+  initialState?: boolean | (() => boolean);
+};
+declare const useDisclosure: (options?: DisclosureOptions) => {
+  isOpen: boolean;
+  onClose: () => void;
+  onOpen: () => void;
+  onToggle: <TValue>(value?: TValue) => void;
+};
+
+//#endregion
+//#region src/hooks/useIsServer.d.ts
+/**
+ * @description Returns whether the component is currently being server side rendered or
+ * hydrated on the client. Can be used to delay browser-specific rendering
+ * until after hydration.
+ */
+declare const useIsServer: () => boolean;
+
+//#endregion
+//#region src/hooks/useLocationState.d.ts
+type UseLocationResult<TSlice> = [state: TSlice, actions: LocationStoreApi];
+declare const createUseLocationState: (options?: LocationStoreOptions) => Omit<_zayne_labs_toolkit_core7.StoreApi<_zayne_labs_toolkit_core7.URLInfoObject>, "setState" | "resetState"> & {
+  push: (url: string | _zayne_labs_toolkit_core7.PartialURLInfo, options?: {
+    state?: _zayne_labs_toolkit_core7.PartialURLInfo["state"];
+  }) => void;
+  replace: LocationStoreApi["push"];
+  triggerPopstateEvent: (nextLocationState?: LocationInfo["state"]) => void;
+} & (<TSlice = _zayne_labs_toolkit_core7.URLInfoObject>(selector?: SelectorFn<LocationInfo, TSlice>) => UseLocationResult<TSlice>);
+declare const useLocationState: <TSlice = LocationInfo>(selector?: SelectorFn<LocationInfo, TSlice>, options?: LocationStoreOptions) => UseLocationResult<TSlice>;
+
+//#endregion
+//#region src/hooks/useToggle.d.ts
+type InitialState = boolean | (() => boolean);
+declare const useToggle: (initialValue?: InitialState) => readonly [boolean, <TValue>(newValue?: TValue) => void];
+
+//#endregion
+//#region src/hooks/usePresence/types.d.ts
+type UsePresenceOptions<TDuration extends number | undefined> = {
+  defaultValue?: boolean;
+  /**
+   * @description The duration of the animation or transition
+   */
+  duration?: TDuration;
+  /**
+   * @description A callback function that will be called when the animation or transition ends
+   */
+  onExitComplete?: () => void;
+};
+type UsePresenceResult<TElement, TDuration> = Prettify<(TDuration extends undefined ? {
+  elementRef: React.RefObject<TElement>;
+} : unknown) & {
+  isPresent: boolean;
+  isVisible: boolean;
+  toggleVisibility: ReturnType<typeof useToggle>[1];
+}>;
+type TypeOption = {
+  /**
+   * @description The type of animation, whether animation or transition
+   * @default "transition"
+   */
+  type?: "animation" | "transition";
+};
+type UsePresence = <TElement extends HTMLElement, TDuration extends number | undefined = undefined>(options?: Prettify<TypeOption & UsePresenceOptions<TDuration>>) => UsePresenceResult<TElement, TDuration>;
+
+//#endregion
+//#region src/hooks/usePresence/usePresence.d.ts
+/**
+ * usePresence hook provides a way to animate an element, before removing it from the DOM.
+ * @param defaultValue - The default value for the presence state. Defaults to `true`.
+ * @param options - The options for the usePresence hook.
+ * @returns A object containing the boolean that should be used to conditionally render the element (isPresent), another boolean used to toggle the animation classes, and a function to toggle the state.
+ */
+declare const usePresence: UsePresence;
+
+//#endregion
+//#region src/hooks/useScrollObserver.d.ts
+declare const useScrollObserver: <TElement extends HTMLElement>(options?: ScrollObserverOptions) => {
+  isScrolled: boolean;
+  observedElementRef: RefCallback<TElement>;
+};
+
+//#endregion
+//#region src/hooks/useSearch.d.ts
+declare const useSearch: <TData>(initialData: TData[], delay?: number) => {
+  data: TData[];
+  isLoading: boolean;
+  query: string;
+  setQuery: react19.Dispatch<react19.SetStateAction<string>>;
+};
+
+//#endregion
+//#region src/hooks/useSearchParams.d.ts
+type UseSearchParamsOptions = LocationStoreOptions & {
+  action?: "push" | "replace";
+};
+declare const useSearchParams: <TSearchParams extends URLSearchParamsInit>(options?: UseSearchParamsOptions) => readonly [URLSearchParams, {
+  (newQueryParams: TSearchParams | ((prev: URLSearchParams) => TSearchParams)): void;
+  triggerPopstateEvent: (nextLocationState?: _zayne_labs_toolkit_core17.LocationInfo["state"]) => void;
+}];
+declare const useSearchParamsObject: <TSearchParams extends Record<string, string>>(options?: UseSearchParamsOptions) => readonly [TSearchParams, {
+  (newQueryParams: TSearchParams | ((prev: TSearchParams) => TSearchParams)): void;
+  triggerPopstateEvent: (nextLocationState?: _zayne_labs_toolkit_core17.LocationInfo["state"]) => void;
+}];
+
+//#endregion
+//#region src/hooks/useStorageState.d.ts
+type UseStorageResult<TState, TSlice = TState> = [state: TSlice, actions: StorageStoreApi<TState>];
+/**
+ * @description Creates a custom hook that returns a storage state and actions to modify it. You can use this if you need shared options.
+ * @note You must use this if you want to be able to prevent syncing state across tabs.
+ */
+declare const createUseStorageState: <TState>(baseOptions: StorageOptions<TState>) => _zayne_labs_toolkit_core21.StoreApi<TState> & {
+  removeState: () => void;
+} & (<TSlice = TState>(selector?: SelectorFn<TState, TSlice>) => UseStorageResult<TState, TSlice>);
+type UseStorageStateOptions<TValue> = Omit<StorageOptions<TValue>, "initialValue" | "key">;
+declare const useStorageState: <TValue, TSlice = TValue>(key: string, initialValue?: TValue, options?: UseStorageStateOptions<TValue> & {
+  select?: SelectorFn<TValue, TSlice>;
+}) => UseStorageResult<TValue, TSlice>;
+
+//#endregion
+//#region src/hooks/useStore.d.ts
+declare const useStore: <TState, TSlice>(store: StoreApi<TState>, selector?: SelectorFn<TState, TSlice>) => TSlice;
+
+//#endregion
+//#region src/hooks/useThrottle.d.ts
+declare const useThrottleBySetTimeout: <TParams>(callbackFn: CallbackFn<TParams>, delay: number) => {
+  (...params: TParams[]): void;
+  cancelTimeout(): void;
+};
+declare const useThrottleByTimer: <TParams>(callbackFn: CallbackFn<TParams>, delay: number) => (...params: TParams[]) => void;
+declare const useThrottleByFrame: <TParams>(callbackFn: CallbackFn<TParams>) => {
+  (...params: TParams[]): void;
+  cancelAnimation(): void;
+};
+
+//#endregion
+export { ContextError as ContextError$1, CustomContextOptions, createCustomContext as createCustomContext$1, createUseLocationState as createUseLocationState$1, createUseStorageState as createUseStorageState$1, getErrorMessage as getErrorMessage$1, useAfterMountEffect as useAfterMountEffect$1, useAnimateElementRefs as useAnimateElementRefs$1, useAnimationInterval as useAnimationInterval$1, useAsyncEffect as useAsyncEffect$1, useCallbackRef as useCallbackRef$1, useClickOutside as useClickOutside$1, useConstant as useConstant$1, useCopyToClipboard as useCopyToClipboard$1, useDebouncedFn as useDebouncedFn$1, useDebouncedState as useDebouncedState$1, useDisclosure as useDisclosure$1, useEffectOnce as useEffectOnce$1, useIsServer as useIsServer$1, useLifeCycle as useLifeCycle$1, useLocationState as useLocationState$1, useMountEffect as useMountEffect$1, usePresence as usePresence$1, useScrollObserver as useScrollObserver$1, useSearch as useSearch$1, useSearchParams as useSearchParams$1, useSearchParamsObject as useSearchParamsObject$1, useStorageState as useStorageState$1, useStore as useStore$1, useThrottleByFrame as useThrottleByFrame$1, useThrottleBySetTimeout as useThrottleBySetTimeout$1, useThrottleByTimer as useThrottleByTimer$1, useToggle as useToggle$1, useUnmountEffect as useUnmountEffect$1 };
+//# sourceMappingURL=index-DeDvIi3X.d.ts.map

package/dist/esm/utils/index.d.ts

@@ -1,6 +1,7 @@
-import { RefCallback } from 'react';
-import { AnyFunction, UnionDiscriminator, AnyObject, Prettify } from '@zayne-labs/toolkit-type-helpers';
+import { AnyFunction, AnyObject, Prettify, UnionDiscriminator } from "@zayne-labs/toolkit-type-helpers";
+import { RefCallback } from "react";
 
+//#region src/utils/composeRefs.d.ts
 type PossibleRef<TRef extends HTMLElement> = React.Ref<TRef> | undefined;
 /**
  * @description Set a given ref to a given value.
@@ -14,10 +15,14 @@ declare const setRef: <TRef extends HTMLElement>(ref: PossibleRef<TRef>, node: T
 declare const composeRefs: <TRef extends HTMLElement>(...refs: Array<PossibleRef<TRef>>) => RefCallback<TRef>;
 declare const useComposeRefs: <TRef extends HTMLElement>(...refs: Array<PossibleRef<TRef>>) => () => RefCallback<TRef>;
 
+//#endregion
+//#region src/utils/composeEventHandlers.d.ts
 declare const composeTwoEventHandlers: (formerHandler: AnyFunction | undefined, latterHandler: AnyFunction | undefined) => (event: unknown) => unknown;
 declare const composeEventHandlers: (...eventHandlerArray: Array<AnyFunction | undefined>) => (event: unknown) => unknown;
 
-type UnionToIntersection<TUnion> = (TUnion extends unknown ? (param: TUnion) => void : "") extends (param: infer TParam) => void ? TParam : "";
+//#endregion
+//#region src/utils/mergeProps.d.ts
+type UnionToIntersection<TUnion> = (TUnion extends unknown ? (param: TUnion) => void : "") extends ((param: infer TParam) => void) ? TParam : "";
 /**
  * Merges multiple sets of React props.
  *
@@ -34,15 +39,19 @@ type UnionToIntersection<TUnion> = (TUnion extends unknown ? (param: TUnion) =>
  */
 declare const mergeProps: <TProps extends Record<never, never>>(...propsObjectArray: Array<TProps | undefined>) => UnionToIntersection<TProps>;
 
+//#endregion
+//#region src/utils/mergeTwoProps.d.ts
 declare const mergeTwoProps: <TProps extends Record<never, never>>(formerProps: TProps | undefined, latterProps: TProps | undefined) => TProps;
 
+//#endregion
+//#region src/utils/types/common.d.ts
 type ForwardedRefType<TComponent extends HTMLElement | React.ElementType> = TComponent extends React.ElementType ? React.ForwardedRef<React.Ref<TComponent>> : React.ForwardedRef<TComponent>;
 type InferProps<TComponent extends HTMLElement | React.ElementType> = TComponent extends React.ElementType ? React.ComponentPropsWithRef<TComponent> : React.HTMLAttributes<TComponent>;
 type StateSetter<TSetter = unknown> = React.Dispatch<React.SetStateAction<TSetter>>;
 type CssWithCustomProperties<TExtra extends Record<string, string> = NonNullable<unknown>> = React.CSSProperties & Record<`--${string}`, string> & TExtra;
 type DefaultPossibleMessages = {
-    children: "Hey, Sorry but the children prop is redundant since you're currently using the render prop";
-    render: "Hey, Sorry but the render prop is redundant since you're currently using the children prop";
+  children: "Hey, Sorry but the children prop is redundant since you're currently using the render prop";
+  render: "Hey, Sorry but the render prop is redundant since you're currently using the children prop";
 };
 /**
  * @description Represents a set of props that can be used to render a component conditionally based on a discriminated union type.
@@ -51,16 +60,20 @@ type DefaultPossibleMessages = {
  * @template TErrorMessages An object of custom messages to display on the disallowed property.
  */
 type DiscriminatedRenderProps<TRenderPropType, TErrorMessages extends Record<"children" | "render", string> = DefaultPossibleMessages> = UnionDiscriminator<[{
-    children: TRenderPropType;
+  children: TRenderPropType;
 }, {
-    render: TRenderPropType;
+  render: TRenderPropType;
 }], TErrorMessages>;
 
+//#endregion
+//#region src/utils/types/polymorphism.d.ts
 type AsProp<TElement extends React.ElementType> = {
-    as?: TElement;
+  as?: TElement;
 };
 type InferRemainingProps<TElement extends React.ElementType, TProps> = Omit<InferProps<TElement>, keyof TProps>;
 type MergedGivenPropsWithAs<TElement extends React.ElementType, TProps> = Prettify<Omit<AsProp<TElement>, keyof TProps> & TProps>;
 type PolymorphicProps<TElement extends React.ElementType, TProps extends AnyObject = NonNullable<unknown>> = MergedGivenPropsWithAs<TElement, TProps> & InferRemainingProps<TElement, TProps>;
 
-export { type AsProp, type CssWithCustomProperties, type DiscriminatedRenderProps, type ForwardedRefType, type InferProps, type PolymorphicProps, type StateSetter, composeEventHandlers, composeRefs, composeTwoEventHandlers, mergeProps, mergeTwoProps, setRef, useComposeRefs };
+//#endregion
+export { AsProp, CssWithCustomProperties, DiscriminatedRenderProps, ForwardedRefType, InferProps, PolymorphicProps, StateSetter, composeEventHandlers, composeRefs, composeTwoEventHandlers, mergeProps, mergeTwoProps, setRef, useComposeRefs };
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/utils/index.js

@@ -1,123 +1,130 @@
-import { isFunction, isObject } from '@zayne-labs/toolkit-type-helpers';
-import { useCallback } from 'react';
+import { isFunction, isObject } from "@zayne-labs/toolkit-type-helpers";
+import { useCallback } from "react";
 
-// src/utils/composeRefs.ts
-var setRef = (ref, node) => {
-  if (!ref) return;
-  if (isFunction(ref)) {
-    return ref(node);
-  }
-  ref.current = node;
+//#region src/utils/composeRefs.ts
+/**
+* @description Set a given ref to a given value.
+*
+* This utility takes care of different types of refs: callback refs and RefObject(s)
+*/
+const setRef = (ref, node) => {
+	if (!ref) return;
+	if (isFunction(ref)) return ref(node);
+	ref.current = node;
 };
-var composeRefs = (...refs) => {
-  const mergedRefCallBack = (node) => {
-    const cleanupFnArray = refs.map((ref) => setRef(ref, node));
-    const cleanupFn = () => cleanupFnArray.forEach((cleanup) => cleanup?.());
-    return cleanupFn;
-  };
-  return mergedRefCallBack;
+/**
+* @description A utility to combine refs. Accepts callback refs and RefObject(s)
+*/
+const composeRefs = (...refs) => {
+	const mergedRefCallBack = (node) => {
+		const cleanupFnArray = refs.map((ref) => setRef(ref, node));
+		const cleanupFn = () => cleanupFnArray.forEach((cleanup) => cleanup?.());
+		return cleanupFn;
+	};
+	return mergedRefCallBack;
 };
-var useComposeRefs = (...refs) => {
-  const mergedRef = useCallback(() => composeRefs(...refs), refs);
-  return mergedRef;
+const useComposeRefs = (...refs) => {
+	const mergedRef = useCallback(() => composeRefs(...refs), refs);
+	return mergedRef;
 };
-var isSyntheticEvent = (event) => {
-  return isObject(event) && Object.hasOwn(event, "nativeEvent");
+
+//#endregion
+//#region src/utils/composeEventHandlers.ts
+const isSyntheticEvent = (event) => {
+	return isObject(event) && Object.hasOwn(event, "nativeEvent");
 };
-var composeTwoEventHandlers = (formerHandler, latterHandler) => {
-  const mergedEventHandler = (event) => {
-    if (isSyntheticEvent(event)) {
-      const result2 = latterHandler?.(event);
-      if (!event.defaultPrevented) {
-        formerHandler?.(event);
-      }
-      return result2;
-    }
-    const result = latterHandler?.(event);
-    formerHandler?.(event);
-    return result;
-  };
-  return mergedEventHandler;
+const composeTwoEventHandlers = (formerHandler, latterHandler) => {
+	const mergedEventHandler = (event) => {
+		if (isSyntheticEvent(event)) {
+			const result$1 = latterHandler?.(event);
+			if (!event.defaultPrevented) formerHandler?.(event);
+			return result$1;
+		}
+		const result = latterHandler?.(event);
+		formerHandler?.(event);
+		return result;
+	};
+	return mergedEventHandler;
 };
-var composeEventHandlers = (...eventHandlerArray) => {
-  const mergedEventHandler = (event) => {
-    if (eventHandlerArray.length === 0) return;
-    if (eventHandlerArray.length === 1) {
-      return eventHandlerArray[0]?.(event);
-    }
-    let accumulatedHandlers;
-    for (const eventHandler of eventHandlerArray) {
-      if (!eventHandler) continue;
-      accumulatedHandlers = composeTwoEventHandlers(accumulatedHandlers, eventHandler);
-    }
-    return accumulatedHandlers?.(event);
-  };
-  return mergedEventHandler;
+const composeEventHandlers = (...eventHandlerArray) => {
+	const mergedEventHandler = (event) => {
+		if (eventHandlerArray.length === 0) return;
+		if (eventHandlerArray.length === 1) return eventHandlerArray[0]?.(event);
+		let accumulatedHandlers;
+		for (const eventHandler of eventHandlerArray) {
+			if (!eventHandler) continue;
+			accumulatedHandlers = composeTwoEventHandlers(accumulatedHandlers, eventHandler);
+		}
+		return accumulatedHandlers?.(event);
+	};
+	return mergedEventHandler;
 };
-var isEventHandler = (key, value) => {
-  const thirdCharCode = key.codePointAt(2);
-  if (!isFunction(value) || thirdCharCode === void 0) {
-    return false;
-  }
-  const isHandler = key.startsWith("on") && thirdCharCode >= 65 && thirdCharCode <= 90;
-  return isHandler;
+
+//#endregion
+//#region src/utils/mergeTwoProps.ts
+const isEventHandler = (key, value) => {
+	const thirdCharCode = key.codePointAt(2);
+	if (!isFunction(value) || thirdCharCode === void 0) return false;
+	const isHandler = key.startsWith("on") && thirdCharCode >= 65 && thirdCharCode <= 90;
+	return isHandler;
 };
-var mergeTwoClassNames = (formerClassName, latterClassName) => {
-  if (!latterClassName || !formerClassName) {
-    return latterClassName || formerClassName;
-  }
-  return formerClassName + " " + latterClassName;
+const mergeTwoClassNames = (formerClassName, latterClassName) => {
+	if (!latterClassName || !formerClassName) return latterClassName || formerClassName;
+	return formerClassName + " " + latterClassName;
 };
-var mergeTwoProps = (formerProps, latterProps) => {
-  if (!latterProps || !formerProps) {
-    return latterProps ?? formerProps ?? {};
-  }
-  const propsAccumulator = { ...formerProps };
-  for (const latterPropName of Object.keys(latterProps)) {
-    const formerPropValue = formerProps[latterPropName];
-    const latterPropValue = latterProps[latterPropName];
-    if (latterPropName === "className" || latterPropName === "class") {
-      propsAccumulator[latterPropName] = mergeTwoClassNames(
-        formerPropValue,
-        latterPropValue
-      );
-      continue;
-    }
-    if (latterPropName === "style") {
-      propsAccumulator[latterPropName] = {
-        ...formerPropValue,
-        ...latterPropValue
-      };
-      continue;
-    }
-    if (isEventHandler(latterPropName, latterPropValue)) {
-      propsAccumulator[latterPropName] = composeTwoEventHandlers(
-        formerPropValue,
-        latterPropValue
-      );
-      continue;
-    }
-    propsAccumulator[latterPropName] = latterPropValue;
-  }
-  return propsAccumulator;
+const mergeTwoProps = (formerProps, latterProps) => {
+	if (!latterProps || !formerProps) return latterProps ?? formerProps ?? {};
+	const propsAccumulator = { ...formerProps };
+	for (const latterPropName of Object.keys(latterProps)) {
+		const formerPropValue = formerProps[latterPropName];
+		const latterPropValue = latterProps[latterPropName];
+		if (latterPropName === "className" || latterPropName === "class") {
+			propsAccumulator[latterPropName] = mergeTwoClassNames(formerPropValue, latterPropValue);
+			continue;
+		}
+		if (latterPropName === "style") {
+			propsAccumulator[latterPropName] = {
+				...formerPropValue,
+				...latterPropValue
+			};
+			continue;
+		}
+		if (isEventHandler(latterPropName, latterPropValue)) {
+			propsAccumulator[latterPropName] = composeTwoEventHandlers(formerPropValue, latterPropValue);
+			continue;
+		}
+		propsAccumulator[latterPropName] = latterPropValue;
+	}
+	return propsAccumulator;
 };
 
-// src/utils/mergeProps.ts
-var mergeProps = (...propsObjectArray) => {
-  if (propsObjectArray.length === 0) {
-    return {};
-  }
-  if (propsObjectArray.length === 1) {
-    return propsObjectArray[0];
-  }
-  let accumulatedProps = {};
-  for (const propsObject of propsObjectArray) {
-    if (!propsObject) continue;
-    accumulatedProps = mergeTwoProps(accumulatedProps, propsObject);
-  }
-  return accumulatedProps;
+//#endregion
+//#region src/utils/mergeProps.ts
+/**
+* Merges multiple sets of React props.
+*
+* - It follows the Object.assign pattern where the rightmost object's fields overwrite
+* the conflicting ones from others. This doesn't apply to event handlers, `className` and `style` props.
+* - Event handlers are merged such that they are called in sequence (the rightmost one being called first),
+* and allows the user to prevent the previous event handlers from being executed by calling the `preventDefault` method.
+* - It also merges the `className` and `style` props, whereby the classes are concatenated
+* and the rightmost styles overwrite the previous ones.
+*
+* @important **`ref` is not merged.**
+* @param props props to merge.
+* @returns the merged props.
+*/
+const mergeProps = (...propsObjectArray) => {
+	if (propsObjectArray.length === 0) return {};
+	if (propsObjectArray.length === 1) return propsObjectArray[0];
+	let accumulatedProps = {};
+	for (const propsObject of propsObjectArray) {
+		if (!propsObject) continue;
+		accumulatedProps = mergeTwoProps(accumulatedProps, propsObject);
+	}
+	return accumulatedProps;
 };
 
+//#endregion
 export { composeEventHandlers, composeRefs, composeTwoEventHandlers, mergeProps, mergeTwoProps, setRef, useComposeRefs };
-//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/esm/utils/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/utils/composeRefs.ts","../../../src/utils/composeEventHandlers.ts","../../../src/utils/mergeTwoProps.ts","../../../src/utils/mergeProps.ts"],"names":["result","isFunction"],"mappings":"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","file":"index.js","sourcesContent":["import { isFunction } from \"@zayne-labs/toolkit-type-helpers\";\nimport { type RefCallback, useCallback } from \"react\";\n\ntype PossibleRef<TRef extends HTMLElement> = React.Ref<TRef> | undefined;\n\n/**\n * @description Set a given ref to a given value.\n *\n * This utility takes care of different types of refs: callback refs and RefObject(s)\n */\nexport const setRef = <TRef extends HTMLElement>(\n\tref: PossibleRef<TRef>,\n\tnode: TRef | null\n): ReturnType<RefCallback<TRef>> => {\n\tif (!ref) return;\n\n\tif (isFunction(ref)) {\n\t\treturn ref(node);\n\t}\n\n\t// eslint-disable-next-line no-param-reassign -- Mutation is needed here\n\tref.current = node;\n};\n\n/**\n * @description A utility to combine refs. Accepts callback refs and RefObject(s)\n */\nexport const composeRefs = <TRef extends HTMLElement>(\n\t...refs: Array<PossibleRef<TRef>>\n): RefCallback<TRef> => {\n\tconst mergedRefCallBack: RefCallback<TRef> = (node) => {\n\t\tconst cleanupFnArray = refs.map((ref) => setRef(ref, node));\n\n\t\tconst cleanupFn = () => cleanupFnArray.forEach((cleanup) => cleanup?.());\n\n\t\treturn cleanupFn;\n\t};\n\n\treturn mergedRefCallBack;\n};\n\nexport const useComposeRefs = <TRef extends HTMLElement>(...refs: Array<PossibleRef<TRef>>) => {\n\t// eslint-disable-next-line react-hooks/exhaustive-deps -- Allow\n\tconst mergedRef = useCallback(() => composeRefs(...refs), refs);\n\n\treturn mergedRef;\n};\n","import { type AnyFunction, isObject } from \"@zayne-labs/toolkit-type-helpers\";\n\nconst isSyntheticEvent = (event: unknown): event is React.SyntheticEvent => {\n\treturn isObject(event) && Object.hasOwn(event, \"nativeEvent\");\n};\n\nexport const composeTwoEventHandlers = (\n\tformerHandler: AnyFunction | undefined,\n\tlatterHandler: AnyFunction | undefined\n) => {\n\tconst mergedEventHandler = (event: unknown) => {\n\t\tif (isSyntheticEvent(event)) {\n\t\t\tconst result = latterHandler?.(event) as unknown;\n\n\t\t\tif (!event.defaultPrevented) {\n\t\t\t\tformerHandler?.(event);\n\t\t\t}\n\n\t\t\treturn result;\n\t\t}\n\n\t\tconst result = latterHandler?.(event) as unknown;\n\t\tformerHandler?.(event);\n\t\treturn result;\n\t};\n\n\treturn mergedEventHandler;\n};\n\nexport const composeEventHandlers = (...eventHandlerArray: Array<AnyFunction | undefined>) => {\n\tconst mergedEventHandler = (event: unknown) => {\n\t\tif (eventHandlerArray.length === 0) return;\n\n\t\tif (eventHandlerArray.length === 1) {\n\t\t\treturn eventHandlerArray[0]?.(event) as unknown;\n\t\t}\n\n\t\tlet accumulatedHandlers: AnyFunction | undefined;\n\n\t\tfor (const eventHandler of eventHandlerArray) {\n\t\t\tif (!eventHandler) continue;\n\n\t\t\taccumulatedHandlers = composeTwoEventHandlers(accumulatedHandlers, eventHandler);\n\t\t}\n\n\t\treturn accumulatedHandlers?.(event) as unknown;\n\t};\n\n\treturn mergedEventHandler;\n};\n","import { type AnyFunction, isFunction } from \"@zayne-labs/toolkit-type-helpers\";\nimport { composeTwoEventHandlers } from \"./composeEventHandlers\";\n\n// == This approach is more efficient than using a regex.\nconst isEventHandler = (key: string, value: unknown): value is AnyFunction => {\n\tconst thirdCharCode = key.codePointAt(2);\n\n\tif (!isFunction(value) || thirdCharCode === undefined) {\n\t\treturn false;\n\t}\n\n\tconst isHandler = key.startsWith(\"on\") && thirdCharCode >= 65 /* A */ && thirdCharCode <= 90; /* Z */\n\n\treturn isHandler;\n};\n\nconst mergeTwoClassNames = (formerClassName: string | undefined, latterClassName: string | undefined) => {\n\tif (!latterClassName || !formerClassName) {\n\t\t// eslint-disable-next-line ts-eslint/prefer-nullish-coalescing -- Logical OR is fit for this case\n\t\treturn latterClassName || formerClassName;\n\t}\n\n\t// eslint-disable-next-line prefer-template -- String concatenation is more performant than template literals in this case\n\treturn formerClassName + \" \" + latterClassName;\n};\n\nexport const mergeTwoProps = <TProps extends Record<never, never>>(\n\tformerProps: TProps | undefined,\n\tlatterProps: TProps | undefined\n): TProps => {\n\t// == If no props are provided, return an empty object\n\tif (!latterProps || !formerProps) {\n\t\treturn latterProps ?? formerProps ?? ({} as TProps);\n\t}\n\n\tconst propsAccumulator = { ...formerProps } as Record<string, unknown>;\n\n\tfor (const latterPropName of Object.keys(latterProps)) {\n\t\tconst formerPropValue = (formerProps as Record<string, unknown>)[latterPropName];\n\t\tconst latterPropValue = (latterProps as Record<string, unknown>)[latterPropName];\n\n\t\t// == If the prop is `className` or `class`, we merge them\n\t\tif (latterPropName === \"className\" || latterPropName === \"class\") {\n\t\t\tpropsAccumulator[latterPropName] = mergeTwoClassNames(\n\t\t\t\tformerPropValue as string,\n\t\t\t\tlatterPropValue as string\n\t\t\t);\n\t\t\tcontinue;\n\t\t}\n\n\t\t// == If the prop is `style`, we merge them\n\t\tif (latterPropName === \"style\") {\n\t\t\tpropsAccumulator[latterPropName] = {\n\t\t\t\t...(formerPropValue as object),\n\t\t\t\t...(latterPropValue as object),\n\t\t\t};\n\t\t\tcontinue;\n\t\t}\n\n\t\t// == If the handler exists on both, we compose them\n\t\tif (isEventHandler(latterPropName, latterPropValue)) {\n\t\t\tpropsAccumulator[latterPropName] = composeTwoEventHandlers(\n\t\t\t\tformerPropValue as AnyFunction | undefined,\n\t\t\t\tlatterPropValue\n\t\t\t);\n\n\t\t\tcontinue;\n\t\t}\n\n\t\t// == latterProps override by default\n\t\tpropsAccumulator[latterPropName] = latterPropValue;\n\t}\n\n\treturn propsAccumulator as TProps;\n};\n","import { mergeTwoProps } from \"./mergeTwoProps\";\n\ntype UnionToIntersection<TUnion> = (TUnion extends unknown ? (param: TUnion) => void : \"\") extends (\n\tparam: infer TParam\n) => void\n\t? TParam\n\t: \"\";\n\n/**\n * Merges multiple sets of React props.\n *\n * - It follows the Object.assign pattern where the rightmost object's fields overwrite\n * the conflicting ones from others. This doesn't apply to event handlers, `className` and `style` props.\n * - Event handlers are merged such that they are called in sequence (the rightmost one being called first),\n * and allows the user to prevent the previous event handlers from being executed by calling the `preventDefault` method.\n * - It also merges the `className` and `style` props, whereby the classes are concatenated\n * and the rightmost styles overwrite the previous ones.\n *\n * @important **`ref` is not merged.**\n * @param props props to merge.\n * @returns the merged props.\n */\n\nconst mergeProps = <TProps extends Record<never, never>>(\n\t...propsObjectArray: Array<TProps | undefined>\n): UnionToIntersection<TProps> => {\n\tif (propsObjectArray.length === 0) {\n\t\treturn {} as never;\n\t}\n\n\tif (propsObjectArray.length === 1) {\n\t\treturn propsObjectArray[0] as never;\n\t}\n\n\tlet accumulatedProps: Record<string, unknown> = {};\n\n\tfor (const propsObject of propsObjectArray) {\n\t\tif (!propsObject) continue;\n\n\t\taccumulatedProps = mergeTwoProps(accumulatedProps, propsObject);\n\t}\n\n\treturn accumulatedProps as never;\n};\n\nexport { mergeProps };\n"]}
+{"version":3,"file":"index.js","names":["ref: PossibleRef<TRef>","node: TRef | null","mergedRefCallBack: RefCallback<TRef>","event: unknown","formerHandler: AnyFunction | undefined","latterHandler: AnyFunction | undefined","result","accumulatedHandlers: AnyFunction | undefined","key: string","value: unknown","formerClassName: string | undefined","latterClassName: string | undefined","formerProps: TProps | undefined","latterProps: TProps | undefined","accumulatedProps: Record<string, unknown>"],"sources":["../../../src/utils/composeRefs.ts","../../../src/utils/composeEventHandlers.ts","../../../src/utils/mergeTwoProps.ts","../../../src/utils/mergeProps.ts"],"sourcesContent":["import { isFunction } from \"@zayne-labs/toolkit-type-helpers\";\nimport { type RefCallback, useCallback } from \"react\";\n\ntype PossibleRef<TRef extends HTMLElement> = React.Ref<TRef> | undefined;\n\n/**\n * @description Set a given ref to a given value.\n *\n * This utility takes care of different types of refs: callback refs and RefObject(s)\n */\nexport const setRef = <TRef extends HTMLElement>(\n\tref: PossibleRef<TRef>,\n\tnode: TRef | null\n): ReturnType<RefCallback<TRef>> => {\n\tif (!ref) return;\n\n\tif (isFunction(ref)) {\n\t\treturn ref(node);\n\t}\n\n\t// eslint-disable-next-line no-param-reassign -- Mutation is needed here\n\tref.current = node;\n};\n\n/**\n * @description A utility to combine refs. Accepts callback refs and RefObject(s)\n */\nexport const composeRefs = <TRef extends HTMLElement>(\n\t...refs: Array<PossibleRef<TRef>>\n): RefCallback<TRef> => {\n\tconst mergedRefCallBack: RefCallback<TRef> = (node) => {\n\t\tconst cleanupFnArray = refs.map((ref) => setRef(ref, node));\n\n\t\tconst cleanupFn = () => cleanupFnArray.forEach((cleanup) => cleanup?.());\n\n\t\treturn cleanupFn;\n\t};\n\n\treturn mergedRefCallBack;\n};\n\nexport const useComposeRefs = <TRef extends HTMLElement>(...refs: Array<PossibleRef<TRef>>) => {\n\t// eslint-disable-next-line react-hooks/exhaustive-deps -- Allow\n\tconst mergedRef = useCallback(() => composeRefs(...refs), refs);\n\n\treturn mergedRef;\n};\n","import { type AnyFunction, isObject } from \"@zayne-labs/toolkit-type-helpers\";\n\nconst isSyntheticEvent = (event: unknown): event is React.SyntheticEvent => {\n\treturn isObject(event) && Object.hasOwn(event, \"nativeEvent\");\n};\n\nexport const composeTwoEventHandlers = (\n\tformerHandler: AnyFunction | undefined,\n\tlatterHandler: AnyFunction | undefined\n) => {\n\tconst mergedEventHandler = (event: unknown) => {\n\t\tif (isSyntheticEvent(event)) {\n\t\t\tconst result = latterHandler?.(event) as unknown;\n\n\t\t\tif (!event.defaultPrevented) {\n\t\t\t\tformerHandler?.(event);\n\t\t\t}\n\n\t\t\treturn result;\n\t\t}\n\n\t\tconst result = latterHandler?.(event) as unknown;\n\t\tformerHandler?.(event);\n\t\treturn result;\n\t};\n\n\treturn mergedEventHandler;\n};\n\nexport const composeEventHandlers = (...eventHandlerArray: Array<AnyFunction | undefined>) => {\n\tconst mergedEventHandler = (event: unknown) => {\n\t\tif (eventHandlerArray.length === 0) return;\n\n\t\tif (eventHandlerArray.length === 1) {\n\t\t\treturn eventHandlerArray[0]?.(event) as unknown;\n\t\t}\n\n\t\tlet accumulatedHandlers: AnyFunction | undefined;\n\n\t\tfor (const eventHandler of eventHandlerArray) {\n\t\t\tif (!eventHandler) continue;\n\n\t\t\taccumulatedHandlers = composeTwoEventHandlers(accumulatedHandlers, eventHandler);\n\t\t}\n\n\t\treturn accumulatedHandlers?.(event) as unknown;\n\t};\n\n\treturn mergedEventHandler;\n};\n","import { type AnyFunction, isFunction } from \"@zayne-labs/toolkit-type-helpers\";\nimport { composeTwoEventHandlers } from \"./composeEventHandlers\";\n\n// == This approach is more efficient than using a regex.\nconst isEventHandler = (key: string, value: unknown): value is AnyFunction => {\n\tconst thirdCharCode = key.codePointAt(2);\n\n\tif (!isFunction(value) || thirdCharCode === undefined) {\n\t\treturn false;\n\t}\n\n\tconst isHandler = key.startsWith(\"on\") && thirdCharCode >= 65 /* A */ && thirdCharCode <= 90; /* Z */\n\n\treturn isHandler;\n};\n\nconst mergeTwoClassNames = (formerClassName: string | undefined, latterClassName: string | undefined) => {\n\tif (!latterClassName || !formerClassName) {\n\t\t// eslint-disable-next-line ts-eslint/prefer-nullish-coalescing -- Logical OR is fit for this case\n\t\treturn latterClassName || formerClassName;\n\t}\n\n\t// eslint-disable-next-line prefer-template -- String concatenation is more performant than template literals in this case\n\treturn formerClassName + \" \" + latterClassName;\n};\n\nexport const mergeTwoProps = <TProps extends Record<never, never>>(\n\tformerProps: TProps | undefined,\n\tlatterProps: TProps | undefined\n): TProps => {\n\t// == If no props are provided, return an empty object\n\tif (!latterProps || !formerProps) {\n\t\treturn latterProps ?? formerProps ?? ({} as TProps);\n\t}\n\n\tconst propsAccumulator = { ...formerProps } as Record<string, unknown>;\n\n\tfor (const latterPropName of Object.keys(latterProps)) {\n\t\tconst formerPropValue = (formerProps as Record<string, unknown>)[latterPropName];\n\t\tconst latterPropValue = (latterProps as Record<string, unknown>)[latterPropName];\n\n\t\t// == If the prop is `className` or `class`, we merge them\n\t\tif (latterPropName === \"className\" || latterPropName === \"class\") {\n\t\t\tpropsAccumulator[latterPropName] = mergeTwoClassNames(\n\t\t\t\tformerPropValue as string,\n\t\t\t\tlatterPropValue as string\n\t\t\t);\n\t\t\tcontinue;\n\t\t}\n\n\t\t// == If the prop is `style`, we merge them\n\t\tif (latterPropName === \"style\") {\n\t\t\tpropsAccumulator[latterPropName] = {\n\t\t\t\t...(formerPropValue as object),\n\t\t\t\t...(latterPropValue as object),\n\t\t\t};\n\t\t\tcontinue;\n\t\t}\n\n\t\t// == If the handler exists on both, we compose them\n\t\tif (isEventHandler(latterPropName, latterPropValue)) {\n\t\t\tpropsAccumulator[latterPropName] = composeTwoEventHandlers(\n\t\t\t\tformerPropValue as AnyFunction | undefined,\n\t\t\t\tlatterPropValue\n\t\t\t);\n\n\t\t\tcontinue;\n\t\t}\n\n\t\t// == latterProps override by default\n\t\tpropsAccumulator[latterPropName] = latterPropValue;\n\t}\n\n\treturn propsAccumulator as TProps;\n};\n","import { mergeTwoProps } from \"./mergeTwoProps\";\n\ntype UnionToIntersection<TUnion> = (TUnion extends unknown ? (param: TUnion) => void : \"\") extends (\n\tparam: infer TParam\n) => void\n\t? TParam\n\t: \"\";\n\n/**\n * Merges multiple sets of React props.\n *\n * - It follows the Object.assign pattern where the rightmost object's fields overwrite\n * the conflicting ones from others. This doesn't apply to event handlers, `className` and `style` props.\n * - Event handlers are merged such that they are called in sequence (the rightmost one being called first),\n * and allows the user to prevent the previous event handlers from being executed by calling the `preventDefault` method.\n * - It also merges the `className` and `style` props, whereby the classes are concatenated\n * and the rightmost styles overwrite the previous ones.\n *\n * @important **`ref` is not merged.**\n * @param props props to merge.\n * @returns the merged props.\n */\n\nconst mergeProps = <TProps extends Record<never, never>>(\n\t...propsObjectArray: Array<TProps | undefined>\n): UnionToIntersection<TProps> => {\n\tif (propsObjectArray.length === 0) {\n\t\treturn {} as never;\n\t}\n\n\tif (propsObjectArray.length === 1) {\n\t\treturn propsObjectArray[0] as never;\n\t}\n\n\tlet accumulatedProps: Record<string, unknown> = {};\n\n\tfor (const propsObject of propsObjectArray) {\n\t\tif (!propsObject) continue;\n\n\t\taccumulatedProps = mergeTwoProps(accumulatedProps, propsObject);\n\t}\n\n\treturn accumulatedProps as never;\n};\n\nexport { mergeProps };\n"],"mappings":"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"}