@24i/bigscreen-sdk 1.0.0 → 1.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@24i/bigscreen-sdk",
-    "version": "1.0.0",
+    "version": "1.0.1",
     "description": "SmartApps BIGscreen SDK monorepo",
     "main": "index.js",
     "scripts": {
@@ -38,8 +38,8 @@
     "homepage": "https://github.com/24i/smartapps-bigscreen-sdk#readme",
     "dependencies": {
         "@24i/player-base": "6.10.0",
-        "@24i/smartapps-datalayer": "2.3.0-beta.1",
-        "@sentry/browser": "^7.6.0",
+        "@24i/smartapps-datalayer": "2.3.2",
+        "@sentry/browser": "^7.8.0",
         "@types/prop-types": "^15.7.5",
         "@types/scheduler": "^0.16.1",
         "csstype": "^3.1.0",
@@ -50,13 +50,13 @@
         "@24i/bigscreen-sdk": "file:.",
         "@24i/eslint-config-smartapps-bigscreen-linters": "file:./libs/linters",
         "@24i/smartapps-bigscreen-changelog-generator": "0.17.0",
-        "@babel/core": "^7.18.6",
-        "@babel/preset-env": "^7.18.6",
+        "@babel/core": "^7.18.9",
+        "@babel/preset-env": "^7.18.9",
         "@types/fs-extra": "^9.0.13",
         "@types/inquirer": "^8.2.1",
-        "@types/jest": "^28.1.5",
+        "@types/jest": "^28.1.6",
         "@types/minimist": "^1.2.2",
-        "@types/node": "^17.0.43",
+        "@types/node": "^18.6.3",
         "@types/react": "^18.0.15",
         "babel-jest": "^28.1.2",
         "chalk": "^4.1.2",
@@ -65,15 +65,15 @@
         "fs-extra": "^10.1.0",
         "full-icu": "^1.4.0",
         "identity-obj-proxy": "^3.0.0",
-        "inquirer": "^9.0.0",
+        "inquirer": "^9.0.2",
         "jest": "^28.1.2",
         "jest-canvas-mock": "^2.4.0",
         "jest-environment-jsdom": "^28.1.2",
         "minimist": "^1.2.6",
         "patch-package": "^6.2.1",
-        "sass": "^1.53.0",
+        "sass": "^1.54.0",
         "sass-true": "^6.1.0",
-        "ts-jest": "^28.0.4",
+        "ts-jest": "^28.0.7",
         "ts-node": "^10.8.2",
         "tsconfig-paths-jest": "0.0.1",
         "typescript": "^4.7.2"
@@ -111,6 +111,7 @@
         "./driver-kreatv": "./packages/driver-kreatv/src/index.ts",
         "./driver-saphi": "./packages/driver-saphi/src/index.ts",
         "./driver-tizen": "./packages/driver-tizen/src/index.ts",
+        "./driver-vidaa": "./packages/driver-vidaa/src/index.ts",
         "./driver-webos/scripts/template": "./packages/driver-webos/scripts/template.ts",
         "./driver-webos/scripts/exportWebOSTVjs": "./packages/driver-webos/scripts/exportWebOSTVjs.ts",
         "./driver-webos": "./packages/driver-webos/src/index.ts",

package/packages/developer-tools/src/EnvironmentSelection/styles/EnvironmentSelection.scss

@@ -111,7 +111,7 @@
         }
 
         .leading-ellipses-list-item {
-            height: fit-content;
+            height: auto;
         }
     }
 }

package/packages/device/src/driver/index.vidaa.tv.ts

@@ -0,0 +1 @@
+export { DeviceVidaa as Device } from '@24i/bigscreen-sdk/driver-vidaa';

package/packages/device/src/resolver/resolver.ts

@@ -5,6 +5,7 @@ import { DeviceHbbTV } from '@24i/bigscreen-sdk/driver-hbbtv';
 import { DeviceKreaTV } from '@24i/bigscreen-sdk/driver-kreatv';
 import { DeviceSaphi } from '@24i/bigscreen-sdk/driver-saphi';
 import { DeviceTizen } from '@24i/bigscreen-sdk/driver-tizen';
+import { DeviceVidaa } from '@24i/bigscreen-sdk/driver-vidaa';
 import { DeviceWebos } from '@24i/bigscreen-sdk/driver-webos';
 import { DeviceXbox } from '@24i/bigscreen-sdk/driver-xbox';
 
@@ -30,6 +31,10 @@ const getDevice = () => {
         info('Saphi');
         return new DeviceSaphi();
     }
+    if (userAgent.match(/Hisense/)) {
+        info('VIDAA');
+        return new DeviceVidaa();
+    }
     if (userAgent.match(/Ekioh/)) {
         info('KreaTV');
         return new DeviceKreaTV();

package/packages/driver-vidaa/src/DeviceVidaa.ts

@@ -0,0 +1,134 @@
+import {
+    DeviceBase,
+    ConnectionType,
+    ScreenSaverStatus,
+    VolumeRange,
+} from '@24i/bigscreen-sdk/driver-base';
+import { getPlatformInfo } from './formatUserAgent';
+import { HisenseVidaaApi } from './types';
+import { getKeyMap } from './keymap';
+
+declare global {
+    interface Window extends HisenseVidaaApi {}
+}
+
+export class DeviceVidaa extends DeviceBase {
+    keyMap = getKeyMap();
+
+    platformInfo = getPlatformInfo(navigator.userAgent);
+
+    async initDevice(): Promise<void> {
+        this.initNetworkChangeListener();
+    }
+
+    initNetworkChangeListener() {
+        window.addEventListener('online', () => {
+            this.triggerEvent('networkchange', { isConnected: true });
+        });
+        window.addEventListener('offline', () => {
+            this.triggerEvent('networkchange', { isConnected: false });
+        });
+    }
+
+    reboot(): void {
+        let rootPath = '';
+        const splitUrl = window.location.href.split('#');
+        if (splitUrl.length > 1) rootPath = splitUrl[0];
+        window.location.href = rootPath;
+    }
+
+    exit(): void {
+        window.close();
+    }
+
+    async getManufacturerName(): Promise<string> {
+        return 'Hisense';
+    }
+
+    async getPlatformName(): Promise<string> {
+        return 'VIDAA';
+    }
+
+    async getPlatformVersion(): Promise<string> {
+        // platform version of Hisense VIDAA is defined on TV 2020 or later
+        return this.platformInfo.platformVersion || '';
+    }
+
+    async getDeviceName(): Promise<string> {
+        return `Hisense VIDAA ${await this.getModelName()}`.trim();
+    }
+
+    async getModelName(): Promise<string> {
+        return window.Hisense_GetModelName() || '';
+    }
+
+    async getFirmware(): Promise<string> {
+        return window.Hisense_GetFirmWareVersion() || '';
+    }
+
+    async is4KSupported(): Promise<boolean> {
+        return window.Hisense_Get4KSupportState() || false;
+    }
+
+    async is8KSupported(): Promise<boolean> {
+        return false;
+    }
+
+    async getUuid(): Promise<string> {
+        return window.Hisense_GetDeviceID() || '';
+    }
+
+    async getVolume(): Promise<number> {
+        return VolumeRange.UNSUPPORTED;
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async setVolume(volumePercentage: number): Promise<void> {
+        // not supported on Hisense VIDAA platform
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async mute(mute: boolean): Promise<void> {
+        // not supported on Hisense VIDAA platform
+    }
+
+    async isMute(): Promise<boolean> {
+        // not supported on Hisense VIDAA platform
+        return false;
+    }
+
+    async getScreenSaver(): Promise<ScreenSaverStatus> {
+        // not supported on Hisense VIDAA platform
+        return { enabled: false };
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async setScreenSaver(status: ScreenSaverStatus): Promise<void> {
+        // not supported on Hisense VIDAA platform
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async setUserAgent(userAgent: string): Promise<boolean> {
+        // not supported on Hisense VIDAA platform
+        return false;
+    }
+
+    async isNetworkConnected(): Promise<boolean> {
+        return window.navigator.onLine;
+    }
+
+    async getConnectionType(): Promise<ConnectionType> {
+        // not supported on Hisense VIDAA platform
+        return 'unknown';
+    }
+
+    async getLocalIP(): Promise<string> {
+        // not supported on Hisense VIDAA platform
+        return '';
+    }
+
+    async getMacAddress(): Promise<string> {
+        // not supported on Hisense VIDAA platform
+        return '';
+    }
+}

package/packages/driver-vidaa/src/__mocks__/vidaa.ts

@@ -0,0 +1,20 @@
+import { HisenseVidaaApi, HisenseVidaaKeys } from '../types';
+
+export const mockHisenseVidaaApi: HisenseVidaaApi = {
+    Hisense_GetBrand: () => 'hisense',
+    Hisense_GetModelName: () => '5U61FQEVS',
+    Hisense_GetFirmWareVersion: () => 'V0000.01.00Q.L0301',
+    Hisense_Get4KSupportState: () => true,
+    Hisense_GetDeviceID: () => '861003009000001000000641123456789012',
+};
+
+// Key constants are set to random number values
+export const mockHisenseVidaaKeys = {
+    VK_LEFT: 0,
+    VK_RIGHT: 1,
+    VK_UP: 2,
+    VK_DOWN: 3,
+    VK_ENTER: 4,
+    VK_BACK_SPACE: 5,
+    // the rest of key constants is not needed for testing
+} as HisenseVidaaKeys;

package/packages/driver-vidaa/src/formatUserAgent.ts

@@ -0,0 +1,16 @@
+/**
+ * Parses platform info of VIDAA from user agent string.
+ * NOTE: Platform info of VIDAA is available in user agent of TVs 2020 or later.
+ *
+ * @param userAgent User agent string
+ * @returns object with platform info like platform name and platform version.
+ * If values are not not available, values of keys are set to undefined.
+ * Ex. for VIDAA platform string like "VIDAA/4.0" in user agent string , it returns
+ * object { platformName: "VIDAA", platformVersion: "4.0" }
+ */
+export const getPlatformInfo = (userAgent: string) => {
+    const [
+        , platformName, platformVersion,
+    ] = userAgent.match(/(VIDAA)\/([\d.]+)/) || [] as Array<undefined>;
+    return { platformName, platformVersion };
+};

package/packages/driver-vidaa/src/index.ts

@@ -0,0 +1 @@
+export { DeviceVidaa } from './DeviceVidaa';

package/packages/driver-vidaa/src/keymap.ts

@@ -0,0 +1,54 @@
+/* eslint-disable no-magic-numbers */
+import { KeyMap } from '@24i/bigscreen-sdk/driver-base';
+import { HisenseVidaaKeys } from './types';
+
+declare const window: Window & HisenseVidaaKeys;
+
+export const getKeyMap = () => {
+    KeyMap.overrideValues({
+        LEFT: { keyCode: window.VK_LEFT },
+        RIGHT: { keyCode: window.VK_RIGHT },
+        UP: { keyCode: window.VK_UP },
+        DOWN: { keyCode: window.VK_DOWN },
+        ENTER: { keyCode: window.VK_ENTER },
+        BACK: { keyCode: window.VK_BACK_SPACE },
+
+        RED: { keyCode: window.VK_RED },
+        GREEN: { keyCode: window.VK_GREEN },
+        YELLOW: { keyCode: window.VK_YELLOW },
+        BLUE: { keyCode: window.VK_BLUE },
+
+        PLAY: { keyCode: window.VK_PLAY },
+        PAUSE: { keyCode: window.VK_PAUSE },
+        PLAYPAUSE: { keyCode: window.VK_PLAY_PAUSE },
+        STOP: { keyCode: window.VK_STOP },
+        FF: { keyCode: window.VK_FAST_FWD },
+        REW: { keyCode: window.VK_REWIND },
+
+        NUM_0: { keyCode: window.VK_0 },
+        NUM_1: { keyCode: window.VK_1 },
+        NUM_2: { keyCode: window.VK_2 },
+        NUM_3: { keyCode: window.VK_3 },
+        NUM_4: { keyCode: window.VK_4 },
+        NUM_5: { keyCode: window.VK_5 },
+        NUM_6: { keyCode: window.VK_6 },
+        NUM_7: { keyCode: window.VK_7 },
+        NUM_8: { keyCode: window.VK_8 },
+        NUM_9: { keyCode: window.VK_9 },
+        KP_0: { keyCode: window.VK_NUMPAD0 },
+        KP_1: { keyCode: window.VK_NUMPAD1 },
+        KP_2: { keyCode: window.VK_NUMPAD2 },
+        KP_3: { keyCode: window.VK_NUMPAD3 },
+        KP_4: { keyCode: window.VK_NUMPAD4 },
+        KP_5: { keyCode: window.VK_NUMPAD5 },
+        KP_6: { keyCode: window.VK_NUMPAD6 },
+        KP_7: { keyCode: window.VK_NUMPAD7 },
+        KP_8: { keyCode: window.VK_NUMPAD8 },
+        KP_9: { keyCode: window.VK_NUMPAD9 },
+
+        CHANNEL_UP: { keyCode: window.VK_CHANNEL_UP || 427 },
+        CHANNEL_DOWN: { keyCode: window.VK_CHANNEL_DOWN || 428 },
+        INFO: { keyCode: window.VK_INFO },
+    });
+    return KeyMap.generateKeyCodeKeyMap();
+};

package/packages/driver-vidaa/src/types.ts

@@ -0,0 +1,82 @@
+export interface HisenseVidaaApi {
+    /**
+     * This interface will retrieve Hisense Unique ID for the device.
+     * @return a 32bytes string that represents the device id.
+     * Example: 861003009000001000000641123456789012
+     */
+    Hisense_GetDeviceID: () => string,
+    /**
+     * This interface will retrieve the firmware version for the device.
+     * @return a string that represents the firmware version.
+     * Example: V00.01.00a.F0116
+     */
+    Hisense_GetFirmWareVersion: () => string,
+    /**
+     * This will retrieve the 4K support status for the device.
+     * @return true if 4K is supported otherwise returns false.
+     */
+    Hisense_Get4KSupportState: () => boolean,
+    /**
+     * This will retrieve the TV brand for the device.
+     * @return a brand full name string that represents the TV brand.
+     * Example: hisense, sharp
+     */
+    Hisense_GetBrand: () => string,
+    /**
+     * This will retrieve the TV model name (hardware version) for the device.
+     * @return a string that represents the TV model name.
+     */
+    Hisense_GetModelName: () => string,
+}
+
+export type HisenseVidaaKeys = {
+    readonly VK_UP: number,
+    readonly VK_RIGHT: number,
+    readonly VK_DOWN: number,
+    readonly VK_LEFT: number,
+    readonly VK_ENTER: number,
+    readonly VK_BACK_SPACE: number,
+
+    readonly VK_BLUE: number,
+    readonly VK_RED: number,
+    readonly VK_GREEN: number,
+    readonly VK_YELLOW: number,
+
+    readonly VK_MENU: number,
+
+    readonly VK_0: number,
+    readonly VK_1: number,
+    readonly VK_2: number,
+    readonly VK_3: number,
+    readonly VK_4: number,
+    readonly VK_5: number,
+    readonly VK_6: number,
+    readonly VK_7: number,
+    readonly VK_8: number,
+    readonly VK_9: number,
+    // keys VK_NUMPAD{X} are not introduced in Hisense VIDAA spec but exist in global scope
+    readonly VK_NUMPAD0: number,
+    readonly VK_NUMPAD1: number,
+    readonly VK_NUMPAD2: number,
+    readonly VK_NUMPAD3: number,
+    readonly VK_NUMPAD4: number,
+    readonly VK_NUMPAD5: number,
+    readonly VK_NUMPAD6: number,
+    readonly VK_NUMPAD7: number,
+    readonly VK_NUMPAD8: number,
+    readonly VK_NUMPAD9: number,
+
+    readonly VK_PLAY: number,
+    readonly VK_PAUSE: number,
+    readonly VK_PLAY_PAUSE: number,
+    readonly VK_STOP: number,
+    readonly VK_TRACK_NEXT: number,
+    readonly VK_TRACK_PREV: number,
+    readonly VK_FAST_FWD: number,
+    readonly VK_REWIND: number,
+    readonly VK_SUBTITLE: number,
+    readonly VK_INFO: number,
+    // VK_CHANNEL_{UP/DOWN} not introduced in Hisense VIDAA spec but exists in global scope
+    readonly VK_CHANNEL_UP: number,
+    readonly VK_CHANNEL_DOWN: number,
+};

package/packages/list/src/BasicList/BasicList.tsx

@@ -103,7 +103,10 @@ export class BasicList<T extends Item<U>, U>
 
     shouldShowMrcuForward = () => {
         const { visibleItems, data } = this.props;
-        return this.controller.scrollIndex < data.length - 1 - visibleItems + VISIBLE_ITEMS_OFFSET;
+        return (
+            this.controller.scrollIndex < data.length - 1 - visibleItems + VISIBLE_ITEMS_OFFSET
+            && data.length > visibleItems - 2
+        );
     };
 
     shouldShowMrcuBackward = () => this.controller.scrollIndex > 0;

package/packages/list/src/EdgeOffsetList/EdgeOffsetList.tsx

@@ -93,11 +93,12 @@ export class EdgeOffsetList<T extends Item<U>, U>
     };
 
     shouldShowMrcuForward = () => {
-        const { edgeOffset, visibleItems } = this.props;
+        const { data, edgeOffset, visibleItems } = this.props;
         const { scrollIndex } = this.controller;
-        const list = this.base.current!;
+
         return (
-            scrollIndex < list.data.length - visibleItems + VISIBLE_ITEMS_OFFSET - edgeOffset
+            scrollIndex < data.length - visibleItems + VISIBLE_ITEMS_OFFSET - edgeOffset
+            && data.length > visibleItems - 2
         );
     };
 

package/packages/list/src/FirstOnlyList/FirstOnlyList.tsx

@@ -70,9 +70,9 @@ export class FirstOnlyList<T extends Item<U>, U>
     };
 
     shouldShowMrcuForward = () => {
-        const { data } = this.props;
+        const { data, visibleItems } = this.props;
         const list = this.base.current!;
-        return list.index < data.length - 1;
+        return list.index < data.length - 1 && data.length > visibleItems - 2;
     };
 
     shouldShowMrcuBackward = () => {

package/packages/list/src/FirstOnlyVariedList/FirstOnlyVariedList.tsx

@@ -80,9 +80,9 @@ export class FirstOnlyVariedList<T extends Item<U>, U> extends Component<Props<T
     };
 
     shouldShowMrcuForward = () => {
-        const { data } = this.props;
+        const { data, visibleItems } = this.props;
         const list = this.base.current!;
-        return list.index < data.length - 1;
+        return list.index < data.length - 1 && data.length > visibleItems - 2;
     };
 
     shouldShowMrcuBackward = () => {

package/packages/list/src/FixedToEndList/FixedToEndList.tsx

@@ -76,9 +76,9 @@ export class FixedToEndList<T extends Item<U>, U>
     };
 
     shouldShowMrcuForward = () => {
-        const { visibleItems } = this.props;
+        const { data, visibleItems } = this.props;
         const list = this.base.current!;
-        return list.index <= list.data.length - visibleItems + 1;
+        return list.index <= data.length - visibleItems + 1 && data.length > visibleItems - 2;
     };
 
     shouldShowMrcuBackward = () => this.controller.scrollIndex > 0;

package/packages/logger/README.md

@@ -55,7 +55,7 @@ the output would be:
 ## Logger Manager
 
 Logger Manager is used for managing loggers. We are able to add individual loggers to the Logger Manager and perform various operations on them.
-All loggers that we want to add to the Logger Manager should inherit from the [LoggerBase](./src/loggers/LoggerBase/README.md) abstract class.
+All loggers that we want to add to the Logger Manager should inherit from the [LoggerBase](./src/loggers/LoggerBase/README) abstract class.
 
 ### Methods
 

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/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);
-    });
-});