@24i/bigscreen-sdk 1.0.4 → 1.0.5-4.alpha-2832

package/packages/list/src/Base/Base.tsx

@@ -100,11 +100,13 @@ export class ListBase<T extends Item<U>, U>
     componentDidMount() {
         this.scrollerDom.current!.addEventListener('wheel', this.onWheel);
         this.scroller.current!.wrapRef.current!.addEventListener('keyup', this.onKeyUp);
+        window.document.addEventListener('keyup', this.onGlobalKeyUp, true);
     }
 
     componentWillUnmount() {
         this.scrollerDom.current!.removeEventListener('wheel', this.onWheel);
         this.scroller.current!.wrapRef.current!.removeEventListener('keyup', this.onKeyUp);
+        window.document.removeEventListener('keyup', this.onGlobalKeyUp, true);
     }
 
     onKeyDown = (event: KeyboardEvent) => {
@@ -130,6 +132,9 @@ export class ListBase<T extends Item<U>, U>
     onKeyUp = () => {
         this.stopFastScrolling();
         this.fastFocusingOptimizer.stop();
+    };
+
+    onGlobalKeyUp = () => {
         this.preventBlurCounter = 0;
     };
 
@@ -152,14 +157,6 @@ export class ListBase<T extends Item<U>, U>
         }
     };
 
-    shouldPreventBlur(event: KeyboardEvent) {
-        const { horizontal, preventBlurOnLongPress } = this.props;
-        return (this.preventBlurCounter >= PREVENT_BLUR_ON_LONG_PRESS_KEYDOWNS && (
-            (preventBlurOnLongPress.forward && isForward(event, horizontal))
-            || (preventBlurOnLongPress.backward && isBackward(event, horizontal))
-        ));
-    }
-
     getRefAtIndex(i: number): Reference<T> {
         const ref = this.itemRefs[i];
         if (!ref) {
@@ -201,6 +198,14 @@ export class ListBase<T extends Item<U>, U>
         this.fastScrollingCounter.reset();
     }
 
+    shouldPreventBlur(event: KeyboardEvent) {
+        const { horizontal, preventBlurOnLongPress } = this.props;
+        return (this.preventBlurCounter >= PREVENT_BLUR_ON_LONG_PRESS_KEYDOWNS && (
+            (preventBlurOnLongPress.forward && isForward(event, horizontal))
+            || (preventBlurOnLongPress.backward && isBackward(event, horizontal))
+        ));
+    }
+
     animatedScrollStarted() {
         this.isAnimatedScrollRunning = true;
     }
@@ -360,7 +365,10 @@ export class ListBase<T extends Item<U>, U>
     }
 
     render() {
-        const { horizontal, className, mrcuMountingPoint } = this.props;
+        const {
+            horizontal, className,
+            mrcuMountingPoint, mrcuForward, mrcuBackward, forward, backward,
+        } = this.props;
         return (
             <Scroller
                 className={className}
@@ -375,6 +383,8 @@ export class ListBase<T extends Item<U>, U>
                     ref={this.mrcuRef}
                     getMountingPoint={() => mrcuMountingPoint || this.scroller.current!.wrapRef}
                     {...this.props}
+                    forward={mrcuForward || forward}
+                    backward={mrcuBackward || backward}
                 />
             </Scroller>
         );

package/packages/list/src/Base/interface.ts

@@ -4,11 +4,11 @@ export type MouseNavigationProps = {
     /**
       * Function to call on the press of the right arrow.
       */
-    forward(): boolean,
+    forward(): void,
     /**
       * Function to call on the press of the left arrow.
       */
-    backward(): boolean,
+    backward(): void,
     /**
       * Function which determines whether to show the forward arrow.
       */

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

@@ -127,34 +127,34 @@ export class BasicList<T extends Item<U>, U>
         this.controller.focusCurrentItem(options);
     }
 
-    scrollTo(index: number) {
+    scrollTo(index: number, animate?: boolean) {
         const list = this.base.current!;
         const safeIndex = Math.max(0, Math.min(index, list.data.length - 1));
         if (list.index === safeIndex) return;
         if (list.index < safeIndex) {
-            this.scrollToForward(safeIndex);
+            this.scrollToForward(safeIndex, animate);
         } else {
-            this.scrollToBackward(safeIndex);
+            this.scrollToBackward(safeIndex, animate);
         }
     }
 
-    private scrollToForward(index: number) {
+    private scrollToForward(index: number, animate?: boolean) {
         const { visibleItems } = this.props;
         const list = this.base.current!;
         list.index = index;
         const scrollTarget = list.index - visibleItems + VISIBLE_ITEMS_OFFSET;
         if (scrollTarget > this.controller.scrollIndex) {
-            this.controller.scroll(scrollTarget);
+            this.controller.scroll(scrollTarget, animate);
         }
     }
 
-    private scrollToBackward(index: number) {
+    private scrollToBackward(index: number, animate?: boolean) {
         const { firstScrollStep, scrollStep } = this.props;
         const list = this.base.current!;
         list.index = index;
         const offset = firstScrollStep < scrollStep ? 1 : 0;
         if (list.index - offset < this.controller.scrollIndex) {
-            this.controller.scroll(list.index);
+            this.controller.scroll(list.index, animate);
         }
     }
 

package/packages/list/src/CenteredList/CenteredList.tsx

@@ -90,12 +90,12 @@ export class CenteredList<T extends Item<U>, U>
         this.controller.focusCurrentItem(options);
     }
 
-    scrollTo(index: number) {
+    scrollTo(index: number, animate?: boolean) {
         const list = this.base.current!;
         const safeIndex = Math.max(0, Math.min(index, list.data.length - 1));
         if (list.index === safeIndex) return;
         list.index = safeIndex;
-        this.controller.scroll(list.index);
+        this.controller.scroll(list.index, animate);
     }
 
     render() {

package/packages/list/src/CenteredList/controller.ts

@@ -30,7 +30,6 @@ export class CenteredListController<T> extends UnifiedListController<T, Props<an
         this.scrollListScroller(-this.topOffset);
         if (initialFocusIndex !== 0) {
             base.index = initialFocusIndex!;
-            this.focusCurrentItem();
             this.scroll(base.index, false);
         }
     }

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

@@ -81,14 +81,14 @@ export class EdgeOffsetList<T extends Item<U>, U>
         const list = this.base.current!;
         list.index = Math.max(
             0,
-            Math.min(scrollIndex + visibleItems - VISIBLE_ITEMS_OFFSET, list.data.length - 1),
+            Math.min(scrollIndex + visibleItems - VISIBLE_ITEMS_OFFSET - 1, list.data.length - 1),
         );
         this.forward();
     };
 
     mrcuBackward = () => {
         const list = this.base.current!;
-        list.index = this.controller.scrollIndex;
+        list.index = this.controller.scrollIndex + 1;
         this.backward();
     };
 
@@ -120,18 +120,18 @@ export class EdgeOffsetList<T extends Item<U>, U>
         this.controller.focusCurrentItem(options);
     }
 
-    scrollTo(index: number) {
+    scrollTo(index: number, animate?: boolean) {
         const list = this.base.current!;
         const safeIndex = Math.max(0, Math.min(index, list.data.length - 1));
         if (list.index === safeIndex) return;
         if (list.index < safeIndex) {
-            this.scrollToForward(safeIndex);
+            this.scrollToForward(safeIndex, animate);
         } else {
-            this.scrollToBackward(safeIndex);
+            this.scrollToBackward(safeIndex, animate);
         }
     }
 
-    private scrollToForward(index: number) {
+    private scrollToForward(index: number, animate?: boolean) {
         const { visibleItems, edgeOffset } = this.props;
         const list = this.base.current!;
         list.index = index;
@@ -140,16 +140,16 @@ export class EdgeOffsetList<T extends Item<U>, U>
             : edgeOffset + list.index - list.data.length - 1;
         const scrollTarget = list.index - visibleItems + offset + VISIBLE_ITEMS_OFFSET;
         if (scrollTarget > this.controller.scrollIndex) {
-            this.controller.scroll(scrollTarget);
+            this.controller.scroll(scrollTarget, animate);
         }
     }
 
-    private scrollToBackward(index: number) {
+    private scrollToBackward(index: number, animate?: boolean) {
         const { edgeOffset } = this.props;
         const list = this.base.current!;
         list.index = index;
-        if (list.index < this.controller.scrollIndex) {
-            this.controller.scroll(list.index < edgeOffset ? 0 : list.index - edgeOffset);
+        if (list.index <= this.controller.scrollIndex) {
+            this.controller.scroll(list.index < edgeOffset ? 0 : list.index - edgeOffset, animate);
         }
     }
 

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

@@ -96,12 +96,12 @@ export class FirstOnlyList<T extends Item<U>, U>
         this.controller.focusCurrentItem(options);
     }
 
-    scrollTo(index: number) {
+    scrollTo(index: number, animate?: boolean) {
         const list = this.base.current!;
         const safeIndex = Math.max(0, Math.min(index, list.data.length - 1));
         if (list.index === safeIndex) return;
         list.index = safeIndex;
-        this.controller.scroll(list.index);
+        this.controller.scroll(list.index, animate);
     }
 
     render() {

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

@@ -106,12 +106,12 @@ export class FirstOnlyVariedList<T extends Item<U>, U> extends Component<Props<T
         this.controller.focusCurrentItem(options);
     }
 
-    scrollTo(index: number) {
+    scrollTo(index: number, animate?: boolean) {
         const list = this.base.current!;
         const safeIndex = Math.max(0, Math.min(index, list.data.length - 1));
         if (list.index === safeIndex) return;
         list.index = safeIndex;
-        this.controller.scroll(0);
+        this.controller.scroll(0, animate);
     }
 
     render() {

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

@@ -99,12 +99,12 @@ export class FixedToEndList<T extends Item<U>, U>
         this.controller.focusCurrentItem(options);
     }
 
-    scrollTo(index: number) {
+    scrollTo(index: number, animate?: boolean) {
         const list = this.base.current!;
         const safeIndex = Math.max(0, Math.min(index, list.data.length - 1));
         if (list.index === safeIndex) return;
         list.index = safeIndex;
-        this.controller.scroll(list.index);
+        this.controller.scroll(list.index, animate);
     }
 
     render() {

package/packages/list/src/UnifiedListController/UnifiedListController.ts

@@ -144,12 +144,16 @@ extends SharedProps<any, any> = SharedProps<any, any>>
         if (backward) {
             nextScrollIndex = this.scrollPixelsToIndex(scrollValuePx, backward);
             if (this.lastScrollIndex !== nextScrollIndex) {
-                this.adjustItemsOffsetsBackward(nextScrollIndex);
+                for (let i = this.lastScrollIndex - 1; i >= nextScrollIndex; i--) {
+                    this.adjustItemsOffsetsBackward(i);
+                }
             }
         } else {
             nextScrollIndex = this.scrollPixelsToIndex(scrollValuePx, backward);
             if (this.lastScrollIndex !== nextScrollIndex) {
-                this.adjustItemsOffsetsForward(nextScrollIndex);
+                for (let i = this.lastScrollIndex + 1; i <= nextScrollIndex; i++) {
+                    this.adjustItemsOffsetsForward(i);
+                }
             }
         }
         this.lastScrollIndex = nextScrollIndex;

package/packages/list/src/interface.ts

@@ -12,7 +12,7 @@ export interface List<
     controller: UnifiedListController<U>,
     appendData(data: U[]): void,
     prependData(data: U[]): void,
-    scrollTo(index: number): void,
+    scrollTo(index: number, animate?: boolean): void,
 }
 
 export interface VariedList<
@@ -22,7 +22,7 @@ export interface VariedList<
     controller: UnifiedVariedListController<U>,
     appendData(data: U[]): void,
     prependData(data: U[]): void,
-    scrollTo(index: number): void,
+    scrollTo(index: number, animate?: boolean): void,
 }
 
 export interface ListComponent<

package/packages/logger/src/loggers/ConsoleLogger/ConsoleLogger.ts

@@ -43,7 +43,13 @@ export class ConsoleLogger extends LoggerBase {
         let errorMessage = category ? `[${category.toUpperCase()}] ${message}` : message;
         if (additionalData) {
             if (additionalData.message) errorMessage += ` - ${additionalData.message}`;
-            logFunction(errorMessage, JSON.stringify(additionalData, null, LOG_MESSAGE_SPACE_SIZE));
+            let stringifiedAdditionalData;
+            try {
+                stringifiedAdditionalData = JSON.stringify(
+                    additionalData, null, LOG_MESSAGE_SPACE_SIZE,
+                );
+            } catch {}
+            logFunction(errorMessage, stringifiedAdditionalData);
         } else {
             logFunction(errorMessage);
         }

package/packages/logger/src/loggers/SentryLogger/Sentry.ts

@@ -1 +1,2 @@
 export * as Sentry from '@sentry/browser';
+export { ErrorEvent } from '@sentry/types';

package/packages/logger/src/loggers/SentryLogger/SentryLogger.ts

@@ -3,7 +3,7 @@ import { IStorage, Storage as DefaultStorage } from '@24i/bigscreen-sdk/storage'
 import { LogOptions, LogLevel, SentryLoggerEnvironment, XhrBreadcrumbData } from '../../types';
 import { getFormattedMemoryHeapInfo, getFormattedUsedLocalStorageSize } from '../../utils';
 import { LoggerBase, Config as LoggerBaseConfig } from '../LoggerBase';
-import { Sentry } from './Sentry';
+import { Sentry, ErrorEvent } from './Sentry';
 
 type Config = {
     sentryOptions: Sentry.BrowserOptions;
@@ -46,7 +46,7 @@ export class SentryLogger extends LoggerBase {
         const { beforeSend, ...restOptions } = options;
         Sentry.init({
             ...restOptions,
-            beforeSend: async (event: Sentry.Event, hint: Sentry.EventHint) => {
+            beforeSend: async (event: ErrorEvent, hint: Sentry.EventHint) => {
                 if (this.mute) return null;
                 await this.sendMemoryInfo(event);
                 return beforeSend ? beforeSend(event, hint) : event;
@@ -170,7 +170,9 @@ export class SentryLogger extends LoggerBase {
             }
             if (additionalData) {
                 if (additionalData.message) logMessage += ` - ${additionalData.message}`;
-                scope.setExtra(contextKeys.ADDITIONAL_DATA, JSON.stringify(additionalData));
+                try {
+                    scope.setExtra(contextKeys.ADDITIONAL_DATA, JSON.stringify(additionalData));
+                } catch {}
             }
             Sentry.captureMessage(logMessage, level);
         });

package/packages/menu/src/MenuAndContentContainer/MenuAndContentContainer.tsx

@@ -100,7 +100,7 @@ export class MenuAndContentContainer<T extends string = string>
      * Handles opening with mouse.
      * @param event mouse event
      */
-    onMouseMove = (event: MouseEvent) => {
+    onMouseDown = (event: MouseEvent) => {
         const menu = this.menu.current!;
         if (this.isMenuAvailable() && !menu.isOpen()) {
             menu.open();
@@ -108,6 +108,30 @@ export class MenuAndContentContainer<T extends string = string>
         }
     };
 
+    /**
+     * Handles hover with mouse.
+     * @param event mouse event
+     */
+    onMouseEnter = (event: MouseEvent) => {
+        const menu = this.menu.current!;
+        if (this.isMenuAvailable() && !menu.isOpen() && menu.mrcuEnter) {
+            menu.mrcuEnter();
+            stopEvent(event);
+        }
+    };
+
+    /**
+     * Handles hover end with mouse.
+     * @param event mouse event
+     */
+    onMouseLeave = (event: MouseEvent) => {
+        const menu = this.menu.current!;
+        if (this.isMenuAvailable() && !menu.isOpen() && menu.mrcuLeave) {
+            menu.mrcuLeave();
+            stopEvent(event);
+        }
+    };
+
     /**
      * Handles adding/removing mouse listeners based on whether the mouse is used or not.
      * @param event mouse active event
@@ -137,7 +161,9 @@ export class MenuAndContentContainer<T extends string = string>
         if (!this.listensToMouse) {
             this.listensToMouse = true;
             if (!this.menu.current!.isOpen()) this.mouseTriggerElementDisplayToggler.show();
-            this.mouseTriggerElement.current!.addEventListener('mousemove', this.onMouseMove);
+            this.mouseTriggerElement.current!.addEventListener('mousedown', this.onMouseDown);
+            this.mouseTriggerElement.current!.addEventListener('mouseenter', this.onMouseEnter);
+            this.mouseTriggerElement.current!.addEventListener('mouseleave', this.onMouseLeave);
         }
     }
 
@@ -148,7 +174,9 @@ export class MenuAndContentContainer<T extends string = string>
         if (this.listensToMouse) {
             this.listensToMouse = false;
             if (!this.menu.current!.isOpen()) this.mouseTriggerElementDisplayToggler.hide();
-            this.mouseTriggerElement.current!.removeEventListener('mousemove', this.onMouseMove);
+            this.mouseTriggerElement.current!.removeEventListener('mousedown', this.onMouseDown);
+            this.mouseTriggerElement.current!.removeEventListener('mouseenter', this.onMouseEnter);
+            this.mouseTriggerElement.current!.removeEventListener('mouseleave', this.onMouseLeave);
         }
     }
 

package/packages/menu/src/MenuAndContentContainer/interface.ts

@@ -112,6 +112,14 @@ export interface Menu<
      * Function to close the menu.
      */
     close(): void,
+    /**
+     * Function for "hover" effect on the menu.
+     */
+    mrcuEnter?(): void,
+    /**
+     * Function for ending "hover" effect on the menu.
+     */
+    mrcuLeave?(): void,
     /**
      * Renders new menu items.
      * @param items new items to render

package/packages/modal-service/README.md

@@ -9,7 +9,10 @@ sidebar_label: Modal Service
 A component which helps managing modal windows. Handles rendering and focus management.
 
 ## Props
-- ref - the reference to the modal service instance
+- ```ref``` - the reference to the modal service instance
+- ```className``` - custom class name for modal service div
+- ```isFocusable``` - whether is modal focusable or not
+- ```onCloseLastModal``` - function called when the last modal is closed
 
 ## Provided functionality
 - exports interface which needs to be implemented by the modal component

package/packages/modal-service/src/ModalService.tsx

@@ -1,27 +1,36 @@
-import { Component, createRef, Reference, clearNode } from '@24i/bigscreen-sdk/jsx';
+import { Component, createRef, Reference, clearNode, DeclareProps } from '@24i/bigscreen-sdk/jsx';
 import {
     setActiveElementAsFocusCandidate, focusCandidate, refocusAfterHashChange,
 } from '@24i/bigscreen-sdk/focus';
+import { noop } from '@24i/bigscreen-sdk/utils';
 import { IModal } from './IModal';
 import './ModalService.styles';
 
 type Props = {
     className?: string;
     isFocusable?: boolean;
+    onCloseLastModal?: Function,
 };
 
+type RenderFunction = (ref:Reference) => JSX.Element;
+
 export class ModalService extends Component<Props> {
     private openState = false;
 
     private readonly rootRef = createRef<HTMLDivElement>();
 
+    private readonly modalQueue: RenderFunction[] = [];
+
     modalRef = createRef<any>();
 
     static defaultProps = {
         className: '',
         isFocusable: true,
+        onCloseLastModal: noop,
     };
 
+    declare props: DeclareProps<Props, typeof ModalService.defaultProps>;
+
     componentDidMount() {
         window.addEventListener('hashchange', this.onHashChange);
     }
@@ -37,10 +46,22 @@ export class ModalService extends Component<Props> {
     };
 
     getMountedComponent() {
-        return this.modalRef;
+        return this.modalRef as Reference<IModal>;
+    }
+
+    private enqueueModal(modal: RenderFunction) {
+        this.modalQueue.push(modal);
     }
 
-    open<T extends IModal>(render: (ref: Reference<T>) => JSX.Element) {
+    private dequeueModal() {
+        return this.modalQueue.shift();
+    }
+
+    open<T extends IModal>(render: (ref: Reference<T>) => JSX.Element, queueModal = false) {
+        if (queueModal && this.openState) {
+            this.enqueueModal(render);
+            return;
+        }
         const { isFocusable } = this.props;
         this.openState = true;
         this.clearMount(
@@ -53,13 +74,16 @@ export class ModalService extends Component<Props> {
         }
     }
 
-    close() {
-        const { isFocusable } = this.props;
+    close(ignoreQueue = false) {
+        const { isFocusable, onCloseLastModal } = this.props;
         this.openState = false;
         clearNode(this.rootRef);
         if (isFocusable) {
             focusCandidate();
         }
+        const modalFromQueue = this.dequeueModal();
+        if (modalFromQueue && !ignoreQueue) this.open(modalFromQueue);
+        if (!this.modalQueue.length) onCloseLastModal();
     }
 
     isOpen() {

package/packages/perf-utils/README.md

@@ -5,123 +5,4 @@ hide_title: true
 sidebar_label: Performance Utils
 ---
 
-# Performance Utils
-Set of utilities that should increase a performance if they are used instead of a native way, mainly on older devices (e.g. Entone/Kamai set-top-boxes).
-
-> **Please check the limitations of each performance utility You want to use in a code.**
-
-## Available perf utils
-- **[Array](#array-perf-utils)**
-    - [filter](#filter)
-    - [forEach](#foreach)
-    - [includes](#includes)
-    - [includesNaN](#includesnan)
-    - [map](#map)
-  
-## Array perf utils
-
-> In general, each Array utility which requires a callback will iterate over all array items, even if array index hasn't been initialized yet (to understand the issue, see [An adventure in sparse arrays](https://remysharp.com/2018/06/26/an-adventure-in-sparse-arrays)).
-
-### filter()
-> The filter() method creates a new array with all elements that pass the test implemented by the provided function.  
-
-For more info, please see [native **filter** method](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter).
-
-#### Limitations against native implementation
-- **`callback` is invoked for all indexes of the array** (not only for indexes with assigned values like [native filter implementation](http://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/filter#Description)).
-- **Doesn't coerce returned value from a callback to `true` or `false`**, the callback has to return a boolean value directly.
-- Doesn't accept the `scope` as last argument.
-
-#### Usage
-```javascript
-import { filter } from '@24i/bigscreen-sdk/perf-utils/array';
-
-const array = ['spray', 'limit', 'elite', 'exuberant', 'destruction'];
-//const result = array.filter(word => word.length > 6); // slower native solution
-const result = filter(array, word => word.length > 6);  // faster
-
-console.log(result);
-// expected output: Array ["exuberant", "destruction"]
-```
-
-### forEach()
-> The forEach() method executes a provided function once for each array element.
-
-For more info, please see [native **forEach** method](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach).
-
-#### Limitations against native implementation
-- **`callback` is invoked for all indexes of the array** (not only for indexes with assigned values like [native forEach implementation](http://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach#Description)).
-- Doesn't accept the `scope` as last argument.
-
-#### Usage
-```javascript
-import { forEach } from '@24i/bigscreen-sdk/perf-utils/array';
-
-const array = ['a', 'b', 'c'];
-// array.forEach(item => console.log(item)); // slower native solution
-forEach(array, item => console.log(item));   // faster
-
-// expected output: "a"
-// expected output: "b"
-// expected output: "c"
-```
-
-### includes()
-> The includes() method determines whether an array includes a certain value among its entries, returning true or false as appropriate.
-
-For more info, please see [native **includes** method](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/includes).
-
-#### Limitations against native implementation
-- **Doesn't work for searching NaN value!** For that purpose, please use [includesNaN()](#includesnan).
-- Doesn't support negative indexes for `fromIndex` param - the entire array will be processed.
-
-#### Usage
-```javascript
-import { includes } from '@24i/bigscreen-sdk/perf-utils/array';
-
-const array = ['item0', 'item1', 'item2'];
-
-//console.log(array.includes('item1')); // slower native solution
-console.log(includes(array, 'item1'));  // faster
-// expected output: true
-
-//console.log(array.includes('item1')); // slower native solution
-console.log(includes(array, 'item1', 2));  // faster
-// expected output: false
-```
-
-### includesNaN()
-> The includesNaN() method determines whether an array includes NaN value among its entries, returning true or false as appropriate.
-
-#### Usage
-```javascript
-import { includesNaN } from '@24i/bigscreen-sdk/perf-utils/array';
-
-console.log(includesNaN([0, NaN, 1]));
-// expected output: true
-
-console.log(includesNaN([0, NaN, 1], 2));
-// expected output: false
-```
-
-### map()
-> The map() method creates a new array populated with the results of calling a provided function on every element in the calling array.
-
-For more info, please see [native **map** method](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map).
-
-#### Limitations against native implementation
-- **`callback` is invoked for all indexes of the array** (not only for indexes with assigned values like [native map implementation](http://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/map#Description)).
-- Doesn't accept the `scope` as last argument.
-
-#### Usage
-```javascript
-import { map } from '@24i/bigscreen-sdk/perf-utils/array';
-
-const array = [1, 4, 9, 16];
-
-// const mappedArray = array.map(x => x * 2); // slower native solution
-const mappedArray = map(array, x => x * 2);   // faster
-
-console.log(mappedArray);
-// expected output: Array [2, 8, 18, 32]
-```
+https://github.com/24i/appstage-shared-packages/blob/main/packages/perf-utils/README.md