@24i/bigscreen-sdk 1.0.40-alpha.2687 → 1.0.40

package/packages/grid/src/UnifiedGridController/index.ts

@@ -1,2 +1,2 @@
-export { UnifiedGridController } from './UnifiedGridController';
-export type { ControllableGrid } from './interface';
+export { UnifiedGridController } from './UnifiedGridController';
+export type { ControllableGrid } from './interface';

package/packages/grid/src/UnifiedGridController/interface.ts

@@ -1,92 +1,92 @@
-import { Reference } from '@24i/bigscreen-sdk/jsx';
-import { GridBase } from '../Base';
-import { AnimationConfiguration, SharedProps } from '../types';
-
-export type GridConfig = {
-    defaultAnimation: AnimationConfiguration,
-    animate: boolean,
-};
-
-export interface ControllableGrid {
-    /**
-     * The grid Base component
-     */
-    base: Reference<GridBase<any, any>>,
-    /**
-     * Props of the grid
-     */
-    props: SharedProps<any, any>,
-    /**
-     * Method for scrolling forward, unique for every list
-     */
-    scrollForward: () => void;
-    /**
-     * Method for scrolling backward, unique for every list
-     */
-    scrollBackward: () => void;
-}
-
-export interface UnifiedGridController<T> {
-    /**
-     * Returns the maximum index for group (in data)
-     */
-    getMaxGroupIndex: () => number,
-    /**
-     * Focuses current item
-     */
-    focusCurrentItem: () => void,
-    /**
-     * Focuses given index
-     * @param dataIndex index to focus
-     * @param animate flag whether the scroll to that item should be animated (defaults to false)
-     */
-    focusToIndex: (dataIndex: number, animate?: boolean) => void,
-    /**
-     * Scrolls to the given scroll index
-     * @param newScrollIndex index to scroll to
-     * @param animate flag whether the scroll should be animated (defaults to grid.props.animate)
-     */
-    scroll: (newScrollIndex: number, animate?: boolean) => void,
-    /**
-     * Scrolls the grid Scroller to the given px
-     * @param scrollValuePx pixel value to scroll to
-     */
-    scrollGridScroller: (scrollValuePx: number) => void,
-    /**
-     * Converts item (data) index to scroll index
-     */
-    itemIndexToScrollIndex: (dataIndex: number) => number,
-    /**
-     * Function to return the number of pixels to scroll to given a scrollIndex value
-     * @param index the scrollIndex for which to calculate the pixels distance
-     * @returns the number of pixels for scroll value
-     */
-    scrollIndexToPixels: (index: number) => number,
-    /**
-     * Function to scrollIndex value from scroll position in pixels
-     * @param pixels scroll position in pixels (expect positive number)
-     * @param backward boolean param for determine scroll direction (true is backward)
-     * @returns the number of pixels for scroll value
-     */
-    scrollPixelsToIndex: (scrollValuePx: number, backward: boolean) => number,
-    /**
-     * Takes care of group offsets and rotation during scroll forward
-     * @param scrollIndex currently targeted scrollIndex
-     */
-    adjustGroupsOffsetsForward: (scrollIndex: number) => void,
-    /**
-     * Takes care of group offsets and rotation during scroll backward
-     * @param scrollIndex currently targeted scrollIndex
-     */
-    adjustGroupsOffsetsBackward: (scrollIndex: number) => void,
-    /**
-     * Appends data at the end of data array
-     * @param data data to append
-     */
-    appendData: (data: T[]) => void,
-    /**
-     * Prepends data at the start of data array
-     * @param data data to prepend
-     */
-    prependData: (data: T[]) => void,
-}
+import { Reference } from '@24i/bigscreen-sdk/jsx';
+import { GridBase } from '../Base';
+import { AnimationConfiguration, SharedProps } from '../types';
+
+export type GridConfig = {
+    defaultAnimation: AnimationConfiguration,
+    animate: boolean,
+};
+
+export interface ControllableGrid {
+    /**
+     * The grid Base component
+     */
+    base: Reference<GridBase<any, any>>,
+    /**
+     * Props of the grid
+     */
+    props: SharedProps<any, any>,
+    /**
+     * Method for scrolling forward, unique for every list
+     */
+    scrollForward: () => void;
+    /**
+     * Method for scrolling backward, unique for every list
+     */
+    scrollBackward: () => void;
+}
+
+export interface UnifiedGridController<T> {
+    /**
+     * Returns the maximum index for group (in data)
+     */
+    getMaxGroupIndex: () => number,
+    /**
+     * Focuses current item
+     */
+    focusCurrentItem: () => void,
+    /**
+     * Focuses given index
+     * @param dataIndex index to focus
+     * @param animate flag whether the scroll to that item should be animated (defaults to false)
+     */
+    focusToIndex: (dataIndex: number, animate?: boolean) => void,
+    /**
+     * Scrolls to the given scroll index
+     * @param newScrollIndex index to scroll to
+     * @param animate flag whether the scroll should be animated (defaults to grid.props.animate)
+     */
+    scroll: (newScrollIndex: number, animate?: boolean) => void,
+    /**
+     * Scrolls the grid Scroller to the given px
+     * @param scrollValuePx pixel value to scroll to
+     */
+    scrollGridScroller: (scrollValuePx: number) => void,
+    /**
+     * Converts item (data) index to scroll index
+     */
+    itemIndexToScrollIndex: (dataIndex: number) => number,
+    /**
+     * Function to return the number of pixels to scroll to given a scrollIndex value
+     * @param index the scrollIndex for which to calculate the pixels distance
+     * @returns the number of pixels for scroll value
+     */
+    scrollIndexToPixels: (index: number) => number,
+    /**
+     * Function to scrollIndex value from scroll position in pixels
+     * @param pixels scroll position in pixels (expect positive number)
+     * @param backward boolean param for determine scroll direction (true is backward)
+     * @returns the number of pixels for scroll value
+     */
+    scrollPixelsToIndex: (scrollValuePx: number, backward: boolean) => number,
+    /**
+     * Takes care of group offsets and rotation during scroll forward
+     * @param scrollIndex currently targeted scrollIndex
+     */
+    adjustGroupsOffsetsForward: (scrollIndex: number) => void,
+    /**
+     * Takes care of group offsets and rotation during scroll backward
+     * @param scrollIndex currently targeted scrollIndex
+     */
+    adjustGroupsOffsetsBackward: (scrollIndex: number) => void,
+    /**
+     * Appends data at the end of data array
+     * @param data data to append
+     */
+    appendData: (data: T[]) => void,
+    /**
+     * Prepends data at the start of data array
+     * @param data data to prepend
+     */
+    prependData: (data: T[]) => void,
+}

package/packages/grid/src/animate.animated.ts

@@ -1 +1 @@
-export const animate = true;
+export const animate = true;

package/packages/grid/src/animate.ts

@@ -1 +1 @@
-export const animate = false;
+export const animate = false;

package/packages/grid/src/interface.ts

@@ -1,30 +1,30 @@
-import { Component, Reference } from '@24i/bigscreen-sdk/jsx';
-import { IFocusable } from '@24i/bigscreen-sdk/focus';
-import { UnifiedGridController } from './UnifiedGridController/UnifiedGridController';
-import { SharedProps, Item } from './types';
-import { GridBase } from './Base';
-
-export interface Grid<
-    T extends Item<U>, U, V extends SharedProps<T, U> = SharedProps<T, U>,
-> extends IFocusable, Component<V> {
-    base: Reference<GridBase<T, U>>,
-    controller: UnifiedGridController<U>;
-    appendData(data: U[]): void,
-    prependData(data: U[]): void,
-    focusToIndex(dataIndex: number, animated?: boolean): void,
-}
-
-export interface GridComponent<
-    T extends Item<U>, U, V extends SharedProps<T, U> = SharedProps<T, U>,
-> {
-    new (props: V): Grid<T, U, V>,
-}
-
-export interface ItemComponent<T> {
-    new (props: any): Item<T>,
-}
-
-export {
-    SharedProps as Props,
-    Item,
-};
+import { Component, Reference } from '@24i/bigscreen-sdk/jsx';
+import { IFocusable } from '@24i/bigscreen-sdk/focus';
+import { UnifiedGridController } from './UnifiedGridController/UnifiedGridController';
+import { SharedProps, Item } from './types';
+import { GridBase } from './Base';
+
+export interface Grid<
+    T extends Item<U>, U, V extends SharedProps<T, U> = SharedProps<T, U>,
+> extends IFocusable, Component<V> {
+    base: Reference<GridBase<T, U>>,
+    controller: UnifiedGridController<U>;
+    appendData(data: U[]): void,
+    prependData(data: U[]): void,
+    focusToIndex(dataIndex: number, animated?: boolean): void,
+}
+
+export interface GridComponent<
+    T extends Item<U>, U, V extends SharedProps<T, U> = SharedProps<T, U>,
+> {
+    new (props: V): Grid<T, U, V>,
+}
+
+export interface ItemComponent<T> {
+    new (props: any): Item<T>,
+}
+
+export {
+    SharedProps as Props,
+    Item,
+};

package/packages/grid/src/mocks/index.tsx

@@ -1,41 +1,41 @@
-import { createRef, Component } from '@24i/bigscreen-sdk/jsx';
-
-export type MockData = { id: number };
-
-export const getMockData = (amount: number): MockData[] => {
-    const data = [];
-    for (let i = 0; i < amount; i++) {
-        data.push({ id: i });
-    }
-    return data;
-};
-
-type Props = {
-    className: string,
-    id: number,
-};
-
-export class MockItem extends Component<Props> {
-    div = createRef<HTMLDivElement>();
-
-    show = jest.fn();
-
-    hide = jest.fn();
-
-    focus(options?: FocusOptions) {
-        this.div.current!.focus(options);
-    }
-
-    updateData() {}
-
-    hasDom(dom: HTMLElement) {
-        return this.div.current === dom;
-    }
-
-    render() {
-        const { id, className } = this.props;
-        return (
-            <div className={className} id={id.toString()} ref={this.div} />
-        );
-    }
-}
+import { createRef, Component } from '@24i/bigscreen-sdk/jsx';
+
+export type MockData = { id: number };
+
+export const getMockData = (amount: number): MockData[] => {
+    const data = [];
+    for (let i = 0; i < amount; i++) {
+        data.push({ id: i });
+    }
+    return data;
+};
+
+type Props = {
+    className: string,
+    id: number,
+};
+
+export class MockItem extends Component<Props> {
+    div = createRef<HTMLDivElement>();
+
+    show = jest.fn();
+
+    hide = jest.fn();
+
+    focus(options?: FocusOptions) {
+        this.div.current!.focus(options);
+    }
+
+    updateData() {}
+
+    hasDom(dom: HTMLElement) {
+        return this.div.current === dom;
+    }
+
+    render() {
+        const { id, className } = this.props;
+        return (
+            <div className={className} id={id.toString()} ref={this.div} />
+        );
+    }
+}

package/packages/grid/src/types.ts

@@ -1,69 +1,69 @@
-import { Reference } from '@24i/bigscreen-sdk/jsx';
-import { EasingType } from '@24i/bigscreen-sdk/animations';
-
-export interface Item<T> {
-    focus: (options?: FocusOptions) => void,
-    show: () => void,
-    hide: () => void,
-    updateData: (item: T, index: number) => void,
-    hasDom?: (target: HTMLElement) => boolean,
-    onFastScrolling?: (isFastScrolling: boolean) => void,
-}
-
-export type GroupInfo = {
-    element: Reference<HTMLElement>,
-    dataIndex: number,
-    offset: number,
-};
-
-type CommonProps<T extends Item<U>, U> = {
-    data: U[],
-    renderItem: (item: U, index: number, ref: Reference<T>) => JSX.Element,
-    scrollStep: number,
-    className?: string,
-    continuousFocus?: boolean;
-    onFocusChanged?: (item: Reference<T>, index: number) => void,
-    animation?: Partial<AnimationConfiguration>,
-    animate?: boolean,
-    fastScrolling?: boolean,
-    fastFocusingOptimization?: boolean,
-    onScrollChanged?: (item: Reference<T>, scrollIndex: number) => void,
-    firstScrollStep?: number,
-    preventBlurOnLongPress?: {
-        forward?: boolean,
-        backward?: boolean,
-        forwardGroup?: boolean,
-        backwardGroup?: boolean,
-    }
-};
-
-type VerticalSharedProps = {
-    columns: number;
-    visibleRows: number;
-    horizontal?: false,
-    rows?: false;
-    visibleColumns?: false;
-};
-type HorizontalSharedProps = {
-    columns?: false;
-    visibleRows?: false;
-    horizontal: true;
-    rows: number;
-    visibleColumns: number;
-};
-
-export type SharedProps<T extends Item<U>, U> =
-(VerticalSharedProps & CommonProps<T, U>) | (HorizontalSharedProps & CommonProps<T, U>);
-
-export type AnimationConfiguration = {
-    normal: {
-        time: number,
-        easing: EasingType,
-    },
-    fastLinear?: {
-        time: number,
-        startRatio: number,
-        endRatio?: number,
-    }
-    slowdownRatio?: number,
-};
+import { Reference } from '@24i/bigscreen-sdk/jsx';
+import { EasingType } from '@24i/bigscreen-sdk/animations';
+
+export interface Item<T> {
+    focus: (options?: FocusOptions) => void,
+    show: () => void,
+    hide: () => void,
+    updateData: (item: T, index: number) => void,
+    hasDom?: (target: HTMLElement) => boolean,
+    onFastScrolling?: (isFastScrolling: boolean) => void,
+}
+
+export type GroupInfo = {
+    element: Reference<HTMLElement>,
+    dataIndex: number,
+    offset: number,
+};
+
+type CommonProps<T extends Item<U>, U> = {
+    data: U[],
+    renderItem: (item: U, index: number, ref: Reference<T>) => JSX.Element,
+    scrollStep: number,
+    className?: string,
+    continuousFocus?: boolean;
+    onFocusChanged?: (item: Reference<T>, index: number) => void,
+    animation?: Partial<AnimationConfiguration>,
+    animate?: boolean,
+    fastScrolling?: boolean,
+    fastFocusingOptimization?: boolean,
+    onScrollChanged?: (item: Reference<T>, scrollIndex: number) => void,
+    firstScrollStep?: number,
+    preventBlurOnLongPress?: {
+        forward?: boolean,
+        backward?: boolean,
+        forwardGroup?: boolean,
+        backwardGroup?: boolean,
+    }
+};
+
+type VerticalSharedProps = {
+    columns: number;
+    visibleRows: number;
+    horizontal?: false,
+    rows?: false;
+    visibleColumns?: false;
+};
+type HorizontalSharedProps = {
+    columns?: false;
+    visibleRows?: false;
+    horizontal: true;
+    rows: number;
+    visibleColumns: number;
+};
+
+export type SharedProps<T extends Item<U>, U> =
+(VerticalSharedProps & CommonProps<T, U>) | (HorizontalSharedProps & CommonProps<T, U>);
+
+export type AnimationConfiguration = {
+    normal: {
+        time: number,
+        easing: EasingType,
+    },
+    fastLinear?: {
+        time: number,
+        startRatio: number,
+        endRatio?: number,
+    }
+    slowdownRatio?: number,
+};

package/packages/grid/src/utils.ts

@@ -1,69 +1,69 @@
-import { map } from '@24i/bigscreen-sdk/perf-utils/array';
-import { GridBase } from './Base';
-import { AnimationConfiguration, GroupInfo } from './types';
-
-export const configureAnimation = (
-    defaultAnimation: AnimationConfiguration,
-    propsAnimation: Partial<AnimationConfiguration>,
-): AnimationConfiguration => ({
-    normal: {
-        time: propsAnimation.normal?.time || defaultAnimation.normal.time,
-        easing: propsAnimation.normal?.easing || defaultAnimation.normal.easing,
-    },
-    // eslint-disable-next-line no-nested-ternary
-    fastLinear: propsAnimation.fastLinear ? {
-        time: propsAnimation.fastLinear.time,
-        startRatio: propsAnimation.fastLinear.startRatio,
-        endRatio: propsAnimation.fastLinear.endRatio,
-    } : defaultAnimation.fastLinear ? {
-        time: defaultAnimation.fastLinear.time,
-        startRatio: defaultAnimation.fastLinear.startRatio,
-        endRatio: defaultAnimation.fastLinear.endRatio,
-    } : undefined,
-    slowdownRatio: propsAnimation.slowdownRatio || defaultAnimation.slowdownRatio || undefined,
-});
-
-export const getOffsetObject = (horizontal: boolean | undefined, offset: number) => (
-    { [horizontal ? 'x' : 'y']: offset }
-);
-
-export const prepareAnimatedGroups = (grid: GridBase<any, any>): GroupInfo[] => {
-    const itemsInGroup = grid.getItemsInGroup();
-    return map(grid.groupRefs, (groupRef, groupIndex) => ({
-        element: groupRef,
-        dataIndex: groupIndex * itemsInGroup,
-        offset: 0,
-    }));
-};
-
-/**
- * Convert Scroll position in pixels to Scroll index.
- * @param pixels Scroll position in pixels (expect positive number)
- * @param scrollStep Size in pixels for one step of scroller
- * @param firstScrollStep Size in pixels for first scroller step
- * @returns scroll index
- */
-export const scrollPixelsToIndexForward = (
-    pixels: number, scrollStep: number, firstScrollStep?: number,
-) => {
-    if (pixels === 0) return 0;
-    if (typeof firstScrollStep === 'undefined') return Math.ceil(pixels / scrollStep);
-    if (pixels <= firstScrollStep) return 1;
-    return Math.ceil((pixels - firstScrollStep) / scrollStep) + 1;
-};
-
-/**
- * Convert Scroll position in pixels to Scroll index.
- * @param pixels Scroll position in pixels (expect positive number)
- * @param scrollStep Size in pixels for one step of scroller
- * @param firstScrollStep Size in pixels for first scroller step
- * @returns scroll index
- */
-export const scrollPixelsToIndexBackward = (
-    pixels: number, scrollStep: number, firstScrollStep?: number,
-) => {
-    if (pixels === 0) return 0;
-    if (typeof firstScrollStep === 'undefined') return Math.floor(pixels / scrollStep);
-    if (pixels <= firstScrollStep) return 0;
-    return Math.floor((pixels - firstScrollStep) / scrollStep) + 1;
-};
+import { map } from '@24i/bigscreen-sdk/perf-utils/array';
+import { GridBase } from './Base';
+import { AnimationConfiguration, GroupInfo } from './types';
+
+export const configureAnimation = (
+    defaultAnimation: AnimationConfiguration,
+    propsAnimation: Partial<AnimationConfiguration>,
+): AnimationConfiguration => ({
+    normal: {
+        time: propsAnimation.normal?.time || defaultAnimation.normal.time,
+        easing: propsAnimation.normal?.easing || defaultAnimation.normal.easing,
+    },
+    // eslint-disable-next-line no-nested-ternary
+    fastLinear: propsAnimation.fastLinear ? {
+        time: propsAnimation.fastLinear.time,
+        startRatio: propsAnimation.fastLinear.startRatio,
+        endRatio: propsAnimation.fastLinear.endRatio,
+    } : defaultAnimation.fastLinear ? {
+        time: defaultAnimation.fastLinear.time,
+        startRatio: defaultAnimation.fastLinear.startRatio,
+        endRatio: defaultAnimation.fastLinear.endRatio,
+    } : undefined,
+    slowdownRatio: propsAnimation.slowdownRatio || defaultAnimation.slowdownRatio || undefined,
+});
+
+export const getOffsetObject = (horizontal: boolean | undefined, offset: number) => (
+    { [horizontal ? 'x' : 'y']: offset }
+);
+
+export const prepareAnimatedGroups = (grid: GridBase<any, any>): GroupInfo[] => {
+    const itemsInGroup = grid.getItemsInGroup();
+    return map(grid.groupRefs, (groupRef, groupIndex) => ({
+        element: groupRef,
+        dataIndex: groupIndex * itemsInGroup,
+        offset: 0,
+    }));
+};
+
+/**
+ * Convert Scroll position in pixels to Scroll index.
+ * @param pixels Scroll position in pixels (expect positive number)
+ * @param scrollStep Size in pixels for one step of scroller
+ * @param firstScrollStep Size in pixels for first scroller step
+ * @returns scroll index
+ */
+export const scrollPixelsToIndexForward = (
+    pixels: number, scrollStep: number, firstScrollStep?: number,
+) => {
+    if (pixels === 0) return 0;
+    if (typeof firstScrollStep === 'undefined') return Math.ceil(pixels / scrollStep);
+    if (pixels <= firstScrollStep) return 1;
+    return Math.ceil((pixels - firstScrollStep) / scrollStep) + 1;
+};
+
+/**
+ * Convert Scroll position in pixels to Scroll index.
+ * @param pixels Scroll position in pixels (expect positive number)
+ * @param scrollStep Size in pixels for one step of scroller
+ * @param firstScrollStep Size in pixels for first scroller step
+ * @returns scroll index
+ */
+export const scrollPixelsToIndexBackward = (
+    pixels: number, scrollStep: number, firstScrollStep?: number,
+) => {
+    if (pixels === 0) return 0;
+    if (typeof firstScrollStep === 'undefined') return Math.floor(pixels / scrollStep);
+    if (pixels <= firstScrollStep) return 0;
+    return Math.floor((pixels - firstScrollStep) / scrollStep) + 1;
+};