@websolutespa/bom-mixer-hooks 3.1.0 → 3.1.2

package/src/useSearchParams/useSearchParams.test.ts

@@ -1,65 +1,65 @@
-import { act, renderHook } from '@testing-library/react';
-import { useRouter as useCompatRouter } from 'next/compat/router';
-import { describe, expect, it, vi, type Mock } from 'vitest';
-import { useSearchParams } from './useSearchParams';
-
-vi.mock('next/compat/router', () => ({ useRouter: vi.fn() }));
-
-const useRouter = useCompatRouter as unknown as Mock;
-
-describe('useSearchParams', () => {
-
-  it('should work correctly', async () => {
-    useRouter.mockReturnValue({
-      asPath: '',
-    });
-    const params = {};
-    const { result } = renderHook(() => useSearchParams());
-    expect(result.current.params).toEqual(params);
-  });
-
-  it('should work correctly with params', async () => {
-    useRouter.mockReturnValue({
-      asPath: '?flag=1',
-    });
-    const params = { flag: '1' };
-    const { result } = renderHook(() => useSearchParams());
-    expect(result.current.params).toEqual(params);
-  });
-
-  it('should replace search params silently', async () => {
-    const handler = vi.fn();
-    useRouter.mockReturnValue({
-      asPath: '',
-      replace: handler,
-    });
-    const params = { flag: '1' };
-    const { result } = renderHook(() => useSearchParams());
-    expect(result.current.replaceParamsSilently).toEqual(expect.any(Function));
-    act(() => result.current.replaceParamsSilently(params));
-    expect(handler).toBeCalledTimes(1);
-    expect(handler).toBeCalledWith('', {
-      pathname: '',
-      query: { flag: '1' },
-    }, { shallow: true, scroll: false });
-  });
-
-  it('should replace search params', async () => {
-    const handler = vi.fn();
-    useRouter.mockReturnValue({
-      asPath: '',
-      replace: handler,
-    });
-    const params = { flag: '1' };
-    const { result } = renderHook(() => useSearchParams());
-    window.history.replaceState = vi.fn();
-    expect(result.current.replaceParams).toEqual(expect.any(Function));
-    act(() => result.current.replaceParams(params));
-    expect(handler).toBeCalledTimes(1);
-    expect(handler).toBeCalledWith({
-      pathname: '',
-      query: { flag: '1' },
-    });
-  });
-
-});
+import { act, renderHook } from '@testing-library/react';
+import { useRouter as useCompatRouter } from 'next/compat/router';
+import { describe, expect, it, vi, type Mock } from 'vitest';
+import { useSearchParams } from './useSearchParams';
+
+vi.mock('next/compat/router', () => ({ useRouter: vi.fn() }));
+
+const useRouter = useCompatRouter as unknown as Mock;
+
+describe('useSearchParams', () => {
+
+  it('should work correctly', async () => {
+    useRouter.mockReturnValue({
+      asPath: '',
+    });
+    const params = {};
+    const { result } = renderHook(() => useSearchParams());
+    expect(result.current.params).toEqual(params);
+  });
+
+  it('should work correctly with params', async () => {
+    useRouter.mockReturnValue({
+      asPath: '?flag=1',
+    });
+    const params = { flag: '1' };
+    const { result } = renderHook(() => useSearchParams());
+    expect(result.current.params).toEqual(params);
+  });
+
+  it('should replace search params silently', async () => {
+    const handler = vi.fn();
+    useRouter.mockReturnValue({
+      asPath: '',
+      replace: handler,
+    });
+    const params = { flag: '1' };
+    const { result } = renderHook(() => useSearchParams());
+    expect(result.current.replaceParamsSilently).toEqual(expect.any(Function));
+    act(() => result.current.replaceParamsSilently(params));
+    expect(handler).toBeCalledTimes(1);
+    expect(handler).toBeCalledWith('', {
+      pathname: '',
+      query: { flag: '1' },
+    }, { shallow: true, scroll: false });
+  });
+
+  it('should replace search params', async () => {
+    const handler = vi.fn();
+    useRouter.mockReturnValue({
+      asPath: '',
+      replace: handler,
+    });
+    const params = { flag: '1' };
+    const { result } = renderHook(() => useSearchParams());
+    window.history.replaceState = vi.fn();
+    expect(result.current.replaceParams).toEqual(expect.any(Function));
+    act(() => result.current.replaceParams(params));
+    expect(handler).toBeCalledTimes(1);
+    expect(handler).toBeCalledWith({
+      pathname: '',
+      query: { flag: '1' },
+    });
+  });
+
+});

package/src/useSearchParamsEncoded/useSearchParamsEncoded.test.ts

@@ -1,64 +1,64 @@
-import { act, renderHook } from '@testing-library/react';
-import { useRouter as useCompatRouter } from 'next/compat/router';
-import { describe, expect, it, vi, type Mock } from 'vitest';
-import { useSearchParamsEncoded } from './useSearchParamsEncoded';
-
-vi.mock('next/compat/router', () => ({ useRouter: vi.fn() }));
-
-const useRouter = useCompatRouter as unknown as Mock;
-
-describe('useSearchParamsEncoded', () => {
-
-  it('should work correctly', async () => {
-    useRouter.mockReturnValue({
-      asPath: '',
-    });
-    const { result } = renderHook(() => useSearchParamsEncoded());
-    expect(result.current.params).toEqual(null);
-  });
-
-  it('should work correctly with params', async () => {
-    useRouter.mockReturnValue({
-      asPath: '?params=eyJmbGFnIjoiMSJ9',
-    });
-    const params = { flag: '1' };
-    const { result } = renderHook(() => useSearchParamsEncoded());
-    expect(result.current.params).toEqual(params);
-  });
-
-  it('should replace search params silently', async () => {
-    const handler = vi.fn();
-    useRouter.mockReturnValue({
-      asPath: '',
-      replace: handler,
-    });
-    const params = { flag: '1' };
-    const { result } = renderHook(() => useSearchParamsEncoded());
-    expect(result.current.replaceParamsSilently).toEqual(expect.any(Function));
-    act(() => result.current.replaceParamsSilently(params));
-    expect(handler).toBeCalledTimes(1);
-    expect(handler).toBeCalledWith('', {
-      pathname: '',
-      query: { params: 'eyJmbGFnIjoiMSJ9' },
-    }, { shallow: true, scroll: false });
-  });
-
-  it('should replace search params', async () => {
-    const handler = vi.fn();
-    useRouter.mockReturnValue({
-      asPath: '',
-      replace: handler,
-    });
-    const params = { flag: '1' };
-    const { result } = renderHook(() => useSearchParamsEncoded());
-    window.history.replaceState = vi.fn();
-    expect(result.current.replaceParams).toEqual(expect.any(Function));
-    act(() => result.current.replaceParams(params));
-    expect(handler).toBeCalledTimes(1);
-    expect(handler).toBeCalledWith({
-      pathname: '',
-      query: { params: 'eyJmbGFnIjoiMSJ9' },
-    });
-  });
-
-});
+import { act, renderHook } from '@testing-library/react';
+import { useRouter as useCompatRouter } from 'next/compat/router';
+import { describe, expect, it, vi, type Mock } from 'vitest';
+import { useSearchParamsEncoded } from './useSearchParamsEncoded';
+
+vi.mock('next/compat/router', () => ({ useRouter: vi.fn() }));
+
+const useRouter = useCompatRouter as unknown as Mock;
+
+describe('useSearchParamsEncoded', () => {
+
+  it('should work correctly', async () => {
+    useRouter.mockReturnValue({
+      asPath: '',
+    });
+    const { result } = renderHook(() => useSearchParamsEncoded());
+    expect(result.current.params).toEqual(null);
+  });
+
+  it('should work correctly with params', async () => {
+    useRouter.mockReturnValue({
+      asPath: '?params=eyJmbGFnIjoiMSJ9',
+    });
+    const params = { flag: '1' };
+    const { result } = renderHook(() => useSearchParamsEncoded());
+    expect(result.current.params).toEqual(params);
+  });
+
+  it('should replace search params silently', async () => {
+    const handler = vi.fn();
+    useRouter.mockReturnValue({
+      asPath: '',
+      replace: handler,
+    });
+    const params = { flag: '1' };
+    const { result } = renderHook(() => useSearchParamsEncoded());
+    expect(result.current.replaceParamsSilently).toEqual(expect.any(Function));
+    act(() => result.current.replaceParamsSilently(params));
+    expect(handler).toBeCalledTimes(1);
+    expect(handler).toBeCalledWith('', {
+      pathname: '',
+      query: { params: 'eyJmbGFnIjoiMSJ9' },
+    }, { shallow: true, scroll: false });
+  });
+
+  it('should replace search params', async () => {
+    const handler = vi.fn();
+    useRouter.mockReturnValue({
+      asPath: '',
+      replace: handler,
+    });
+    const params = { flag: '1' };
+    const { result } = renderHook(() => useSearchParamsEncoded());
+    window.history.replaceState = vi.fn();
+    expect(result.current.replaceParams).toEqual(expect.any(Function));
+    act(() => result.current.replaceParams(params));
+    expect(handler).toBeCalledTimes(1);
+    expect(handler).toBeCalledWith({
+      pathname: '',
+      query: { params: 'eyJmbGFnIjoiMSJ9' },
+    });
+  });
+
+});

package/src/useSearchParamsQs/useSearchParamsQs.test.ts

@@ -1,82 +1,82 @@
-import { act, renderHook } from '@testing-library/react';
-import { useRouter as useCompatRouter } from 'next/compat/router';
-import { describe, expect, it, vi, type Mock } from 'vitest';
-import { useSearchParamsQs } from './useSearchParamsQs';
-
-vi.mock('next/compat/router', () => ({ useRouter: vi.fn() }));
-
-const useRouter = useCompatRouter as unknown as Mock;
-
-describe('useSearchParamsQs', () => {
-
-  it('should work correctly', async () => {
-    useRouter.mockReturnValue({
-      asPath: '',
-    });
-    const { result } = renderHook(() => useSearchParamsQs());
-    expect(result.current.params).toEqual({});
-  });
-
-  it('should work correctly with params', async () => {
-    useRouter.mockReturnValue({
-      asPath: '?where[market][equals]=ww',
-    });
-    const params = {
-      where: {
-        market: {
-          equals: 'ww',
-        },
-      },
-    };
-    const { result } = renderHook(() => useSearchParamsQs());
-    expect(result.current.params).toEqual(params);
-  });
-
-  it('should replace search params silently', async () => {
-    const handler = vi.fn();
-    useRouter.mockReturnValue({
-      asPath: '',
-      replace: handler,
-    });
-    const params = {
-      where: {
-        market: {
-          equals: 'ww',
-        },
-      },
-    };
-    const { result } = renderHook(() => useSearchParamsQs());
-    expect(result.current.replaceParamsSilently).toEqual(expect.any(Function));
-    act(() => result.current.replaceParamsSilently(params));
-    expect(handler).toBeCalledTimes(1);
-    expect(handler).toBeCalledWith('', {
-      pathname: '',
-      query: 'where[market][equals]=ww',
-    }, { shallow: true, scroll: false });
-  });
-
-  it('should replace search params', async () => {
-    const handler = vi.fn();
-    useRouter.mockReturnValue({
-      asPath: '',
-      replace: handler,
-    });
-    const params = {
-      where: {
-        market: {
-          equals: 'ww',
-        },
-      },
-    };
-    const { result } = renderHook(() => useSearchParamsQs());
-    window.history.replaceState = vi.fn();
-    expect(result.current.replaceParams).toEqual(expect.any(Function));
-    act(() => result.current.replaceParams(params));
-    expect(handler).toBeCalledTimes(1);
-    expect(handler).toBeCalledWith({
-      pathname: '',
-      query: 'where[market][equals]=ww',
-    });
-  });
-
-});
+import { act, renderHook } from '@testing-library/react';
+import { useRouter as useCompatRouter } from 'next/compat/router';
+import { describe, expect, it, vi, type Mock } from 'vitest';
+import { useSearchParamsQs } from './useSearchParamsQs';
+
+vi.mock('next/compat/router', () => ({ useRouter: vi.fn() }));
+
+const useRouter = useCompatRouter as unknown as Mock;
+
+describe('useSearchParamsQs', () => {
+
+  it('should work correctly', async () => {
+    useRouter.mockReturnValue({
+      asPath: '',
+    });
+    const { result } = renderHook(() => useSearchParamsQs());
+    expect(result.current.params).toEqual({});
+  });
+
+  it('should work correctly with params', async () => {
+    useRouter.mockReturnValue({
+      asPath: '?where[market][equals]=ww',
+    });
+    const params = {
+      where: {
+        market: {
+          equals: 'ww',
+        },
+      },
+    };
+    const { result } = renderHook(() => useSearchParamsQs());
+    expect(result.current.params).toEqual(params);
+  });
+
+  it('should replace search params silently', async () => {
+    const handler = vi.fn();
+    useRouter.mockReturnValue({
+      asPath: '',
+      replace: handler,
+    });
+    const params = {
+      where: {
+        market: {
+          equals: 'ww',
+        },
+      },
+    };
+    const { result } = renderHook(() => useSearchParamsQs());
+    expect(result.current.replaceParamsSilently).toEqual(expect.any(Function));
+    act(() => result.current.replaceParamsSilently(params));
+    expect(handler).toBeCalledTimes(1);
+    expect(handler).toBeCalledWith('', {
+      pathname: '',
+      query: 'where[market][equals]=ww',
+    }, { shallow: true, scroll: false });
+  });
+
+  it('should replace search params', async () => {
+    const handler = vi.fn();
+    useRouter.mockReturnValue({
+      asPath: '',
+      replace: handler,
+    });
+    const params = {
+      where: {
+        market: {
+          equals: 'ww',
+        },
+      },
+    };
+    const { result } = renderHook(() => useSearchParamsQs());
+    window.history.replaceState = vi.fn();
+    expect(result.current.replaceParams).toEqual(expect.any(Function));
+    act(() => result.current.replaceParams(params));
+    expect(handler).toBeCalledTimes(1);
+    expect(handler).toBeCalledWith({
+      pathname: '',
+      query: 'where[market][equals]=ww',
+    });
+  });
+
+});