DRAFT [feat]: new docs

.gitignore

@@ -222,3 +222,8 @@ generated
 # Reactuse
 
 **/registry.json
+
+
+# Docgen. Generated content
+packages/docs/content/docs/hooks/
+.source

.prettierrc.mjs

@@ -1,3 +1,3 @@
-import { prettier } from "@siberiacancode/prettier";
+import { prettier } from '@siberiacancode/prettier';
 
-export default { ...prettier, plugins: ["prettier-plugin-tailwindcss"] };
+export default { ...prettier, plugins: ['prettier-plugin-tailwindcss'] };

package.json

@@ -26,7 +26,7 @@
   "scripts": {
     "cli:build": "pnpm --filter @siberiacancode/cli build && pnpm --filter @siberiacancode/cli generate-registry",
     "cli:build:registry": "pnpm --filter useverse build:registry",
-    "docs:build": "pnpm --filter @siberiacancode/docs build",
+    "docs:build": "pnpm --filter @siberiacancode/docs build & pnpm format",
     "core:build:js": "pnpm --filter @siberiacancode/reactuse build:js",
     "lint": "pnpm --recursive lint",
     "format": "prettier --write .",

packages/core/src/hooks/useClickOutside/useClickOutside.demo.tsx

@@ -1,4 +1,4 @@
-import { cn } from '@siberiacancode/docs/utils';
+import { cn } from '../../../../docs/lib/utils';
 import { useClickOutside, useCounter } from '@siberiacancode/reactuse';
 
 const Demo = () => {

packages/core/src/hooks/useGamepad/useGamepad.demo.tsx

@@ -1,3 +1,4 @@
+'use client';
 import { useGamepad } from '@siberiacancode/reactuse';
 
 const Demo = () => {

packages/core/src/hooks/useIdle/useIdle.demo.tsx

@@ -1,4 +1,4 @@
-import { cn } from '@siberiacancode/docs/utils';
+import { cn } from '../../../../docs/lib/utils';
 import { useIdle } from '@siberiacancode/reactuse';
 
 const Demo = () => {

packages/core/src/hooks/useMergedRef/useMergedRef.demo.tsx

@@ -1,4 +1,4 @@
-import { cn } from '@siberiacancode/docs/utils';
+import { cn } from '../../../../docs/lib/utils';
 import {
   useClickOutside,
   useCounter,

packages/core/src/hooks/useMouse/useMouse.demo.tsx

@@ -1,4 +1,4 @@
-import { cn } from '@siberiacancode/docs/utils';
+import { cn } from '../../../../docs/lib/utils';
 import { useHover, useMouse } from '@siberiacancode/reactuse';
 
 const Demo = () => {

packages/core/src/hooks/useMutation/useMutation.test.ts

@@ -1,41 +1,35 @@
-import { act, renderHook, waitFor } from "@testing-library/react";
+import { act, renderHook, waitFor } from '@testing-library/react';
 
-import { renderHookServer } from "@/tests";
+import { renderHookServer } from '@/tests';
 
-import { useMutation } from "./useMutation";
+import { useMutation } from './useMutation';
 
-it("Should use mutation", () => {
-  const { result } = renderHook(() =>
-    useMutation(() => Promise.resolve("data"))
-  );
+it('Should use mutation', () => {
+  const { result } = renderHook(() => useMutation(() => Promise.resolve('data')));
 
   expect(result.current.data).toBeNull();
   expect(result.current.error).toBeNull();
   expect(result.current.isError).toBeFalsy();
   expect(result.current.isLoading).toBeFalsy();
   expect(result.current.isSuccess).toBeFalsy();
-  expect(result.current.mutate).toBeTypeOf("function");
-  expect(result.current.mutateAsync).toBeTypeOf("function");
+  expect(result.current.mutate).toBeTypeOf('function');
+  expect(result.current.mutateAsync).toBeTypeOf('function');
 });
 
-it("Should use mutation on server side", () => {
-  const { result } = renderHookServer(() =>
-    useMutation(() => Promise.resolve("data"))
-  );
+it('Should use mutation on server side', () => {
+  const { result } = renderHookServer(() => useMutation(() => Promise.resolve('data')));
 
   expect(result.current.data).toBeNull();
   expect(result.current.error).toBeNull();
   expect(result.current.isError).toBeFalsy();
   expect(result.current.isLoading).toBeFalsy();
   expect(result.current.isSuccess).toBeFalsy();
-  expect(result.current.mutate).toBeTypeOf("function");
-  expect(result.current.mutateAsync).toBeTypeOf("function");
+  expect(result.current.mutate).toBeTypeOf('function');
+  expect(result.current.mutateAsync).toBeTypeOf('function');
 });
 
-it("Should mutate data successfully", async () => {
-  const { result } = renderHook(() =>
-    useMutation(() => Promise.resolve("data"))
-  );
+it('Should mutate data successfully', async () => {
+  const { result } = renderHook(() => useMutation(() => Promise.resolve('data')));
 
   act(result.current.mutate);
 
@@ -45,14 +39,12 @@ it("Should mutate data successfully", async () => {
   await waitFor(() => {
     expect(result.current.isLoading).toBeFalsy();
     expect(result.current.isSuccess).toBeTruthy();
-    expect(result.current.data).toBe("data");
+    expect(result.current.data).toBe('data');
   });
 });
 
-it("Should handle errors", async () => {
-  const { result } = renderHook(() =>
-    useMutation(() => Promise.reject(new Error("error")))
-  );
+it('Should handle errors', async () => {
+  const { result } = renderHook(() => useMutation(() => Promise.reject(new Error('error'))));
 
   await act(async () => {
     try {
@@ -66,29 +58,27 @@ it("Should handle errors", async () => {
   await waitFor(() => {
     expect(result.current.isLoading).toBeFalsy();
     expect(result.current.isError).toBeTruthy();
-    expect(result.current.error).toEqual(new Error("error"));
+    expect(result.current.error).toEqual(new Error('error'));
     expect(result.current.data).toBeNull();
   });
 });
 
-it("Should mutate async", async () => {
-  const { result } = renderHook(() =>
-    useMutation((input) => Promise.resolve(`data-${input}`))
-  );
+it('Should mutate async', async () => {
+  const { result } = renderHook(() => useMutation((input) => Promise.resolve(`data-${input}`)));
 
   await act(async () => {
-    const response = await result.current.mutateAsync("test");
-    expect(response).toBe("data-test");
+    const response = await result.current.mutateAsync('test');
+    expect(response).toBe('data-test');
   });
 
-  expect(result.current.data).toBe("data-test");
+  expect(result.current.data).toBe('data-test');
   expect(result.current.isSuccess).toBeTruthy();
 });
 
-it("Should triggered onSuccess callback", async () => {
+it('Should triggered onSuccess callback', async () => {
   const { result } = renderHook(() =>
-    useMutation(() => Promise.resolve("data"), {
-      onSuccess: (data) => expect(data).toBe("data"),
+    useMutation(() => Promise.resolve('data'), {
+      onSuccess: (data) => expect(data).toBe('data')
     })
   );
 
@@ -97,10 +87,10 @@ it("Should triggered onSuccess callback", async () => {
   await waitFor(() => expect(result.current.isSuccess).toBeTruthy());
 });
 
-it("Should triggered onError callback", async () => {
+it('Should triggered onError callback', async () => {
   const { result } = renderHook(() =>
-    useMutation(() => Promise.reject(new Error("error")), {
-      onError: (error) => expect(error).toEqual(new Error("error")),
+    useMutation(() => Promise.reject(new Error('error')), {
+      onError: (error) => expect(error).toEqual(new Error('error'))
     })
   );
 
@@ -109,19 +99,19 @@ it("Should triggered onError callback", async () => {
   await waitFor(() => expect(result.current.isError).toBeTruthy());
 });
 
-it("Should retry on error once", async () => {
+it('Should retry on error once', async () => {
   let retries = 0;
 
   const { result } = renderHook(() =>
     useMutation(
       () =>
         new Promise((resolve, reject) => {
-          if (retries === 1) resolve("data");
+          if (retries === 1) resolve('data');
           retries++;
-          reject(new Error("error"));
+          reject(new Error('error'));
         }),
       {
-        retry: true,
+        retry: true
       }
     )
   );
@@ -130,22 +120,22 @@ it("Should retry on error once", async () => {
 
   expect(result.current.data).toBeNull();
 
-  await waitFor(() => expect(result.current.data).toBe("data"));
+  await waitFor(() => expect(result.current.data).toBe('data'));
 });
 
-it("Should retry on error multiple times", async () => {
+it('Should retry on error multiple times', async () => {
   let retries = 0;
 
   const { result } = renderHook(() =>
     useMutation(
       () =>
         new Promise((resolve, reject) => {
-          if (retries === 2) resolve("data");
+          if (retries === 2) resolve('data');
           retries++;
-          reject(new Error("error"));
+          reject(new Error('error'));
         }),
       {
-        retry: 2,
+        retry: 2
       }
     )
   );
@@ -154,36 +144,36 @@ it("Should retry on error multiple times", async () => {
 
   expect(result.current.data).toBeNull();
 
-  await waitFor(() => expect(result.current.data).toBe("data"));
+  await waitFor(() => expect(result.current.data).toBe('data'));
 });
 
-it("Should override global options with mutate options", async () => {
+it('Should override global options with mutate options', async () => {
   const globalOnSuccess = vi.fn();
   const localOnSuccess = vi.fn();
 
   const { result } = renderHook(() =>
-    useMutation(() => Promise.resolve("data"), {
-      onSuccess: globalOnSuccess,
+    useMutation(() => Promise.resolve('data'), {
+      onSuccess: globalOnSuccess
     })
   );
 
   act(() => result.current.mutate(undefined, { onSuccess: localOnSuccess }));
 
   await waitFor(() => expect(result.current.isSuccess).toBeTruthy());
 
-  expect(localOnSuccess).toHaveBeenCalledWith("data");
+  expect(localOnSuccess).toHaveBeenCalledWith('data');
   expect(globalOnSuccess).not.toHaveBeenCalled();
 });
 
-it("Should reset error state on successful mutation", async () => {
+it('Should reset error state on successful mutation', async () => {
   let shouldFail = true;
 
   const { result } = renderHook(() =>
     useMutation(() => {
       if (shouldFail) {
-        return Promise.reject(new Error("error"));
+        return Promise.reject(new Error('error'));
       }
-      return Promise.resolve("data");
+      return Promise.resolve('data');
     })
   );
 
@@ -205,35 +195,35 @@ it("Should reset error state on successful mutation", async () => {
   });
 });
 
-it("Should retry by number delay", async () => {
+it('Should retry by number delay', async () => {
   let retries = 0;
   const { result } = renderHook(() =>
     useMutation(() => {
       retries++;
       if (retries < 2) {
-        return Promise.reject(new Error("error"));
+        return Promise.reject(new Error('error'));
       }
-      return Promise.resolve("data");
+      return Promise.resolve('data');
     })
   );
 
   act(() => result.current.mutate(undefined, { retry: 1, retryDelay: 100 }));
 
   expect(result.current.isLoading).toBeTruthy();
 
-  await waitFor(() => expect(result.current.data).toBe("data"));
+  await waitFor(() => expect(result.current.data).toBe('data'));
 });
 
-it("Should retry by number global delay", async () => {
+it('Should retry by number global delay', async () => {
   let retries = 0;
   const { result } = renderHook(() =>
     useMutation(
       () => {
         retries++;
         if (retries < 2) {
-          return Promise.reject(new Error("error"));
+          return Promise.reject(new Error('error'));
         }
-        return Promise.resolve("data");
+        return Promise.resolve('data');
       },
       { retryDelay: 100, retry: 1 }
     )
@@ -243,20 +233,20 @@ it("Should retry by number global delay", async () => {
 
   expect(result.current.isLoading).toBeTruthy();
 
-  await waitFor(() => expect(result.current.data).toBe("data"));
+  await waitFor(() => expect(result.current.data).toBe('data'));
 });
 
-it("Should retry by function delay", async () => {
+it('Should retry by function delay', async () => {
   const retryDelay = vi.fn(() => 100);
   let retries = 0;
 
   const { result } = renderHook(() =>
     useMutation(() => {
       retries++;
       if (retries < 2) {
-        return Promise.reject(new Error("error"));
+        return Promise.reject(new Error('error'));
       }
-      return Promise.resolve("data");
+      return Promise.resolve('data');
     })
   );
 
@@ -265,7 +255,7 @@ it("Should retry by function delay", async () => {
   expect(result.current.isLoading).toBeTruthy();
 
   await waitFor(() => {
-    expect(result.current.data).toBe("data");
+    expect(result.current.data).toBe('data');
     expect(retryDelay).toHaveBeenCalledOnce();
   });
 });