@boxcustodia/library 2.0.0-alpha.18 → 2.0.0-alpha.19

package/src/hooks/{useLocalStorage/__doc__/useLocalStorage.stories.tsx → use-local-storage/use-local-storage.stories.tsx}

@@ -1,7 +1,7 @@
 import { Meta } from "@storybook/react-vite";
 import { Trash } from "lucide-react";
-import { Button, Input } from "../../../components";
-import useLocalStorage from "../useLocalStorage";
+import { Button, Input } from "../../components";
+import { useLocalStorage } from "../use-local-storage";
 
 /**
  * Hook que proporciona una interfaz sencilla para interactuar con el localStorage de manera tipada.

package/src/hooks/{useLocalStorage/__test__/useLocalStorage.test.ts → use-local-storage/use-local-storage.test.ts}

@@ -1,6 +1,6 @@
 import { act, renderHook } from "@testing-library/react";
 import { beforeEach, describe, expect, it, vi } from "vitest";
-import useLocalStorage from "../useLocalStorage";
+import { useLocalStorage } from "../use-local-storage";
 
 describe("useLocalStorage hook", () => {
   const key = "testKey";
@@ -82,4 +82,50 @@ describe("useLocalStorage hook", () => {
 
     consoleErrorSpy.mockRestore();
   });
+
+  it("calls removeItem when storedValue is undefined (no initial value)", () => {
+    const removeItemMock = vi.fn();
+    vi.stubGlobal("localStorage", {
+      getItem: vi.fn().mockReturnValue(null),
+      setItem: vi.fn(),
+      removeItem: removeItemMock,
+      clear: vi.fn(),
+    });
+    renderHook(() => useLocalStorage<string>("empty-key"));
+    expect(removeItemMock).toHaveBeenCalledWith("empty-key");
+    vi.unstubAllGlobals();
+  });
+
+  it("handles localStorage.setItem errors in useEffect gracefully", () => {
+    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    vi.stubGlobal("localStorage", {
+      getItem: vi.fn().mockReturnValue(null),
+      setItem: vi.fn().mockImplementation(() => {
+        throw new Error("Storage full");
+      }),
+      removeItem: vi.fn(),
+      clear: vi.fn(),
+    });
+    renderHook(() => useLocalStorage<string>("err-key", "value"));
+    expect(errorSpy).toHaveBeenCalled();
+    vi.unstubAllGlobals();
+    errorSpy.mockRestore();
+  });
+
+  it("handles localStorage.removeItem errors in remove() gracefully", () => {
+    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    vi.stubGlobal("localStorage", {
+      getItem: vi.fn().mockReturnValue(JSON.stringify("value")),
+      setItem: vi.fn(),
+      removeItem: vi.fn().mockImplementation(() => {
+        throw new Error("remove error");
+      }),
+      clear: vi.fn(),
+    });
+    const { result } = renderHook(() => useLocalStorage<string>("key", "value"));
+    act(() => result.current[2]());
+    expect(errorSpy).toHaveBeenCalled();
+    vi.unstubAllGlobals();
+    errorSpy.mockRestore();
+  });
 });

package/src/hooks/{useLocalStorage/useLocalStorage.ts → use-local-storage/use-local-storage.ts}

@@ -1,13 +1,13 @@
 import { useEffect, useState } from "react";
 
-function useLocalStorage<T>(
+export function useLocalStorage<T>(
   key: string,
 ): [T | undefined, (value: T) => void, () => void];
-function useLocalStorage<T>(
+export function useLocalStorage<T>(
   key: string,
   initialValue: T,
 ): [T, (value: T) => void, () => void];
-function useLocalStorage<T>(
+export function useLocalStorage<T>(
   key: string,
   initialValue?: T,
 ): [T | undefined, (value: T) => void, () => void] {
@@ -54,4 +54,3 @@ function useLocalStorage<T>(
   return [storedValue, setValue, remove];
 }
 
-export default useLocalStorage;

package/src/hooks/use-media-query/index.ts

@@ -0,0 +1 @@
+export * from "./use-media-query";

package/src/hooks/{useMediaQuery/__doc__/useMediaQuery.stories.tsx → use-media-query/use-media-query.stories.tsx}

@@ -1,5 +1,5 @@
 import { Meta } from "@storybook/react-vite";
-import useMediaQuery from "../useMediaQuery";
+import { useMediaQuery } from "../use-media-query";
 
 const meta: Meta = {
   title: "hooks/useMediaQuery",

package/src/hooks/{useMediaQuery/useMediaQuery.ts → use-media-query/use-media-query.ts}

@@ -1,6 +1,6 @@
 import { useEffect, useState } from "react";
 
-const useMediaQuery = (query: string): boolean => {
+export const useMediaQuery = (query: string): boolean => {
   const [matches, setMatches] = useState<boolean>(false);
 
   useEffect(() => {
@@ -18,5 +18,3 @@ const useMediaQuery = (query: string): boolean => {
 
   return matches;
 };
-
-export default useMediaQuery;

package/src/hooks/use-memoized-fn/index.ts

@@ -0,0 +1 @@
+export * from "./use-memoized-fn";

package/src/hooks/use-memoized-fn/use-memoized-fn.test.ts

@@ -0,0 +1,52 @@
+import { renderHook } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import { useMemoizedFn } from "./use-memoized-fn";
+
+describe("useMemoizedFn", () => {
+  it("returns a stable function reference across re-renders", () => {
+    const fn = vi.fn();
+    const { result, rerender } = renderHook(() => useMemoizedFn(fn));
+    const first = result.current;
+    rerender();
+    expect(result.current).toBe(first);
+  });
+
+  it("calls the latest version of the function", () => {
+    const first = vi.fn(() => "first");
+    const second = vi.fn(() => "second");
+
+    const { result, rerender } = renderHook(({ fn }) => useMemoizedFn(fn), {
+      initialProps: { fn: first as () => string },
+    });
+
+    const stable = result.current;
+
+    rerender({ fn: second });
+
+    expect(stable()).toBe("second");
+    expect(first).not.toHaveBeenCalled();
+    expect(second).toHaveBeenCalledOnce();
+  });
+
+  it("forwards arguments correctly", () => {
+    const fn = vi.fn((a: number, b: string) => `${a}-${b}`);
+    const { result } = renderHook(() => useMemoizedFn(fn));
+
+    const ret = result.current(1, "hello");
+
+    expect(fn).toHaveBeenCalledWith(1, "hello");
+    expect(ret).toBe("1-hello");
+  });
+
+  it("logs error when non-function is passed", () => {
+    const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+
+    renderHook(() => useMemoizedFn("not-a-function" as any));
+
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining("useMemoizedFn expected parameter is a function"),
+    );
+
+    consoleSpy.mockRestore();
+  });
+});

package/src/hooks/{useMemoizedFn/useMemoizedFn.ts → use-memoized-fn/use-memoized-fn.ts}

@@ -1,4 +1,3 @@
-import { isFunction } from "lodash";
 import { useMemo, useRef } from "react";
 
 type noop = (this: any, ...args: any[]) => any;
@@ -8,8 +7,8 @@ type PickFunction<T extends noop> = (
   ...args: Parameters<T>
 ) => ReturnType<T>;
 
-function useMemoizedFn<T extends noop>(fn: T) {
-  if (!isFunction(fn)) {
+export function useMemoizedFn<T extends noop>(fn: T) {
+  if (typeof fn !== "function") {
     console.error(
       `useMemoizedFn expected parameter is a function, got ${typeof fn}`,
     );
@@ -29,4 +28,3 @@ function useMemoizedFn<T extends noop>(fn: T) {
   return memoizedFn.current as T;
 }
 
-export default useMemoizedFn;

package/src/hooks/use-mutation/index.ts

@@ -0,0 +1 @@
+export * from "./use-mutation";

package/src/hooks/{useMutation/__doc__/useMutation.stories.tsx → use-mutation/use-mutation.stories.tsx}

@@ -1,9 +1,9 @@
 import { Meta } from "@storybook/react-vite";
 import { FormEvent } from "react";
-import { Button, Input } from "../../../components";
-import { getFormData } from "../../../utils";
-import useAsync from "../../useAsync/useAsync";
-import useMutation from "../useMutation";
+import { Button, Input } from "../../components";
+import { getFormData } from "../../utils";
+import { useAsync } from "../use-async/use-async";
+import { useMutation } from "../use-mutation";
 
 /**
  * El hook `useMutation` permite manejar operaciones de mutación asincrónicas, proporcionando estados de carga, error y éxito.

package/src/hooks/{useMutation/__test__/useMutation.test.tsx → use-mutation/use-mutation.test.tsx}

@@ -1,6 +1,6 @@
 import { renderHook, waitFor } from "@testing-library/react";
 import { describe, expect, it, vi } from "vitest";
-import useMutation from "../useMutation";
+import { useMutation } from "../use-mutation";
 
 const mockMutationSuccess = async (data: any) => {
   return new Promise((resolve) => setTimeout(() => resolve(data), 100));

package/src/hooks/{useMutation/useMutation.tsx → use-mutation/use-mutation.tsx}

@@ -23,18 +23,18 @@ export const useMutation = <TArgs extends any[], TReturn>(
 ): UseMutationReturn<TArgs, TReturn> => {
   const [loading, setLoading] = useState(false);
   const [error, setError] = useState<Error | null>(null);
-  const [data, setdata] = useState<TReturn | null>(null);
+  const [data, setData] = useState<TReturn | null>(null);
 
   const mutate = useCallback(
     async (...args: TArgs) => {
       setLoading(true);
       setError(null);
-      setdata(null);
+      setData(null);
 
       try {
         const result = await opts.fn(...args);
         opts.onSuccess?.(result);
-        setdata(result);
+        setData(result);
         return result;
       } catch (err) {
         const error = err as Error;
@@ -57,4 +57,3 @@ export const useMutation = <TArgs extends any[], TReturn>(
   };
 };
 
-export default useMutation;

package/src/hooks/use-object/index.ts

@@ -0,0 +1 @@
+export * from "./use-object";

package/src/hooks/{useObject/__doc__/useObject.stories.tsx → use-object/use-object.stories.tsx}

@@ -1,7 +1,7 @@
 import { Meta } from "@storybook/react-vite";
 import { ChevronLeft, ChevronRight } from "lucide-react";
-import { Button, Input } from "../../../components";
-import useObject from "../useObject";
+import { Button, Input } from "../../components";
+import { useObject } from "../use-object";
 
 /**
  * Hook para manejar un estado en forma de objeto

package/src/hooks/{useObject/__test__/useObject.test.tsx → use-object/use-object.test.tsx}

@@ -1,7 +1,6 @@
-import { renderHook } from "@testing-library/react";
-import { act } from "react";
+import { act, renderHook } from "@testing-library/react";
 import { describe, expect, it } from "vitest";
-import useObject from "../useObject";
+import { useObject } from "../use-object";
 
 describe("useObject hook", () => {
   it("should initialize with default state", () => {
@@ -84,4 +83,20 @@ describe("useObject hook", () => {
 
     expect(result.current[0]).toEqual({ count: 1, name: "updated" });
   });
+
+  it("function update returning non-object keeps previous state", () => {
+    const { result } = renderHook(() => useObject({ count: 1 }));
+    act(() => {
+      result.current[1]((_state) => null as any);
+    });
+    expect(result.current[0]).toEqual({ count: 1 });
+  });
+
+  it("non-function non-object arg keeps previous state", () => {
+    const { result } = renderHook(() => useObject({ count: 1 }));
+    act(() => {
+      result.current[1](42 as any);
+    });
+    expect(result.current[0]).toEqual({ count: 1 });
+  });
 });

package/src/hooks/{useObject/useObject.tsx → use-object/use-object.tsx}

@@ -1,4 +1,3 @@
-import { isFunction, isObject } from "lodash";
 import { useCallback, useState } from "react";
 
 type GenericObject = Record<string, any>;
@@ -11,9 +10,9 @@ type MaybeReturn<TState> = Return<
   ((state: TState | undefined) => Partial<TState>) | Partial<TState>
 >;
 
-function useObject<T extends GenericObject>(): MaybeReturn<T>;
-function useObject<T extends GenericObject>(initialValue: T): Return<T>;
-function useObject<T extends GenericObject>(initialValue?: T) {
+export function useObject<T extends GenericObject>(): MaybeReturn<T>;
+export function useObject<T extends GenericObject>(initialValue: T): Return<T>;
+export function useObject<T extends GenericObject>(initialValue?: T) {
   const [state, setState] = useState<T | undefined>(initialValue);
 
   const reset = useCallback(() => setState(initialValue), [initialValue]);
@@ -21,16 +20,16 @@ function useObject<T extends GenericObject>(initialValue?: T) {
   const setNewState = useCallback(
     (arg: ((state: T | undefined) => Partial<T>) | Partial<T>) => {
       setState((prevState) => {
-        if (isFunction(arg)) {
+        if (typeof arg === "function") {
           const newState = arg(prevState);
-          if (isObject(newState)) {
+          if (newState !== null && typeof newState === "object") {
             return {
               ...prevState,
               ...newState,
             } as T;
           }
           return prevState;
-        } else if (isObject(arg)) {
+        } else if (arg !== null && typeof arg === "object") {
           return {
             ...prevState,
             ...arg,
@@ -45,4 +44,3 @@ function useObject<T extends GenericObject>(initialValue?: T) {
   return [state, setNewState, reset] as const;
 }
 
-export default useObject;

package/src/hooks/use-on-mount/use-on-mount.test.tsx

@@ -1,4 +1,5 @@
 import { renderHook } from "@testing-library/react";
+import { StrictMode } from "react";
 import { describe, expect, it, vi } from "vitest";
 import { useOnMount } from "./use-on-mount";
 
@@ -41,4 +42,10 @@ describe("useOnMount", () => {
     const { unmount } = renderHook(() => useOnMount(() => undefined));
     expect(() => unmount()).not.toThrow();
   });
+
+  it("guard prevents double-run in React StrictMode", () => {
+    const fn = vi.fn();
+    renderHook(() => useOnMount(fn), { wrapper: StrictMode });
+    expect(fn).toHaveBeenCalledTimes(1);
+  });
 });

package/src/hooks/use-pagination/index.ts

@@ -0,0 +1 @@
+export * from "./use-pagination";

package/src/hooks/{usePagination/__doc__/usePagination.stories.tsx → use-pagination/use-pagination.stories.tsx}

@@ -1,8 +1,8 @@
 import { Meta } from "@storybook/react-vite";
 import { useState } from "react";
 import { action } from "storybook/actions";
-import { Button } from "../../../components";
-import usePagination from "../usePagination";
+import { Button } from "../../components";
+import { usePagination } from "../use-pagination";
 
 const TABLE_PAGE_SIZES = [5, 10, 20, 50, 100];
 /**

package/src/hooks/{usePagination/__test__/usePagination.test.tsx → use-pagination/use-pagination.test.tsx}

@@ -1,6 +1,6 @@
 import { act, renderHook, waitFor } from "@testing-library/react";
 import { describe, expect, it } from "vitest";
-import usePagination from "../usePagination";
+import { usePagination } from "../use-pagination";
 
 describe("usePagination hook", () => {
   it("should be defined", () => {

package/src/hooks/{usePagination/usePagination.tsx → use-pagination/use-pagination.tsx}

@@ -31,7 +31,7 @@ export type usePaginationProps = {
   onChange?: (value: { currentPage: number; pageSize: number }) => void;
 };
 
-function usePagination({
+export function usePagination({
   totalItems,
   pageSize,
   currentPage: currentPageProp,
@@ -83,4 +83,3 @@ function usePagination({
   };
 }
 
-export default usePagination;

package/src/hooks/use-portal/index.ts

@@ -0,0 +1 @@
+export * from "./use-portal";

package/src/hooks/{usePortal/__doc__/usePortal.stories.tsx → use-portal/use-portal.stories.tsx}

@@ -1,5 +1,5 @@
 import { Meta } from "@storybook/react-vite";
-import usePortal from "../usePortal";
+import { usePortal } from "../use-portal";
 
 const meta: Meta = {
   title: "hooks/usePortal",

package/src/hooks/use-portal/use-portal.test.tsx

@@ -0,0 +1,77 @@
+import { render, renderHook, screen } from "@testing-library/react";
+import { afterEach, describe, expect, it } from "vitest";
+import { usePortal } from "../use-portal";
+
+describe("usePortal hook", () => {
+  afterEach(() => {
+    document.body.innerHTML = "";
+  });
+
+  it("should be defined", () => {
+    const { result } = renderHook(() => usePortal("id"));
+    expect(result.current).toBeDefined();
+  });
+
+  it("should render element", () => {
+    const Component = () => {
+      const { render } = usePortal("id2");
+      return render(<div>Hello World</div>);
+    };
+
+    render(<Component />);
+    expect(screen.getByText("Hello World")).toBeInTheDocument();
+  });
+
+  it("removes the wrapper from the DOM when the hook unmounts", () => {
+    const Component = () => {
+      const { render } = usePortal("created-by-hook");
+      return render(<span>portal child</span>);
+    };
+
+    const view = render(<Component />);
+    expect(document.getElementById("created-by-hook")).not.toBeNull();
+
+    view.unmount();
+    expect(document.getElementById("created-by-hook")).toBeNull();
+  });
+
+  it("does not remove a wrapper that already existed in the DOM", () => {
+    const preExisting = document.createElement("div");
+    preExisting.id = "pre-existing";
+    preExisting.textContent = "external";
+    document.body.appendChild(preExisting);
+
+    const Component = () => {
+      const { render } = usePortal("pre-existing");
+      return render(<span>child</span>);
+    };
+
+    const view = render(<Component />);
+    view.unmount();
+
+    expect(document.getElementById("pre-existing")).toBe(preExisting);
+    expect(preExisting.textContent).toContain("external");
+  });
+
+  it("shares a wrapper across multiple instances and removes it only after the last unmount", () => {
+    const A = () => {
+      const { render } = usePortal("shared");
+      return render(<span>a</span>);
+    };
+    const B = () => {
+      const { render } = usePortal("shared");
+      return render(<span>b</span>);
+    };
+
+    const viewA = render(<A />);
+    const viewB = render(<B />);
+
+    expect(document.getElementById("shared")).not.toBeNull();
+
+    viewA.unmount();
+    expect(document.getElementById("shared")).not.toBeNull();
+
+    viewB.unmount();
+    expect(document.getElementById("shared")).toBeNull();
+  });
+});

package/src/hooks/use-portal/use-portal.ts

@@ -0,0 +1,59 @@
+import type { ReactNode, ReactPortal } from "react";
+import { useEffect, useState } from "react";
+import { createPortal } from "react-dom";
+
+type PortalEntry = {
+  node: HTMLElement;
+  count: number;
+  createdByHook: boolean;
+};
+
+const portals = new Map<string, PortalEntry>();
+
+function acquire(id: string): HTMLElement {
+  const existing = portals.get(id);
+  if (existing) {
+    existing.count += 1;
+    return existing.node;
+  }
+
+  const preExisting = document.getElementById(id);
+  if (preExisting) {
+    portals.set(id, { node: preExisting, count: 1, createdByHook: false });
+    return preExisting;
+  }
+
+  const node = document.createElement("div");
+  node.id = id;
+  document.body.appendChild(node);
+  portals.set(id, { node, count: 1, createdByHook: true });
+  return node;
+}
+
+function release(id: string) {
+  const entry = portals.get(id);
+  if (!entry) return;
+  entry.count -= 1;
+  if (entry.count > 0) return;
+  if (entry.createdByHook && entry.node.parentNode) {
+    entry.node.parentNode.removeChild(entry.node);
+  }
+  portals.delete(id);
+}
+
+export function usePortal(id: string) {
+  const [wrapper, setWrapper] = useState<HTMLElement | null>(null);
+
+  useEffect(() => {
+    const node = acquire(id);
+    setWrapper(node);
+    return () => {
+      release(id);
+    };
+  }, [id]);
+
+  return {
+    render: (children: ReactNode): ReactPortal | null =>
+      wrapper ? createPortal(children, wrapper) : null,
+  };
+}

package/src/hooks/use-prevent-close-window/index.ts

@@ -0,0 +1 @@
+export * from "./use-prevent-close-window";

package/src/hooks/{usePreventCloseWindow/__doc__/usePreventCloseWindow.stories.tsx → use-prevent-close-window/use-prevent-close-window.stories.tsx}

@@ -1,5 +1,5 @@
 import { Meta } from "@storybook/react-vite";
-import usePreventCloseWindow from "../usePreventCloseWindow";
+import { usePreventCloseWindow } from "./use-prevent-close-window";
 
 /**
  * Hook que permite prevenir que se cierre la ventana (muestra mensaje de aviso)

package/src/hooks/use-prevent-close-window/use-prevent-close-window.test.ts

@@ -0,0 +1,79 @@
+import { renderHook } from "@testing-library/react";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import usePreventCloseWindow from "./use-prevent-close-window";
+
+describe("usePreventCloseWindow", () => {
+  let addSpy: ReturnType<typeof vi.spyOn>;
+  let removeSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    addSpy = vi.spyOn(window, "addEventListener");
+    removeSpy = vi.spyOn(window, "removeEventListener");
+  });
+
+  afterEach(() => {
+    addSpy.mockRestore();
+    removeSpy.mockRestore();
+  });
+
+  it("registers beforeunload listener on mount", () => {
+    renderHook(() => usePreventCloseWindow({ shouldPrevent: true }));
+    expect(addSpy).toHaveBeenCalledWith("beforeunload", expect.any(Function));
+  });
+
+  it("removes beforeunload listener on unmount", () => {
+    const { unmount } = renderHook(() =>
+      usePreventCloseWindow({ shouldPrevent: true }),
+    );
+    unmount();
+    expect(removeSpy).toHaveBeenCalledWith(
+      "beforeunload",
+      expect.any(Function),
+    );
+  });
+
+  it("calls event.preventDefault when shouldPrevent is true", () => {
+    renderHook(() => usePreventCloseWindow({ shouldPrevent: true }));
+
+    const handler = addSpy.mock.calls.find(
+      ([event]: [string, EventListenerOrEventListenerObject]) =>
+        event === "beforeunload",
+    )?.[1] as EventListener;
+
+    const event = new Event("beforeunload");
+    const preventSpy = vi.spyOn(event, "preventDefault");
+    handler(event);
+
+    expect(preventSpy).toHaveBeenCalled();
+  });
+
+  it("does not call event.preventDefault when shouldPrevent is false", () => {
+    renderHook(() => usePreventCloseWindow({ shouldPrevent: false }));
+
+    const handler = addSpy.mock.calls.find(
+      ([event]: [string, EventListenerOrEventListenerObject]) =>
+        event === "beforeunload",
+    )?.[1] as EventListener;
+
+    const event = new Event("beforeunload");
+    const preventSpy = vi.spyOn(event, "preventDefault");
+    handler(event);
+
+    expect(preventSpy).not.toHaveBeenCalled();
+  });
+
+  it("re-registers listener when shouldPrevent changes", () => {
+    const { rerender } = renderHook(
+      ({ shouldPrevent }) => usePreventCloseWindow({ shouldPrevent }),
+      { initialProps: { shouldPrevent: false } },
+    );
+
+    rerender({ shouldPrevent: true });
+
+    expect(removeSpy).toHaveBeenCalledWith(
+      "beforeunload",
+      expect.any(Function),
+    );
+    expect(addSpy).toHaveBeenCalledTimes(2);
+  });
+});

package/src/hooks/{usePreventCloseWindow/usePreventCloseWindow.ts → use-prevent-close-window/use-prevent-close-window.ts}

@@ -1,6 +1,6 @@
 import { useEffect } from "react";
 
-interface UsePreventUnloadProps {
+interface UsePreventCloseWindowProps {
   /**
    * Propiedad que determina si la ventana se puede cerrar o no
    */
@@ -12,10 +12,10 @@ interface UsePreventUnloadProps {
   message?: string;
 }
 
-function usePreventClose({
+export function usePreventCloseWindow({
   shouldPrevent,
   message = "Es posible que no se guarden los cambios hayas hecho.",
-}: UsePreventUnloadProps) {
+}: UsePreventCloseWindowProps) {
   const handleBeforeUnload = (event: BeforeUnloadEvent): void | string => {
     if (!shouldPrevent) return;
 
@@ -30,4 +30,4 @@ function usePreventClose({
   }, [message, shouldPrevent]);
 }
 
-export default usePreventClose;
+export default usePreventCloseWindow;

package/src/hooks/use-range-pagination/index.ts

@@ -0,0 +1 @@
+export * from "./use-range-pagination";