@24i/bigscreen-sdk 0.9.9-alpha.2154 → 1.0.0-alpha.2054

package/packages/rnv-build-engine/dist/templates/platforms/tizen/project/config.xml

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<widget xmlns="http://www.w3.org/ns/widgets" xmlns:tizen="http://tizen.org/ns/widgets" id="https://24i.com/apps/smartapps/bigscreen/{{configProps.id}}" version="{{APP_VERSION}}" viewmodes="maximized">
+    <tizen:application id="{{configProps.id}}" package="{{configProps.package}}" required_version="2.3"/>
+    <name>{{configProps.appName}}</name>
+    <content src="public/index.html"/>
+    <icon src="app_icon_512x512.png"/>
+    <access origin="*" subdomains="true"></access>
+    <feature name="http://tizen.org/feature/screen.size.normal.{{configProps.webpackConfig.resolution.width}}.{{configProps.webpackConfig.resolution.height}}"/>
+    <feature name="http://tizen.org/feature/network.internet"/>
+    <feature name="http://tizen.org/api/tizen" required="true"/>
+    <tizen:profile name="tv-samsung"/>
+    <tizen:privilege name="http://developer.samsung.com/privilege/network.public"/>
+    <tizen:privilege name="http://developer.samsung.com/privilege/productinfo"/>
+    <tizen:privilege name="http://tizen.org/privilege/internet"/>
+    <tizen:privilege name="http://tizen.org/privilege/tv.inputdevice"/>
+    <tizen:setting screen-orientation="landscape" context-menu="enable" background-support="disable" encryption="disable" install-location="auto" hwkey-event="enable"/>
+</widget>

package/packages/rnv-build-engine/dist/templates/platforms/webos/project/.project

@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>{{configProps.title}}</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.wst.common.project.facet.core.builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.wst.jsdt.core.javascriptValidator</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>com.webos.ide.nature.WebOSBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.wst.validation.validationbuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>com.webos.ide.project.nature</nature>
+		<nature>org.eclipse.wst.jsdt.core.jsNature</nature>
+		<nature>org.eclipse.wst.common.project.facet.core.nature</nature>
+		<nature>org.eclipse.wst.common.modulecore.ModuleCoreNature</nature>
+	</natures>
+</projectDescription>

package/packages/rnv-build-engine/dist/templates/platforms/webos/project/appinfo.json

@@ -0,0 +1,19 @@
+{
+    "icon": "app_icon_80x80.png",
+    "id": "{{configProps.id}}",
+    "largeIcon": "app_icon_130x130.png",
+    "main": "public/index.html",
+    "splashBackground": "splash_background_1920x1080.png",
+    "title": "{{configProps.title}}",
+    "type": "web",
+    "vendor": "{{configProps.author.name}}",
+    "version": "{{configProps.packageVersion}}",
+    "appDescription": "{{configProps.description}}",
+    "bgColor": "{{configProps.backgroundColor}}",
+    "bgImage": "{{configProps.appinfo.bgImage}}",
+    "disableBackHistoryAPI": true,
+    "handlesRelaunch": "{{configProps.appinfo.handlesRelaunch}}",
+    "iconColor": "{{configProps.appinfo.iconColor}}",
+    "resolution": "{{configProps.webpackConfig.resolution.width}}x{{configProps.webpackConfig.resolution.height}}",
+    "transparent": "{{configProps.appinfo.transparent}}"
+}

package/packages/rnv-build-engine/dist/templates/platforms/webos/webpackPlatformProps.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webpackPlatformProps = void 0;
+exports.webpackPlatformProps = {
+    metaTags: `
+        <meta name="viewport" content="width={{APP_WIDTH}}, initial-scale=1, shrink-to-fit=no" />
+    `,
+};

package/packages/scroll-text/src/Base.tsx

@@ -78,6 +78,10 @@ export class ScrollTextBase extends Component<Props> implements IFocusable {
         if (processed) stopEvent(event);
     };
 
+    onMouseEnter = () => {
+        this.focus({ preventScroll: true });
+    };
+
     updateArrowNavigation(enable: boolean) {
         if (enable) {
             removeClass(this.arrowNavRef.current!.domRef, DISABLED_CLASS);
@@ -118,6 +122,7 @@ export class ScrollTextBase extends Component<Props> implements IFocusable {
                 className={className}
                 ref={this.domRef}
                 onKeyDown={this.onKeyDown}
+                onMouseEnter={this.onMouseEnter}
                 tabIndex={0}
             >
                 <Scroller

package/packages/utils/src/textUtils.ts

@@ -0,0 +1,25 @@
+const ELLIPSIS = '...';
+
+export const trimWithLeadingEllipsis = (row: HTMLSpanElement) => {
+    if (row && row.textContent != null) {
+        row.style.visibility = 'hidden';
+        const lineHeightString = window.getComputedStyle(row, null).getPropertyValue('line-height');
+        const lineHeight = parseInt(lineHeightString, 10);
+        let numberOfLines = row.offsetHeight / lineHeight;
+        if (numberOfLines > 2) {
+            const originalTextContent = row.textContent;
+            row.textContent = ELLIPSIS;
+            let stringBuffer = '';
+            let currentPosition = originalTextContent.length - 1;
+            do {
+                const charToAdd = originalTextContent.at(currentPosition);
+                stringBuffer = `${charToAdd}${stringBuffer}`;
+                row.textContent = `${ELLIPSIS}${stringBuffer}`;
+                currentPosition -= 1;
+                numberOfLines = Math.floor(row.offsetHeight / lineHeight);
+            } while (numberOfLines <= 2 && currentPosition >= 0);
+            row.textContent = `${ELLIPSIS}${stringBuffer.substring(1)}`;
+        }
+        row.style.visibility = 'visible';
+    }
+};

package/packages/focus/src/__test__/candidate.spec.tsx

@@ -1,245 +0,0 @@
-import { Component, createRef, removeNode } from '@24i/bigscreen-sdk/jsx';
-import { shallow, MountedComponent } from '@24i/bigscreen-sdk/jsx/test-utils';
-import {
-    focusCandidate,
-    setFocusCandidate,
-    setActiveElementAsFocusCandidate,
-    setNextFocusCandidate,
-    setCandidateFallback,
-    getLastCandidate,
-    getCandidateStack,
-    clearCandidateStack,
-} from '../candidate';
-
-class MockComponent extends Component<{}> {
-    wrapperRef = createRef<HTMLDivElement>();
-
-    focus(options?: FocusOptions) {
-        this.wrapperRef.current!.focus(options);
-    }
-
-    render() {
-        return <div tabIndex={0} ref={this.wrapperRef} />;
-    }
-}
-
-describe('Focus candidate', () => {
-    let elementStructure: MountedComponent<HTMLDivElement>;
-    const refs = {
-        testElement: createRef<HTMLDivElement>(),
-        testComponent1: createRef<MockComponent>(),
-        testComponent2: createRef<MockComponent>(),
-    };
-
-    beforeEach(() => {
-        elementStructure = shallow<HTMLDivElement>(
-            <div tabIndex={0}>
-                <div
-                    ref={refs.testElement}
-                    tabIndex={0}
-                    className="test-element"
-                />
-                <MockComponent ref={refs.testComponent1} />
-                <MockComponent ref={refs.testComponent2} />
-            </div>,
-        );
-    });
-
-    afterEach(() => {
-        jest.clearAllMocks();
-        clearCandidateStack();
-        elementStructure.unmount();
-    });
-
-    it('should register a candidate', () => {
-        refs.testElement.current!.focus();
-        setActiveElementAsFocusCandidate();
-        expect(getLastCandidate()).toBe(refs.testElement.current!);
-    });
-
-    it('should register a manual candidate', () => {
-        setFocusCandidate(refs.testComponent1.current!);
-        expect(getLastCandidate()).toBe(refs.testComponent1.current!);
-    });
-
-    it('should register the next candidate', () => {
-        setNextFocusCandidate(refs.testComponent1.current!);
-        expect(getLastCandidate()).toBe(refs.testComponent1.current!);
-    });
-
-    it('should not register the same candidates twice', () => {
-        refs.testElement.current!.focus();
-        setActiveElementAsFocusCandidate();
-        setActiveElementAsFocusCandidate();
-        expect(getCandidateStack()).toEqual([
-            refs.testElement.current!,
-        ]);
-    });
-
-    it('should the focus candidate', () => {
-        elementStructure.ref().focus();
-        setActiveElementAsFocusCandidate();
-        refs.testElement.current!.focus();
-        focusCandidate();
-        expect(document.activeElement).toBe(elementStructure.ref());
-    });
-
-    it('should fill and pop the candidate stack properly', () => {
-        elementStructure.ref().focus();
-        setActiveElementAsFocusCandidate();
-        refs.testElement.current!.focus();
-        setActiveElementAsFocusCandidate();
-        refs.testComponent1.current!.focus();
-        setActiveElementAsFocusCandidate();
-        refs.testComponent2.current!.focus();
-        setActiveElementAsFocusCandidate();
-        expect(getCandidateStack()).toEqual([
-            elementStructure.ref(),
-            refs.testElement.current!,
-            refs.testComponent1.current!.wrapperRef.current!,
-            refs.testComponent2.current!.wrapperRef.current!,
-        ]);
-        // the last registered is skipped, because it's the current activeElement
-        // so the method should be called only 3x
-        focusCandidate();
-        focusCandidate();
-        focusCandidate();
-        expect(getCandidateStack()).toEqual([]);
-    });
-
-    it('should focus candidates during stack popping', () => {
-        elementStructure.ref().focus();
-        setActiveElementAsFocusCandidate();
-        refs.testElement.current!.focus();
-        setActiveElementAsFocusCandidate();
-        refs.testComponent1.current!.focus();
-        setActiveElementAsFocusCandidate();
-        refs.testComponent2.current!.focus();
-        focusCandidate();
-        expect(document.activeElement).toBe(refs.testComponent1.current!.wrapperRef.current!);
-        focusCandidate();
-        expect(document.activeElement).toBe(refs.testElement.current!);
-        focusCandidate();
-        expect(document.activeElement).toBe(elementStructure.ref());
-    });
-
-    it('should work with the next candidate', () => {
-        elementStructure.ref().focus();
-        setActiveElementAsFocusCandidate();
-        setNextFocusCandidate(refs.testElement.current!);
-        refs.testElement.current!.focus();
-        focusCandidate();
-        expect(document.activeElement).toBe(elementStructure.ref());
-    });
-
-    it('should work with the candidate as a component', () => {
-        refs.testComponent1.current!.focus();
-        setNextFocusCandidate(refs.testComponent1.current!);
-        refs.testComponent2.current!.focus();
-        setNextFocusCandidate(refs.testComponent2.current!);
-        expect(getCandidateStack()).toEqual([
-            refs.testComponent1.current!,
-            refs.testComponent2.current!,
-        ]);
-        // last candidate shoul'd not be focused
-        // because last focused candidate can't be currently focused element
-        focusCandidate();
-        expect(document.activeElement).toBe(refs.testComponent1.current!.wrapperRef.current!);
-    });
-
-    it('should work with the candidate as a reference', () => {
-        refs.testComponent1.current!.focus();
-        setNextFocusCandidate(refs.testComponent1);
-        refs.testComponent2.current!.focus();
-        setNextFocusCandidate(refs.testComponent2);
-        expect(getCandidateStack()).toEqual([
-            refs.testComponent1,
-            refs.testComponent2,
-        ]);
-        focusCandidate();
-        expect(document.activeElement).toBe(refs.testComponent1.current!.wrapperRef.current!);
-    });
-
-    it('should work with the candidate as multiple types and focus only unique elements', () => {
-        refs.testElement.current!.focus();
-        setActiveElementAsFocusCandidate();
-        refs.testComponent1.current!.focus();
-        setNextFocusCandidate(refs.testComponent1);
-        refs.testComponent2.current!.focus();
-        setNextFocusCandidate(refs.testComponent2.current!);
-        expect(getCandidateStack()).toEqual([
-            refs.testElement.current!,
-            refs.testComponent1,
-            refs.testComponent2.current!,
-        ]);
-        focusCandidate();
-        expect(document.activeElement).toBe(refs.testComponent1.current!.wrapperRef.current!);
-        focusCandidate();
-        expect(document.activeElement).toBe(refs.testElement.current!);
-    });
-
-    it('should work with the next candidate as a component', () => {
-        refs.testComponent1.current!.focus();
-        setFocusCandidate(refs.testComponent1.current!);
-        refs.testComponent2.current!.focus();
-        setNextFocusCandidate(refs.testComponent2.current!);
-        expect(getCandidateStack()).toEqual([
-            refs.testComponent1.current!,
-            refs.testComponent2.current!,
-        ]);
-        focusCandidate();
-        expect(document.activeElement).toBe(refs.testComponent1.current!.wrapperRef.current!);
-    });
-
-    it('should not focus an unavailable candidate', () => {
-        elementStructure.ref().focus();
-        setActiveElementAsFocusCandidate();
-        refs.testElement.current!.focus();
-        setActiveElementAsFocusCandidate();
-        refs.testComponent1.current!.focus();
-        setFocusCandidate(refs.testComponent1.current!);
-
-        refs.testElement.current!.style.display = 'none';
-        removeNode(refs.testComponent1.current!.wrapperRef);
-
-        focusCandidate();
-        expect(document.activeElement).toBe(elementStructure.ref());
-    });
-
-    it('should set and work with a candidate fallback', () => {
-        setCandidateFallback(elementStructure.ref());
-
-        refs.testElement.current!.focus();
-        setActiveElementAsFocusCandidate();
-        refs.testComponent1.current!.focus();
-        setActiveElementAsFocusCandidate();
-        refs.testComponent2.current!.focus();
-        setActiveElementAsFocusCandidate();
-
-        refs.testElement.current!.style.display = 'none';
-        removeNode(refs.testComponent1.current!.wrapperRef);
-        removeNode(refs.testComponent2.current!.wrapperRef);
-
-        focusCandidate();
-        expect(document.activeElement).toBe(elementStructure.ref());
-    });
-
-    it('should clear the candidate stack', () => {
-        elementStructure.ref().focus();
-        setActiveElementAsFocusCandidate();
-        refs.testElement.current!.focus();
-        setActiveElementAsFocusCandidate();
-        refs.testComponent1.current!.focus();
-        setActiveElementAsFocusCandidate();
-
-        expect(getCandidateStack()).toEqual([
-            elementStructure.ref(),
-            refs.testElement.current!,
-            refs.testComponent2.current!.wrapperRef.current!,
-        ]);
-
-        clearCandidateStack();
-
-        expect(getCandidateStack()).toEqual([]);
-    });
-});

package/packages/focus/src/__test__/focusFirstExisting.spec.tsx

@@ -1,21 +0,0 @@
-import { focusFirstExisting } from '../focusFirstExisting';
-
-describe('focusFirstExisting', () => {
-    const mockFocus1 = jest.fn();
-    const mockFocus2 = jest.fn();
-
-    it('should properly focus references', () => {
-        focusFirstExisting(
-            { current: { focus: mockFocus1 } },
-            { current: { focus: mockFocus2 } },
-        )();
-        expect(mockFocus1).toHaveBeenCalledTimes(1);
-        expect(mockFocus2).toHaveBeenCalledTimes(0);
-        focusFirstExisting(
-            { current: null },
-            { current: { focus: mockFocus2 } },
-        )();
-        expect(mockFocus1).toHaveBeenCalledTimes(1);
-        expect(mockFocus2).toHaveBeenCalledTimes(1);
-    });
-});

package/packages/focus/src/__test__/refocusAfterHashChange.spec.tsx

@@ -1,41 +0,0 @@
-import { createRef } from '@24i/bigscreen-sdk/jsx';
-import { shallow } from '@24i/bigscreen-sdk/jsx/test-utils';
-import { refocusAfterHashChange } from '../refocusAfterHashChange';
-
-jest.useFakeTimers();
-
-describe('refocusAfterHashChange', () => {
-    const wrapper = createRef<HTMLDivElement>();
-    const elementInsideWrapper = createRef<HTMLDivElement>();
-    const elementOutsideWrapper = createRef<HTMLDivElement>();
-    shallow(
-        <div>
-            <div ref={wrapper}>
-                <div ref={elementInsideWrapper} tabIndex={0} />
-            </div>
-            <div ref={elementOutsideWrapper} tabIndex={0} />
-        </div>,
-    );
-
-    afterEach(() => {
-        jest.clearAllMocks();
-    });
-
-    it('should refocus active element inside wrapper', () => {
-        elementInsideWrapper.current!.focus();
-        const activeElement = document.activeElement as HTMLElement;
-        const spyOnFocus = jest.spyOn(activeElement, 'focus');
-        refocusAfterHashChange(wrapper);
-        jest.runAllTimers();
-        expect(spyOnFocus).toHaveBeenCalledTimes(1);
-    });
-
-    it('should not refocus active element outside wrapper', () => {
-        elementOutsideWrapper.current!.focus();
-        const activeElement = document.activeElement as HTMLElement;
-        const spyOnFocus = jest.spyOn(activeElement, 'focus');
-        refocusAfterHashChange(wrapper);
-        jest.runAllTimers();
-        expect(spyOnFocus).toHaveBeenCalledTimes(0);
-    });
-});

package/packages/focus/src/__test__/safeFocus.spec.tsx

@@ -1,41 +0,0 @@
-import { createRef } from '@24i/bigscreen-sdk/jsx';
-import { shallow } from '@24i/bigscreen-sdk/jsx/test-utils';
-import { safeFocus } from '../safeFocus';
-
-describe('safeFocus', () => {
-    const wrapperElement = createRef<HTMLDivElement>();
-    const element1 = createRef<HTMLDivElement>();
-    const element2 = createRef<HTMLDivElement>();
-    const testSafeFocus = safeFocus(wrapperElement);
-
-    shallow(
-        <div>
-            <div ref={wrapperElement} tabIndex={0}>
-                <div ref={element1} tabIndex={0} />
-            </div>
-            <div ref={element2} tabIndex={0} />
-        </div>,
-    );
-
-    it('should focus element when activeElement is inside of the wrapperElement', () => {
-        wrapperElement.current!.focus();
-        testSafeFocus(element1.current!);
-        expect(document.activeElement === element1.current!).toBeTruthy();
-        testSafeFocus(wrapperElement.current!);
-        expect(document.activeElement === wrapperElement.current!).toBeTruthy();
-    });
-
-    it('should focus element when activeElement is body', () => {
-        document.body.focus();
-        testSafeFocus(element1.current!);
-        expect(document.activeElement === element1.current!).toBeTruthy();
-    });
-
-    it('should not focus element when activeElement is outside of the wrapperElement', () => {
-        element2.current!.focus();
-        testSafeFocus(element1.current!);
-        expect(document.activeElement === element1.current!).toBeFalsy();
-        testSafeFocus(wrapperElement.current!);
-        expect(document.activeElement === wrapperElement.current!).toBeFalsy();
-    });
-});

package/packages/mouse-navigation/src/__test__/MouseElementWrapper.spec.tsx

@@ -1,61 +0,0 @@
-import { createRef } from '@24i/bigscreen-sdk/jsx';
-import { getKeyMap } from '@24i/bigscreen-sdk/device';
-import { MountedComponent, shallow, keydown } from '@24i/bigscreen-sdk/jsx/test-utils';
-import { MouseElementWrapper } from '../MouseElementWrapper';
-import { MouseNavigationInterface } from '../MouseNavigationInterface';
-
-describe('MouseElementWrapper', () => {
-    const mPointRef = createRef<HTMLDivElement>();
-    let root: MountedComponent<HTMLDivElement>;
-    let nav: MountedComponent<MouseElementWrapper>;
-
-    beforeEach(() => {
-        jest.clearAllMocks();
-        root = shallow(<div className="mounting-point" ref={mPointRef} />);
-        nav = shallow(
-            <>
-                <MouseElementWrapper
-                    getMountingPoint={() => mPointRef}
-                >
-                    <div className="test-child" />
-                </MouseElementWrapper>
-            </>,
-        );
-    });
-
-    afterEach(() => {
-        nav.unmount();
-        root.unmount();
-    });
-
-    it('should not render child immediately', () => {
-        expect(root.find('.test-child')).toBe(null);
-    });
-
-    it('should handle key event correctly', () => {
-
-        const event = new MouseEvent('mousemove', {});
-        document.dispatchEvent(event);
-
-        expect(root.find('.mounting-point').firstElementChild)
-            .toBe(nav.ref().domRef.current);
-
-        keydown(document, getKeyMap().UP!);
-        expect(root.find('.mounting-point').firstElementChild).toBe(null);
-    });
-
-    it('should handle interface request to hide', () => {
-        const event = new MouseEvent('mousemove', {});
-        document.dispatchEvent(event);
-
-        expect(root.find('.mounting-point').firstElementChild)
-            .toBe(nav.ref().domRef.current);
-
-        MouseNavigationInterface.hide();
-        expect(root.find('.mounting-point').firstElementChild).toBe(null);
-
-        MouseNavigationInterface.show();
-        expect(root.find('.mounting-point').firstElementChild)
-            .toBe(nav.ref().domRef.current);
-    });
-});

package/packages/mouse-navigation/src/__test__/MouseNavigation.spec.tsx

@@ -1,107 +0,0 @@
-import { createRef } from '@24i/bigscreen-sdk/jsx';
-import { getKeyMap } from '@24i/bigscreen-sdk/device';
-import { MountedComponent, shallow, keydown } from '@24i/bigscreen-sdk/jsx/test-utils';
-import { MouseNavigation } from '../MouseNavigation';
-import { MouseNavigationInterface } from '../MouseNavigationInterface';
-
-const forwardMock = jest.fn();
-const backwardMock = jest.fn();
-const showForwardMock = jest.fn(() => true);
-const showBackwardMock = jest.fn(() => true);
-
-describe('MouseNavigation', () => {
-    const mPointRef = createRef<HTMLDivElement>();
-    let nav: MountedComponent<MouseNavigation>;
-
-    beforeEach(() => {
-        nav = shallow(
-            <MouseNavigation
-                getMountingPoint={() => mPointRef}
-                direction="vertical"
-                forward={forwardMock}
-                backward={backwardMock}
-                shouldShowMrcuForward={showForwardMock}
-                shouldShowMrcuBackward={showBackwardMock}
-            >
-                <>
-                    <div className="test-child" />
-                    <div className="mounting-point" ref={mPointRef} />
-                </>
-            </MouseNavigation>,
-        );
-    });
-
-    afterEach(() => {
-        nav.unmount();
-    });
-
-    it('should handle key event correctly', () => {
-
-        const event = new MouseEvent('mousemove', {});
-        document.dispatchEvent(event);
-
-        expect(nav.find('.mounting-point').firstElementChild)
-            .toBe(nav.ref().arrows.current?.domRef.current);
-
-        keydown(document, getKeyMap().UP!);
-
-        expect(nav.find('.mounting-point').firstElementChild).toBe(null);
-    });
-
-    it('should render child', () => {
-        expect(nav.find('.test-child').className).not.toBe(null);
-    });
-
-    it('should return correct mapped direction', () => {
-        expect(nav.ref().mapDirectionToProps('horizontal').horizontal).toBe(true);
-        expect(nav.ref().mapDirectionToProps('vertical').vertical).toBe(true);
-    });
-
-    it('should handle interface request to hide', () => {
-        const event = new MouseEvent('mousemove', {});
-        document.dispatchEvent(event);
-
-        expect(nav.find('.mounting-point').firstElementChild)
-            .toBe(nav.ref().arrows.current?.domRef.current);
-
-        MouseNavigationInterface.hide();
-
-        expect(nav.find('.mounting-point').firstElementChild).toBe(null);
-
-        MouseNavigationInterface.show();
-
-        expect(nav.find('.mounting-point').firstElementChild)
-            .toBe(nav.ref().arrows.current?.domRef.current);
-    });
-
-    it('should propagate forward and backward', () => {
-        nav.ref().handleArrowState = jest.fn();
-        nav.ref().forward();
-        nav.ref().backward();
-
-        expect(forwardMock).toHaveBeenCalledTimes(1);
-        expect(backwardMock).toHaveBeenCalledTimes(1);
-        expect(nav.ref().handleArrowState).toHaveBeenCalledTimes(2);
-    });
-
-    it('should show/hide arrows as reported', () => {
-        nav.ref().arrows = {
-            current: {
-                enableArrow: jest.fn(),
-                disableArrow: jest.fn(),
-            },
-        } as any;
-
-        nav.ref().handleArrowState();
-        expect(nav.ref().arrows.current?.enableArrow).toHaveBeenNthCalledWith(1, 'down');
-        expect(nav.ref().arrows.current?.enableArrow).toHaveBeenNthCalledWith(2, 'up');
-        expect(nav.ref().arrows.current?.enableArrow).toHaveBeenCalledTimes(2);
-
-        showForwardMock.mockImplementationOnce(() => false);
-        showBackwardMock.mockImplementationOnce(() => false);
-        nav.ref().handleArrowState();
-        expect(nav.ref().arrows.current?.disableArrow).toHaveBeenNthCalledWith(1, 'down');
-        expect(nav.ref().arrows.current?.disableArrow).toHaveBeenNthCalledWith(2, 'up');
-        expect(nav.ref().arrows.current?.disableArrow).toHaveBeenCalledTimes(2);
-    });
-});