@maestro_io/maestro-web-sdk 4.0.0 → 4.0.1

package/dist/src/external/spatial-navigation/measureLayout.js

@@ -0,0 +1,30 @@
+const ELEMENT_NODE = 1;
+const getRect = (node) => {
+    let { offsetParent } = node;
+    const height = node.offsetHeight;
+    const width = node.offsetWidth;
+    let left = node.offsetLeft;
+    let top = node.offsetTop;
+    while (offsetParent && offsetParent.nodeType === ELEMENT_NODE) {
+        left += offsetParent.offsetLeft - offsetParent.scrollLeft;
+        top += offsetParent.offsetTop - offsetParent.scrollTop;
+        ({ offsetParent } = offsetParent);
+    }
+    return {
+        height,
+        left,
+        top,
+        width,
+    };
+};
+const measureLayout = (node, callback) => {
+    const relativeNode = node && node.parentNode;
+    if (relativeNode) {
+        const relativeRect = getRect(relativeNode);
+        const { height, left, top, width } = getRect(node);
+        const x = left - relativeRect.left;
+        const y = top - relativeRect.top;
+        callback(x, y, width, height, left, top);
+    }
+};
+export default measureLayout;

package/dist/src/external/spatial-navigation/spatialNavigation.d.ts

@@ -0,0 +1,155 @@
+import { Details, Direction, KEY_BACK, Layout } from './utils';
+import { KEY_ENTER } from './utils';
+export declare const ROOT_FOCUS_KEY = "SN:ROOT";
+export type KeyType = Direction | typeof KEY_ENTER | typeof KEY_BACK;
+export interface KeyMap {
+    [key: string]: number[];
+}
+interface FocusableComponent {
+    focusKey: string;
+    node: HTMLElement;
+    parentFocusKey: string | null;
+    onEnterPressHandler?: (details: Details) => void;
+    onBackPressHandler?: (details: Details) => void;
+    onEnterReleaseHandler?: () => void;
+    onArrowPressHandler?: (direction: Direction, details: Details) => boolean | void;
+    onBecameFocusedHandler?: (layout: Layout, details: any) => void;
+    onBecameBlurredHandler?: (layout: Layout, details: any) => void;
+    onUpdateFocus?: (isFocused: boolean) => void;
+    onUpdateHasFocusedChild?: (hasFocusedChild: boolean) => void;
+    forgetLastFocusedChild?: boolean;
+    trackChildren?: boolean;
+    lastFocusedChildKey: string | null;
+    preferredChildFocusKey?: string;
+    focusable: boolean;
+    blockNavigationOut?: boolean;
+    autoRestoreFocus?: boolean;
+    layout: Layout;
+    layoutUpdated: boolean;
+}
+interface Corner {
+    x: number;
+    y: number;
+}
+interface RefCorners {
+    a: Corner;
+    b: Corner;
+}
+export interface InitOptions {
+    debug?: boolean;
+    visualDebug?: boolean;
+    nativeMode?: boolean;
+    throttle?: number;
+    throttleKeypresses?: boolean;
+}
+interface AddFocusableOptions {
+    focusKey: string;
+    node: HTMLElement;
+    parentFocusKey: string | null;
+    onEnterPressHandler?: (details: Details) => void;
+    onEnterReleaseHandler?: () => void;
+    onBackPressHandler?: (details: Details) => void;
+    onArrowPressHandler?: (direction: Direction, details: Details) => boolean | void;
+    onBecameFocusedHandler?: (layout: Layout, details: any) => void;
+    onBecameBlurredHandler?: (layout: Layout, details: any) => void;
+    forgetLastFocusedChild?: boolean;
+    trackChildren?: boolean;
+    onUpdateFocus?: (isFocused: boolean) => void;
+    onUpdateHasFocusedChild?: (hasFocusedChild: boolean) => void;
+    preferredChildFocusKey?: string;
+    autoRestoreFocus?: boolean;
+    focusable?: boolean;
+    blockNavigationOut?: boolean;
+}
+interface UpdateFocusableOptions {
+    node?: HTMLElement;
+    preferredChildFocusKey?: string;
+    focusable?: boolean;
+    blockNavigationOut?: boolean;
+}
+export declare const getChildClosestToOrigin: (children: FocusableComponent[]) => FocusableComponent;
+declare class SpatialNavigation {
+    private focusableComponents;
+    focusKey: string | null;
+    private parentsHavingFocusedChild;
+    private nativeMode;
+    private throttle;
+    private throttleKeypresses;
+    private pressedKeys;
+    paused: boolean;
+    private keyDownEventListener;
+    private keyUpEventListener;
+    private keyMap;
+    private debug;
+    private visualDebugger;
+    private logIndex;
+    /**
+     * Used to determine the coordinate that will be used to filter items that are over the "edge"
+     */
+    static getCutoffCoordinate(isVertical: boolean, isIncremental: boolean, isSibling: boolean, layout: Layout): number;
+    /**
+     * Returns two corners (a and b) coordinates that are used as a reference points
+     * Where "a" is always leftmost and topmost corner, and "b" is rightmost bottommost corner
+     */
+    static getRefCorners(direction: Direction, isSibling: boolean, layout: Layout): RefCorners;
+    /**
+     * Calculates if the sibling node is intersecting enough with the ref node by the secondary coordinate
+     */
+    static isAdjacentSlice(refCorners: RefCorners, siblingCorners: RefCorners, isVerticalDirection: boolean): boolean;
+    static getPrimaryAxisDistance(refCorners: RefCorners, siblingCorners: RefCorners, isVerticalDirection: boolean): number;
+    static getSecondaryAxisDistance(refCorners: RefCorners, siblingCorners: RefCorners, isVerticalDirection: boolean): number;
+    /**
+     * Inspired by: https://developer.mozilla.org/en-US/docs/Mozilla/Firefox_OS_for_TV/TV_remote_control_navigation#Algorithm_design
+     * Ref Corners are the 2 corners of the current component in the direction of navigation
+     * They used as a base to measure adjacent slices
+     */
+    sortSiblingsByPriority(siblings: FocusableComponent[], currentLayout: Layout, direction: Direction, _focusKey: string): FocusableComponent[];
+    constructor(options?: InitOptions);
+    init({ debug, visualDebug, nativeMode, throttle, throttleKeypresses, }?: InitOptions): void;
+    startDrawLayouts(): void;
+    destroy(): void;
+    getEventType(keyCode: number): KeyType | undefined;
+    bindEventHandlers(): void;
+    unbindEventHandlers(): void;
+    onEnterPress(details: Details): void;
+    onBackPress(details: Details): void;
+    onEnterRelease(): void;
+    onArrowPress(direction: Direction, details: Details): boolean | void;
+    navigateByDirection(direction: Direction, details?: Record<string, any>): void;
+    onKeyEvent(event: KeyboardEvent): void;
+    smartNavigate(direction: Direction, fromParentFocusKey: string | null, details: Record<string, any>): void;
+    saveLastFocusedChildKey(component: FocusableComponent | undefined, focusKey: string): void;
+    log(functionName: string, debugString: string, ...rest: any[]): void;
+    getNextFocusKey(targetFocusKey: string): string;
+    addFocusable({ focusKey, node, parentFocusKey, onEnterPressHandler, onEnterReleaseHandler, onBackPressHandler, onArrowPressHandler, onBecameFocusedHandler, onBecameBlurredHandler, forgetLastFocusedChild, trackChildren, onUpdateFocus, onUpdateHasFocusedChild, preferredChildFocusKey, autoRestoreFocus, focusable, blockNavigationOut, }: AddFocusableOptions): void;
+    removeFocusable({ focusKey }: {
+        focusKey: string;
+    }): void;
+    getNodeLayoutByFocusKey(focusKey: string): Layout | null;
+    setCurrentFocusedKey(newFocusKey: string, details: Record<string, any>): void;
+    updateParentsHasFocusedChild(focusKey: string, details: Record<string, any>): void;
+    updateParentsLastFocusedChild(focusKey: string): void;
+    getKeyMap(): KeyMap;
+    setKeyMap(keyMap: KeyMap): void;
+    isFocusableComponent(focusKey: string): boolean;
+    /**
+     * Checks whether the focusableComponent is actually participating in spatial navigation (in other words, is a
+     * 'focusable' focusableComponent). Seems less confusing than calling it isFocusableFocusableComponent()
+     */
+    isParticipatingFocusableComponent(focusKey: string): boolean;
+    onIntermediateNodeBecameFocused(focusKey: string, details: Record<string, any>): void;
+    onIntermediateNodeBecameBlurred(focusKey: string, details: Record<string, any>): void;
+    pause(): void;
+    resume(): void;
+    setFocus(targetFocusKey: string, details?: Record<string, any>): void;
+    updateAllLayouts(): void;
+    updateLayout(focusKey: string): void;
+    updateFocusable(focusKey: string, { node, preferredChildFocusKey, focusable, blockNavigationOut, }: UpdateFocusableOptions): void;
+    isNativeMode(): boolean;
+    getFocusableComponents(): FocusableComponent[];
+    getFocusableComponentsByParentFocusKey(parentFocusKey: string): FocusableComponent[];
+}
+/**
+ * Export singleton
+ */
+export default SpatialNavigation;