@vkontakte/vkui 6.0.3 → 6.1.0

package/src/hooks/useFocusWithin.test.tsx

@@ -1,38 +0,0 @@
-import * as React from 'react';
-import { act, render, screen } from '@testing-library/react';
-import { useFocusWithin } from './useFocusWithin';
-
-describe(useFocusWithin, () => {
-  let focusWithin: boolean | undefined = undefined;
-  const Playground = (props: React.HTMLAttributes<HTMLDivElement>) => {
-    const ref = React.useRef<HTMLInputElement>(null);
-    focusWithin = useFocusWithin(ref);
-
-    return <input data-testid="input" ref={ref} {...props} />;
-  };
-
-  it('without focus', () => {
-    render(<Playground />);
-    expect(focusWithin).toBeFalsy();
-  });
-
-  it('focus and blur element', async () => {
-    render(<Playground />);
-    const el = screen.getByTestId('input');
-
-    act(() => {
-      el.focus();
-    });
-    expect(focusWithin).toBeTruthy();
-
-    act(() => {
-      el.blur();
-    });
-    expect(focusWithin).toBeFalsy();
-  });
-
-  it('autoFocus', () => {
-    render(<Playground autoFocus />);
-    expect(focusWithin).toBeTruthy();
-  });
-});

package/src/hooks/useGlobalOnClickOutside.test.tsx

@@ -1,98 +0,0 @@
-import * as React from 'react';
-import { fireEvent, render } from '@testing-library/react';
-import { useGlobalOnClickOutside } from './useGlobalOnClickOutside';
-
-interface WrapperUseGlobalOnClickOutsideProps {
-  disableTarget?: 'target-1' | 'target-2';
-  disableAllTarget?: boolean;
-  globalClickHandler: () => void;
-}
-
-const WrapperUseGlobalOnClickOutside = ({
-  disableTarget,
-  disableAllTarget = false,
-  globalClickHandler,
-}: WrapperUseGlobalOnClickOutsideProps) => {
-  const target1Ref = React.createRef<HTMLDivElement>();
-  const target2Ref = React.createRef<HTMLDivElement>();
-
-  useGlobalOnClickOutside(
-    globalClickHandler,
-    disableAllTarget || disableTarget === 'target-1' ? null : target1Ref,
-    disableAllTarget || disableTarget === 'target-2' ? null : target2Ref,
-  );
-
-  return (
-    <div data-testid="root">
-      <div data-testid="outside" />
-      <div data-testid="target-1" ref={target1Ref}></div>
-      <div data-testid="target-2" ref={target2Ref}>
-        <div data-testid="target-2-child" />
-      </div>
-    </div>
-  );
-};
-
-describe(useGlobalOnClickOutside, () => {
-  it('should works with multiple refs provided', () => {
-    const globalClickHandler = jest.fn();
-    const result = render(
-      <WrapperUseGlobalOnClickOutside globalClickHandler={globalClickHandler} />,
-    );
-
-    fireEvent.click(result.getByTestId('target-1'));
-    fireEvent.click(result.getByTestId('target-2'));
-    fireEvent.click(result.getByTestId('target-2-child'));
-    expect(globalClickHandler).not.toHaveBeenCalled();
-
-    fireEvent.click(document.documentElement);
-    fireEvent.click(result.getByTestId('root'));
-    fireEvent.click(result.getByTestId('outside'));
-    expect(globalClickHandler).toHaveBeenCalledTimes(3);
-  });
-
-  it('should work with one ref provided', () => {
-    const globalClickHandler = jest.fn();
-    const result = render(
-      <WrapperUseGlobalOnClickOutside
-        globalClickHandler={globalClickHandler}
-        disableTarget="target-1"
-      />,
-    );
-
-    fireEvent.click(result.getByTestId('target-1'));
-    fireEvent.click(result.getByTestId('target-2'));
-    expect(globalClickHandler).toHaveBeenCalledTimes(1);
-
-    result.rerender(<WrapperUseGlobalOnClickOutside globalClickHandler={globalClickHandler} />);
-
-    fireEvent.click(result.getByTestId('target-1'));
-    fireEvent.click(result.getByTestId('target-2'));
-    fireEvent.click(document.documentElement);
-    fireEvent.click(result.getByTestId('root'));
-    fireEvent.click(result.getByTestId('outside'));
-    expect(globalClickHandler).toHaveBeenCalledTimes(4);
-  });
-
-  it('should clear events if no refs provided', () => {
-    const globalClickHandler = jest.fn();
-
-    const result = render(
-      <WrapperUseGlobalOnClickOutside globalClickHandler={globalClickHandler} />,
-    );
-
-    fireEvent.click(result.getByTestId('target-2'));
-    expect(globalClickHandler).not.toHaveBeenCalled();
-
-    fireEvent.click(result.getByTestId('outside'));
-    expect(globalClickHandler).toHaveBeenCalledTimes(1);
-
-    result.rerender(
-      <WrapperUseGlobalOnClickOutside globalClickHandler={globalClickHandler} disableAllTarget />,
-    );
-
-    fireEvent.click(result.getByTestId('target-2'));
-    fireEvent.click(result.getByTestId('outside'));
-    expect(globalClickHandler).toHaveBeenCalledTimes(1);
-  });
-});

package/src/hooks/useKeyboardInputTracker.test.ts

@@ -1,79 +0,0 @@
-import { act, fireEvent, renderHook } from '@testing-library/react';
-import { FOCUS_ALLOW_LIST_KEYS, Keys } from '../lib/accessibility';
-import {
-  DISABLE_KEYBOARD_INPUT_EVENT_NAME,
-  ENABLE_KEYBOARD_INPUT_EVENT_NAME,
-  useKeyboardInputTracker,
-} from './useKeyboardInputTracker';
-
-describe(useKeyboardInputTracker, () => {
-  const KEYBOARD_EXPECTED_EVENT = { key: Keys.TAB, code: Keys.TAB };
-  const ALL_KEYBOARD_EXPECTED_EVENTS = Array.from(FOCUS_ALLOW_LIST_KEYS).map((key) => ({
-    key,
-    code: key,
-  }));
-  it.each(ALL_KEYBOARD_EXPECTED_EVENTS)(
-    'should returns true when user calls keyDown event with code $key',
-    (event) => {
-      const result = renderHook(() => useKeyboardInputTracker());
-      expect(result.result.current.current).toBeFalsy();
-
-      fireEvent.keyDown(document, event);
-      expect(result.result.current.current).toBeTruthy();
-
-      act(() => {
-        document.dispatchEvent(new Event(DISABLE_KEYBOARD_INPUT_EVENT_NAME, { bubbles: true }));
-      });
-      expect(result.result.current.current).toBeFalsy();
-    },
-  );
-
-  it('should returns true/false when user calls custom event', () => {
-    const result = renderHook(() => useKeyboardInputTracker());
-
-    act(() => {
-      document.dispatchEvent(new Event(ENABLE_KEYBOARD_INPUT_EVENT_NAME, { bubbles: true }));
-    });
-    expect(result.result.current.current).toBeTruthy();
-
-    act(() => {
-      document.dispatchEvent(new Event(DISABLE_KEYBOARD_INPUT_EVENT_NAME, { bubbles: true }));
-    });
-    expect(result.result.current.current).toBeFalsy();
-  });
-
-  it('should returns false when user calls mouseDown event', () => {
-    const result = renderHook(() => useKeyboardInputTracker());
-
-    fireEvent.keyDown(document, KEYBOARD_EXPECTED_EVENT);
-    expect(result.result.current.current).toBeTruthy();
-
-    fireEvent.mouseDown(document);
-    expect(result.result.current.current).toBeFalsy();
-  });
-
-  it('should returns false when user calls touchStart event', () => {
-    const result = renderHook(() => useKeyboardInputTracker());
-
-    fireEvent.keyDown(document, KEYBOARD_EXPECTED_EVENT);
-    expect(result.result.current.current).toBeTruthy();
-
-    fireEvent.touchStart(document);
-    expect(result.result.current.current).toBeFalsy();
-  });
-
-  it('should cleanups events after unmount', () => {
-    const result = renderHook(() => useKeyboardInputTracker());
-
-    fireEvent.keyDown(document, KEYBOARD_EXPECTED_EVENT);
-    expect(result.result.current.current).toBeTruthy();
-
-    fireEvent.touchStart(document);
-    expect(result.result.current.current).toBeFalsy();
-
-    result.unmount();
-
-    fireEvent.keyDown(document, KEYBOARD_EXPECTED_EVENT);
-    expect(result.result.current.current).toBeFalsy();
-  });
-});

package/src/hooks/useObjectMemo.test.tsx

@@ -1,27 +0,0 @@
-import { renderHook } from '@testing-library/react';
-import { useObjectMemo } from './useObjectMemo';
-
-describe(useObjectMemo, () => {
-  it('has object on first render', () => {
-    const { result } = renderHook(useObjectMemo, {
-      initialProps: { hello: 123 },
-    });
-    expect(result.current).toEqual({ hello: 123 });
-  });
-  it('memoizes object', () => {
-    const stableObject = { hello: 123 };
-    const { result, rerender } = renderHook(useObjectMemo, {
-      initialProps: stableObject,
-    });
-    rerender({ hello: 123 });
-    expect(result.current).toBe(stableObject);
-  });
-  it('updates object on change', () => {
-    const stableObject = { hello: 123 };
-    const { result, rerender } = renderHook(useObjectMemo, {
-      initialProps: stableObject,
-    });
-    rerender({ hello: 234 });
-    expect(result.current).toEqual({ hello: 234 });
-  });
-});

package/src/hooks/usePagintaion.test.ts

@@ -1,74 +0,0 @@
-import { renderHook } from '@testing-library/react';
-import { usePagination } from './usePagination';
-
-describe(usePagination, () => {
-  it('Should return single page by default', () => {
-    const pages = renderHook(() => usePagination()).result.current;
-    expect(pages).toEqual([1]);
-  });
-
-  it('Should return empty array if properties incorrect', () => {
-    const { result } = renderHook(() => usePagination({ currentPage: 1, totalPages: 0 }));
-    expect(result.current).toEqual([]);
-  });
-
-  it('Should has no ellipses when count <= 7', () => {
-    const pages = renderHook(() => usePagination({ totalPages: 7 })).result.current;
-    expect(pages).toEqual([1, 2, 3, 4, 5, 6, 7]);
-  });
-
-  it('Should has an end ellipsis by default when count >= 8', () => {
-    const pages = renderHook(() => usePagination({ totalPages: 8 })).result.current;
-    expect(pages).toEqual([1, 2, 3, 4, 5, 'end-ellipsis', 8]);
-  });
-
-  it('Should has a start ellipsis when page >= 5', () => {
-    const pages = renderHook(() => usePagination({ totalPages: 8, currentPage: 5 })).result.current;
-    expect(pages).toEqual([1, 'start-ellipsis', 4, 5, 6, 7, 8]);
-  });
-
-  it('Should has start & end ellipsis when count >= 9', () => {
-    const pages = renderHook(() => usePagination({ totalPages: 9, currentPage: 5 })).result.current;
-    expect(pages).toEqual([1, 'start-ellipsis', 4, 5, 6, 'end-ellipsis', 9]);
-  });
-
-  it('Can have a reduced siblingCount', () => {
-    const pages = renderHook(() =>
-      usePagination({ totalPages: 7, currentPage: 4, siblingCount: 0 }),
-    ).result.current;
-    expect(pages).toEqual([1, 'start-ellipsis', 4, 'end-ellipsis', 7]);
-  });
-
-  it('Can have an increased siblingCount', () => {
-    const pages = renderHook(() =>
-      usePagination({ totalPages: 11, currentPage: 6, siblingCount: 2 }),
-    ).result.current;
-    expect(pages).toEqual([1, 'start-ellipsis', 4, 5, 6, 7, 8, 'end-ellipsis', 11]);
-  });
-
-  it('Can have a reduced boundaryCount', () => {
-    const pages = renderHook(() =>
-      usePagination({ totalPages: 11, currentPage: 6, boundaryCount: 0 }),
-    ).result.current;
-    expect(pages).toEqual(['start-ellipsis', 5, 6, 7, 'end-ellipsis']);
-  });
-
-  it('Can have an increased boundaryCount', () => {
-    const pages = renderHook(() =>
-      usePagination({ totalPages: 11, currentPage: 6, boundaryCount: 2 }),
-    ).result.current;
-    expect(pages).toEqual([1, 2, 'start-ellipsis', 5, 6, 7, 'end-ellipsis', 10, 11]);
-  });
-
-  it('Can have a reduced siblingCount and boundaryCount', () => {
-    const pages = renderHook(() =>
-      usePagination({
-        totalPages: 11,
-        currentPage: 6,
-        siblingCount: 0,
-        boundaryCount: 0,
-      }),
-    ).result.current;
-    expect(pages).toEqual(['start-ellipsis', 6, 'end-ellipsis']);
-  });
-});

package/src/hooks/usePatchChildren.test.tsx

@@ -1,164 +0,0 @@
-import * as React from 'react';
-import { act, fireEvent, render } from '@testing-library/react';
-import { setRef } from '../lib/utils';
-import type { HasRootRef } from '../types';
-import { usePatchChildren } from './usePatchChildren';
-
-const ComponentWithGetRootRef = ({
-  getRootRef,
-  ...restProps
-}: HasRootRef<HTMLDivElement> & React.DOMAttributes<HTMLDivElement>) => (
-  <div ref={getRootRef} {...restProps}></div>
-);
-
-const ComponentWithForwardRef = React.forwardRef<
-  HTMLDivElement,
-  React.HTMLAttributes<HTMLDivElement>
->((props, ref) => <div ref={ref} {...props}></div>);
-
-type WrapperWithUsePatchChildrenRefProps = {
-  childRef?: React.RefObject<HTMLDivElement>;
-  refHook?: React.RefObject<HTMLDivElement>;
-} & React.HTMLAttributes<HTMLDivElement>;
-
-const WrapperWithUsePatchChildrenRef = ({
-  children,
-  childRef: childRefProp,
-  refHook,
-  ...restProps
-}: WrapperWithUsePatchChildrenRefProps) => {
-  const [childRef, child] = usePatchChildren<HTMLDivElement>(children, restProps, refHook);
-
-  React.useEffect(() => {
-    if (childRef.current && childRefProp) {
-      setRef<HTMLDivElement>(childRef.current, childRefProp);
-    }
-  }, [childRef, childRefProp]);
-
-  return <div data-testid="child">{child}</div>;
-};
-
-describe(usePatchChildren, () => {
-  it.each([
-    { type: 'element', refPropKey: 'childRef' },
-    { type: 'element', refPropKey: 'refHook' },
-    { type: 'component', refPropKey: 'childRef' },
-    { type: 'component', refPropKey: 'refHook' },
-    { type: 'forwardRef', refPropKey: 'refHook' },
-    { type: 'forwardRef', refPropKey: 'childRef' },
-  ])('should get ref by $type with $refPropKey', ({ type, refPropKey }) => {
-    const refByTestingHook = React.createRef<HTMLDivElement>();
-    const refForCompare = React.createRef<HTMLDivElement>();
-
-    let reactElement: React.ReactNode = null;
-    switch (type) {
-      case 'element':
-        reactElement = <div ref={refForCompare} />;
-        break;
-      case 'component':
-        reactElement = <ComponentWithGetRootRef getRootRef={refForCompare} />;
-        break;
-      case 'forwardRef':
-        reactElement = <ComponentWithForwardRef ref={refForCompare} />;
-        break;
-    }
-
-    const result = render(
-      <WrapperWithUsePatchChildrenRef {...{ [refPropKey]: refByTestingHook }}>
-        {reactElement}
-      </WrapperWithUsePatchChildrenRef>,
-    );
-
-    act(() => {
-      expect(refByTestingHook).toEqual(refForCompare);
-    });
-
-    expect(result.getByTestId('child')).not.toBeEmptyDOMElement();
-  });
-
-  it.each([
-    { type: 'element', event: 'onMouseEnter', hasOwnEvent: false },
-    { type: 'element', event: 'onMouseEnter', hasOwnEvent: true },
-    { type: 'component', event: 'onMouseEnter', hasOwnEvent: false },
-    { type: 'component', event: 'onMouseEnter', hasOwnEvent: true },
-  ])(
-    'should inject $event event to $type (hasOwnEvent: $hasOwnEvent)',
-    ({ type, event, hasOwnEvent }) => {
-      const reactElementRef = React.createRef<HTMLDivElement>();
-      const ownEvent = {
-        someIntValue: 1,
-        someBoolValue: false,
-        onMouseEnter: jest.fn(),
-        onMouseLeave: jest.fn(),
-      };
-
-      let reactElement: React.ReactNode = null;
-      switch (type) {
-        case 'element': {
-          const props = hasOwnEvent ? ownEvent : {};
-          reactElement = <div ref={reactElementRef} {...props} />;
-          break;
-        }
-        case 'component': {
-          const props = hasOwnEvent ? ownEvent : {};
-          reactElement = <ComponentWithGetRootRef getRootRef={reactElementRef} {...props} />;
-          break;
-        }
-      }
-
-      const injectedEvents = {
-        [event]: jest.fn(),
-        onClick: jest.fn(),
-      };
-
-      render(
-        <WrapperWithUsePatchChildrenRef {...injectedEvents}>
-          {reactElement}
-        </WrapperWithUsePatchChildrenRef>,
-      );
-
-      act(() => {
-        fireEvent.mouseEnter(reactElementRef.current!);
-        fireEvent.click(reactElementRef.current!);
-      });
-
-      expect(ownEvent.someIntValue).toBe(1);
-      expect(ownEvent.someBoolValue).toBeFalsy();
-      expect(ownEvent.onMouseEnter).toHaveBeenCalledTimes(hasOwnEvent ? 1 : 0);
-      expect(ownEvent.onMouseLeave).toHaveBeenCalledTimes(0);
-      expect(injectedEvents.onMouseEnter).toHaveBeenCalledTimes(1);
-      expect(injectedEvents.onClick).toHaveBeenCalledTimes(1);
-    },
-  );
-
-  it.each([{ type: 'fragment' }, { type: 'array' }])(
-    'should ignore invalid like $type',
-    ({ type }) => {
-      const refByTestingHook = React.createRef<HTMLDivElement>();
-
-      let reactElement: React.ReactNode = null;
-      switch (type) {
-        case 'fragment': {
-          reactElement = <React.Fragment>Fragment</React.Fragment>;
-          break;
-        }
-        case 'array': {
-          reactElement = [<div key="1" />, <div key="2" />];
-          break;
-        }
-      }
-
-      const result = render(
-        <WrapperWithUsePatchChildrenRef childRef={refByTestingHook}>
-          {reactElement}
-        </WrapperWithUsePatchChildrenRef>,
-      );
-
-      act(() => {
-        expect(refByTestingHook.current).toBeNull();
-      });
-
-      expect(result.getByTestId('child')).not.toBeEmptyDOMElement();
-    },
-  );
-});

package/src/hooks/usePlatform.test.tsx

@@ -1,39 +0,0 @@
-import * as React from 'react';
-import { renderHook } from '@testing-library/react';
-import { ConfigProvider } from '../components/ConfigProvider/ConfigProvider';
-import { HasChildren } from '../types';
-import { usePlatform } from './usePlatform';
-
-describe(usePlatform, () => {
-  it("returns ConfigProvider's platform", () => {
-    const wrapper = ({ children }: HasChildren) => (
-      <ConfigProvider platform="ios">{children}</ConfigProvider>
-    );
-
-    const { result } = renderHook(() => usePlatform(), { wrapper });
-
-    expect(result.current).toEqual('ios');
-  });
-
-  it("handles ConfigProvider's without platform", () => {
-    const wrapper = ({ children }: HasChildren) => <ConfigProvider>{children}</ConfigProvider>;
-
-    const { result } = renderHook(() => usePlatform(), { wrapper });
-
-    expect(result.current).toEqual('android');
-  });
-
-  it("handles ConfigProvider's no platform", () => {
-    const wrapper = ({ children }: HasChildren) => <ConfigProvider>{children}</ConfigProvider>;
-
-    const { result } = renderHook(() => usePlatform(), { wrapper });
-
-    expect(result.current).toEqual('android');
-  });
-
-  it('handles no ConfigProvider', () => {
-    const { result } = renderHook(() => usePlatform());
-
-    expect(result.current).toEqual('android');
-  });
-});

package/src/hooks/useStableCallback.test.ts

@@ -1,23 +0,0 @@
-import * as React from 'react';
-import { renderHook } from '@testing-library/react';
-import { useStableCallback } from './useStableCallback';
-
-describe(useStableCallback, () => {
-  it('should save first provided fn', () => {
-    const fn1 = jest.fn();
-    const stableCallback = renderHook((fn) => useStableCallback(fn), {
-      initialProps: fn1,
-    });
-    const memo = renderHook((fn) => React.useMemo(() => fn(), [fn]), {
-      initialProps: stableCallback.result.current,
-    });
-
-    expect(fn1).toHaveBeenCalledTimes(1);
-
-    const fn2 = jest.fn();
-    stableCallback.rerender(fn2);
-    memo.rerender(stableCallback.result.current);
-
-    expect(fn2).toHaveBeenCalledTimes(0);
-  });
-});

package/src/hooks/useTimeout.test.ts

@@ -1,49 +0,0 @@
-import { act, renderHook } from '@testing-library/react';
-import { noop } from '@vkontakte/vkjs';
-import { fakeTimers, runAllTimers } from '../testing/utils';
-import { useTimeout } from './useTimeout';
-
-describe(useTimeout, () => {
-  fakeTimers();
-  it('sets timeout', () => {
-    const cb = jest.fn();
-    const { result } = renderHook(() => useTimeout(cb, 100));
-    act(() => {
-      result.current.set();
-    });
-    runAllTimers();
-    expect(cb).toBeCalledTimes(1);
-  });
-  it('clears timeout on unmount', () => {
-    const { result, unmount } = renderHook(() => useTimeout(noop, 100));
-    // run useEffect
-    runAllTimers();
-    act(() => {
-      result.current.set();
-    });
-    unmount();
-    expect(jest.getTimerCount()).toBe(0);
-  });
-  it('calls current callback', () => {
-    const { result, rerender } = renderHook((cb: VoidFunction = noop) => useTimeout(cb, 100));
-    act(() => {
-      result.current.set();
-    });
-    const cb = jest.fn();
-    rerender(cb);
-    runAllTimers();
-    expect(cb).toBeCalledTimes(1);
-  });
-  it('set() replaces old timeout', () => {
-    const cb = jest.fn();
-    const { result } = renderHook(() => useTimeout(cb, 100));
-    act(() => {
-      result.current.set();
-    });
-    act(() => {
-      result.current.set();
-    });
-    runAllTimers();
-    expect(cb).toBeCalledTimes(1);
-  });
-});

package/src/lib/SSR.test.ts

@@ -1,66 +0,0 @@
-import { renderHook } from '@testing-library/react';
-import { usePlatform } from '../hooks/usePlatform';
-import { createWrapper } from '../testing/createWrapper';
-import { SSRWrapper, SSRWrapperProps } from './SSR';
-
-describe.each<{
-  props: SSRWrapperProps;
-  expectPlatform: string;
-}>([
-  { props: {}, expectPlatform: 'android' },
-  {
-    props: {
-      userAgent: '',
-    },
-    expectPlatform: 'android',
-  },
-  {
-    props: {
-      userAgent:
-        'Mozilla/5.0 (iPhone; CPU iPhone OS 16_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.4 Mobile/15E148 Safari/604.1',
-    },
-    expectPlatform: 'ios',
-  },
-  {
-    props: {
-      userAgent:
-        'Mozilla/5.0 (iPhone; CPU iPhone OS 16_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/112.0.5615.46 Mobile/15E148 Safari/604.1',
-    },
-    expectPlatform: 'ios',
-  },
-  {
-    props: {
-      userAgent:
-        'Mozilla/5.0 (iPhone; CPU iPhone OS 16_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) FxiOS/111.0 Mobile/15E148 Safari/605.1.15',
-    },
-    expectPlatform: 'ios',
-  },
-  {
-    props: {
-      browserInfo: {
-        userAgent: '',
-        system: '',
-        systemVersion: null,
-      },
-    },
-    expectPlatform: 'android',
-  },
-  {
-    props: {
-      browserInfo: {
-        userAgent: '',
-        system: 'ios',
-        systemVersion: null,
-      },
-    },
-    expectPlatform: 'ios',
-  },
-])('SSRWrapper($props)', ({ props, expectPlatform }) => {
-  test(`usePlatform() return ${expectPlatform}`, () => {
-    const renderHookResult = renderHook(() => usePlatform(), {
-      wrapper: createWrapper(SSRWrapper, props),
-    });
-
-    expect(renderHookResult.result.current).toBe(expectPlatform);
-  });
-});