@applicaster/zapp-react-native-utils 15.0.0-rc.98 → 15.1.0-alpha.1852552014

package/appUtils/contextKeysManager/index.ts

@@ -1,4 +1,4 @@
-import { isNil } from "@applicaster/zapp-react-native-utils/utils";
+import * as R from "ramda";
 
 import { StorageLevel, StorageType } from "./consts";
 import {
@@ -13,7 +13,6 @@ import {
   localStorage as LocalStorage,
   secureStorage as SecureStorage,
 } from "./storage";
-import { NativeModules } from "react-native";
 
 export { StorageLevel };
 
@@ -155,65 +154,11 @@ export class ContextKeysManager {
   }
 
   public async getKeys(
-    keys: Array<KeyName>,
-    contextObj?: { key: string; required?: boolean }[]
+    keys: Array<KeyName>
   ): Promise<Map<KeyName, ValueOrNothing>> {
-    if (NativeModules.ContextResolverBridge) {
-      const keysObj: Record<string, boolean> = {};
+    const values = await Promise.all(keys.map((key) => this.getKey(key)));
 
-      const requiredByKey = new Map(
-        contextObj?.map((item) => [item.key, item.required ?? false]) ?? []
-      );
-
-      let hasResolvableKeys = false;
-
-      const normalizedKeys: Array<{
-        original: KeyName;
-        normalized: string | null;
-      }> = [];
-
-      for (const key of keys) {
-        const {
-          isValid: isValidKey,
-          key: parsedKey,
-          namespace: parsedNamespace,
-        } = this.parseKey(key);
-
-        if (!isValidKey) {
-          normalizedKeys.push({ original: key, normalized: null });
-          continue;
-        }
-
-        const normalized = buildNamespaceKey(parsedKey, parsedNamespace);
-
-        keysObj[normalized] = requiredByKey.get(normalized) ?? false;
-        hasResolvableKeys = true;
-        normalizedKeys.push({ original: key, normalized });
-      }
-
-      if (!hasResolvableKeys) {
-        return new Map(
-          normalizedKeys.map(({ original }) => [original, NOTHING])
-        );
-      }
-
-      const res =
-        await NativeModules.ContextResolverBridge.resolveContextKeys(keysObj);
-
-      const resolved = res ?? {};
-
-      return new Map(
-        normalizedKeys.map(({ original, normalized }) => {
-          if (!normalized) return [original, NOTHING];
-
-          return [original, resolved[normalized] ?? NOTHING];
-        })
-      );
-    } else {
-      const values = await Promise.all(keys.map((key) => this.getKey(key)));
-
-      return new Map(keys.map((key, index) => [key, values[index]]));
-    }
+    return new Map(R.zip(keys, values));
   }
 
   public async getKey(key: KeyName): Promise<ValueOrNothing> {
@@ -236,7 +181,7 @@ export class ContextKeysManager {
       parsedNamespace
     );
 
-    if (!isNil(resultByReference)) {
+    if (!R.isNil(resultByReference)) {
       return resultByReference;
     }
 
@@ -247,7 +192,7 @@ export class ContextKeysManager {
         parsedNamespace
       );
 
-      if (!isNil(resultFromSessionStorage)) {
+      if (!R.isNil(resultFromSessionStorage)) {
         return resultFromSessionStorage;
       }
 
@@ -256,7 +201,7 @@ export class ContextKeysManager {
         parsedNamespace
       );
 
-      if (!isNil(resultFromLocalStorage)) {
+      if (!R.isNil(resultFromLocalStorage)) {
         return resultFromLocalStorage;
       }
 
@@ -265,7 +210,7 @@ export class ContextKeysManager {
         parsedNamespace
       );
 
-      if (!isNil(resultFromSecureStorage)) {
+      if (!R.isNil(resultFromSecureStorage)) {
         return resultFromSecureStorage;
       }
 
@@ -330,7 +275,7 @@ export class ContextKeysManager {
       keysProp.map((keyProp) => this.setKey(keyProp))
     );
 
-    return new Map(keys.map((key, index) => [key, values[index]]));
+    return new Map(R.zip(keys, values));
   }
 
   // when succeed saving - return true
@@ -439,7 +384,7 @@ export class ContextKeysManager {
   public async removeKeys(keys: KeyName[]): Promise<Map<KeyName, boolean>> {
     const values = await Promise.all(keys.map((key) => this.removeKey(key)));
 
-    return new Map(keys.map((key, index) => [key, values[index]]));
+    return new Map(R.zip(keys, values));
   }
   // REMOVE
 }

package/appUtils/focusManager/__tests__/__snapshots__/focusManager.test.js.snap

@@ -71,9 +71,6 @@ exports[`focusManagerIOS should be defined 1`] = `
   "invokeHandler": [Function],
   "isChildOf": [Function],
   "isFocusOn": [Function],
-  "isFocusOnContent": [Function],
-  "isFocusOnMenu": [Function],
-  "isFocusOnTabsScreenContent": [Function],
   "isGroupItemFocused": [Function],
   "moveFocus": [Function],
   "on": [Function],

package/appUtils/focusManager/index.ios.ts

@@ -4,11 +4,7 @@ import * as R from "ramda";
 import {
   isCurrentFocusOn,
   isChildOf as isChildOfUtils,
-  isPartOfMenu,
-  isPartOfContent,
-  isPartOfTabsScreenContent,
-} from "../focusManagerAux/utils/index.ios";
-
+} from "../focusManagerAux/utils";
 import { Tree } from "./treeDataStructure/Tree";
 import { findFocusableNode } from "./treeDataStructure/Utils";
 import { subscriber } from "../../functionUtils";
@@ -192,15 +188,9 @@ export const focusManager = (function () {
   function register({ id, component }) {
     const { isGroup = false } = component;
 
-    if (isGroup) {
-      registerGroup(id, component);
-    } else {
-      registerItem(id, component);
-    }
+    emitRegistered(id);
 
-    const groupId = component?.props?.groupId;
-
-    emitRegistered({ id, groupId, isGroup });
+    return isGroup ? registerGroup(id, component) : registerItem(id, component);
   }
 
   function unregister(id, { group = false } = {}) {
@@ -283,9 +273,7 @@ export const focusManager = (function () {
   function setFocus(
     id: string,
     direction?: FocusManager.IOS.Direction,
-    options?: Partial<{
-      groupFocusedChanged: boolean;
-    }>,
+    options?: Partial<{ groupFocusedChanged: boolean }>,
     callback?: any
   ) {
     blur(direction);
@@ -424,30 +412,6 @@ export const focusManager = (function () {
     return id && isCurrentFocusOn(id, currentFocusNode);
   }
 
-  function isFocusOnMenu(): boolean {
-    const currentFocusable = getCurrentFocus();
-
-    return isPartOfMenu(focusableTree, currentFocusable?.props?.id);
-  }
-
-  function isFocusOnContent(): boolean {
-    const currentFocusable = getCurrentFocus();
-
-    return isPartOfContent(focusableTree, currentFocusable?.props?.id);
-  }
-
-  function isFocusOnTabsScreenContent(
-    screenPickerContentContainerId: string
-  ): boolean {
-    const currentFocusable = getCurrentFocus();
-
-    return isPartOfTabsScreenContent(
-      focusableTree,
-      screenPickerContentContainerId,
-      currentFocusable?.props?.id
-    );
-  }
-
   function isChildOf(childId, parentId): boolean {
     return isChildOfUtils(focusableTree, childId, parentId);
   }
@@ -474,9 +438,6 @@ export const focusManager = (function () {
     isGroupItemFocused,
     getPreferredFocusChild,
     isFocusOn,
-    isFocusOnMenu,
-    isFocusOnContent,
-    isFocusOnTabsScreenContent,
     isChildOf,
   };
 })();

package/appUtils/focusManagerAux/utils/index.ts

@@ -13,7 +13,7 @@ import {
 
 import {
   getFocusableId,
-  SCREEN_PICKER_CONTAINER,
+  isTabsScreenContentContainerId,
 } from "@applicaster/zapp-react-native-utils/screenPickerUtils";
 
 // run check each 300 ms
@@ -24,8 +24,6 @@ const isTopMenu = (node) => startsWith(QUICK_BRICK_NAVBAR, node?.id);
 const isContent = (node) => startsWith(QUICK_BRICK_CONTENT, node?.id);
 const isRoot = (node) => node?.id === "root";
 
-const isScrenPicker = (node) => startsWith(SCREEN_PICKER_CONTAINER, node?.id);
-
 type Props = {
   maxTimeout: number;
   conditionFn: () => boolean;
@@ -102,7 +100,7 @@ export const getNavbarNode = (focusableTree) => {
 
 export const waitForContent = (focusableTree) => {
   const contentHasAnyChildren = (): boolean => {
-    const countOfChildren = pathOr<number>(
+    const countOfChildren = pathOr(
       0,
       ["children", "length"],
       getContentNode(focusableTree)
@@ -136,7 +134,7 @@ export const isTabsScreenOnContentFocused = (node) => {
     return false;
   }
 
-  if (isScrenPicker(node)) {
+  if (isTabsScreenContentContainerId(node?.id)) {
     return true;
   }
 

package/appUtils/focusManagerAux/utils/utils.ios.ts

@@ -1,9 +1,7 @@
-import { ReplaySubject, Subject } from "rxjs";
-import { filter, switchMap, take, withLatestFrom, map } from "rxjs/operators";
-
+import { ReplaySubject } from "rxjs";
+import { filter } from "rxjs/operators";
 import { BUTTON_PREFIX } from "@applicaster/zapp-react-native-ui-components/Components/MasterCell/DefaultComponents/tv/TvActionButtons/const";
 import { focusManager } from "@applicaster/zapp-react-native-utils/appUtils/focusManager/index.ios";
-import { isPartOfMenu, isPartOfContent } from "./index.ios";
 
 type FocusableID = string;
 type RegistrationEvent = {
@@ -11,25 +9,6 @@ type RegistrationEvent = {
   registered: boolean;
 };
 
-let focusableViewRegistrationSubject$ = new Subject<{
-  id: FocusableID;
-  groupId: FocusableID;
-}>();
-
-let focusableGroupRegistrationSubject$ = new ReplaySubject<{
-  id: FocusableID;
-}>();
-
-let focusableNativeViewRegistrationSubject$ = new Subject<{
-  id: FocusableID;
-  groupId: FocusableID;
-}>();
-
-let focusableNativeGroupRegistrationSubject$ = new ReplaySubject<{
-  id: FocusableID;
-  groupId: FocusableID;
-}>();
-
 const isFocusableButton = (id: Option<FocusableID>): boolean =>
   id && id.includes?.(BUTTON_PREFIX);
 
@@ -43,189 +22,14 @@ export const focusableButtonsRegistration$ = (focusableGroupId: string) =>
     )
   );
 
-export const resetFocusableRegistration = () => {
-  // complete the old subject so subscribers are notified and resources are freed
-  if (!focusableViewRegistrationSubject$.closed) {
-    focusableViewRegistrationSubject$.complete();
-  }
-
-  if (!focusableGroupRegistrationSubject$.closed) {
-    focusableGroupRegistrationSubject$.complete();
-  }
-
-  if (!focusableNativeViewRegistrationSubject$.closed) {
-    focusableNativeViewRegistrationSubject$.complete();
-  }
-
-  if (!focusableNativeGroupRegistrationSubject$.closed) {
-    focusableNativeGroupRegistrationSubject$.complete();
-  }
-
-  focusableViewRegistrationSubject$ = new Subject<{
-    id: FocusableID;
-    groupId: FocusableID;
-  }>();
-
-  focusableGroupRegistrationSubject$ = new ReplaySubject<{
-    id: FocusableID;
-  }>();
-
-  focusableNativeViewRegistrationSubject$ = new Subject<{
-    id: FocusableID;
-    groupId: FocusableID;
-  }>();
-
-  focusableNativeGroupRegistrationSubject$ = new ReplaySubject<{
-    id: FocusableID;
-    groupId: FocusableID;
-  }>();
-};
-
-const focusableNativeViewRegistration = ({ focusableView, focusableGroup }) => {
-  return focusableNativeViewRegistrationSubject$.pipe(
-    filter(
-      (focusableNativeView) => focusableNativeView.id === focusableView.id
-    ),
-    take(1),
-    switchMap((focusableNativeView) =>
-      // start waiting registration of its parent FocusableNativeGroup
-      focusableNativeGroupRegistrationSubject$.pipe(
-        filter(
-          (focusableNativeGroup) =>
-            focusableNativeGroup.id === focusableNativeView.groupId
-        ),
-        take(1),
-        map((focusableNativeGroup) => ({
-          focusableNativeGroup,
-          focusableNativeView,
-          focusableView,
-          focusableGroup,
-        }))
-      )
-    )
-  );
-};
-
-export const firstFocusableViewRegistrationFactory = () =>
-  focusableViewRegistrationSubject$.pipe(
-    take(1), // we care about only first FocusableView registration
-    switchMap((focusableView) =>
-      // start waiting registration of its parent FocusableGroup
-      focusableGroupRegistrationSubject$.pipe(
-        filter((focusableGroup) => focusableGroup.id === focusableView.groupId),
-        take(1),
-        map((focusableGroup) => ({
-          focusableView,
-          focusableGroup,
-        }))
-      )
-    ),
-    // start waiting registration for FocusableNativeView and its parent FocusableNativeGroup
-    switchMap(({ focusableView, focusableGroup }) =>
-      focusableNativeViewRegistration({
-        focusableView,
-        focusableGroup,
-      })
-    )
-  );
-
-// registration on RN level(into RN focusManager)
-export const emitRegistered = ({
-  id,
-  groupId,
-  isGroup,
-}: {
-  id: Option<FocusableID>;
-  groupId: Option<FocusableID>;
-  isGroup: boolean;
-}): void => {
+export const emitRegistered = (id: Option<FocusableID>): void => {
   if (isFocusableButton(id)) {
     registeredSubject$.next({ id, registered: true });
   }
-
-  if (isGroup && id) {
-    focusableGroupRegistrationSubject$.next({ id });
-  }
-
-  if (!isGroup && id && groupId) {
-    focusableViewRegistrationSubject$.next({ id, groupId });
-  }
 };
 
-// unregistration on RN level(into RN focusManager)
 export const emitUnregistered = (id: Option<FocusableID>): void => {
   if (isFocusableButton(id)) {
     registeredSubject$.next({ id, registered: false });
   }
 };
-
-// registration focusableNativeView and focusableNativeGroup
-export const emitNativeRegistered = ({
-  id,
-  groupId,
-  isGroup,
-}: {
-  id: Option<FocusableID>;
-  groupId: Option<FocusableID>;
-  isGroup: boolean;
-}): void => {
-  if (!isGroup && id && groupId) {
-    focusableNativeViewRegistrationSubject$.next({ id, groupId });
-  }
-
-  if (isGroup && id && groupId) {
-    focusableNativeGroupRegistrationSubject$.next({ id, groupId });
-  }
-};
-
-// /////
-
-const focusedSubject$ = new Subject<FocusableID>();
-
-const focused$ = focusedSubject$.asObservable();
-
-export const emitFocused = (id: FocusableID): void => {
-  focusedSubject$.next(id);
-};
-
-export const topMenuItemFocused$ = focused$.pipe(
-  filter((id) => id && isPartOfMenu(focusManager.focusableTree, id))
-);
-
-export const contentFocused$ = focused$.pipe(
-  filter((id) => {
-    const isContent = isPartOfContent(focusManager.focusableTree, id);
-
-    return id && isContent;
-  })
-);
-
-const createFocusableRegistry = () => {
-  const subject$ = new ReplaySubject<FocusableID | undefined>(1);
-
-  return {
-    observable$: subject$.asObservable(),
-    register: (id: FocusableID) => {
-      // save focusable_id on registration
-      subject$.next(id);
-    },
-    unregister: () => {
-      // reset focusable_id on unregistration
-      subject$.next(undefined);
-    },
-  };
-};
-
-/// HOME_TOP_MENU_ITEM
-export const HomeTopMenuItemRegistry = createFocusableRegistry();
-
-export const homeTopMenuItemFocused$ = topMenuItemFocused$.pipe(
-  withLatestFrom(HomeTopMenuItemRegistry.observable$),
-  filter(([id, homeId]) => id === homeId)
-);
-
-/// SCREEN_PICKER
-export const ScreenPickerContentContainerRegistry = createFocusableRegistry();
-
-/// SEARCH_INPUT
-export const SearchInputRegistry = createFocusableRegistry();

package/appUtils/keyCodes/keys/keys.web.ts

@@ -10,7 +10,10 @@ import { Platform } from "react-native";
  * platformKeys[Platform.OS] should only include keys
  * that are unique to that platform, i.e. Exit: { keyCode: 10182 }
  */
-export const KEYS = Object.assign(platformKeys.web, platformKeys[Platform.OS]);
+export const KEYS = Object.assign(
+  platformKeys["web"],
+  platformKeys[Platform.OS]
+);
 
 export const ARROW_KEYS = [
   KEYS.ArrowUp,

package/appUtils/localizationsHelper.ts

@@ -85,6 +85,10 @@ export const toDayJSLocaleMap = (code) => {
     tt: null,
     "es-LA": "es",
     "en-UK": "en-gb",
+    "en-ZA": null,
+    "en-NG": null,
+    "en-ZW": null,
+    "en-ZM": null,
   };
 
   if (map[code] === null) {

package/appUtils/orientationHelper.ts

@@ -1,5 +1,5 @@
 import * as ReactNative from "react-native";
-import { useAppData } from "@applicaster/zapp-react-native-redux/hooks";
+import { usePickFromState } from "@applicaster/zapp-react-native-redux/hooks";
 
 import { isTV, platformSelect } from "../reactUtils";
 import { useIsTablet } from "../reactHooks";
@@ -184,7 +184,9 @@ export const getScreenOrientation = ({
 
 export const useGetScreenOrientation = (screenData) => {
   const isTablet = useIsTablet();
-  const { isTabletPortrait } = useAppData();
+
+  const { appData } = usePickFromState(["appData"]);
+  const isTabletPortrait = appData?.isTabletPortrait;
 
   return getScreenOrientation({
     screenData,

package/appUtils/platform/platformUtils.ts

@@ -79,7 +79,7 @@ export class ClosedCaptioningManager {
   private constructor() {
     this.initialize();
 
-    window.vizioDebug = {
+    window["vizioDebug"] = {
       setCCEnabled: (isCCEnabled: boolean) => {
         this.ccState$.next(isCCEnabled);
       },

package/appUtils/playerManager/__tests__/playerFactory.test.ts

@@ -0,0 +1,150 @@
+const mockAppStoreGet = jest.fn();
+const mockFindPluginByIdentifier = jest.fn();
+
+jest.mock("@applicaster/zapp-react-native-redux/AppStore", () => ({
+  appStore: { get: (key: string) => mockAppStoreGet(key) },
+}));
+
+jest.mock("@applicaster/zapp-react-native-utils/pluginUtils", () => ({
+  findPluginByIdentifier: (id: string, plugins: any) =>
+    mockFindPluginByIdentifier(id, plugins),
+}));
+
+import { PlayerRole } from "../conts";
+import { playerFactory } from "../playerFactory";
+
+const fakeComponent = () => null;
+
+class FakeController {
+  receivedConfig: any;
+  constructor(config: any) {
+    this.receivedConfig = config;
+  }
+}
+
+const baseConfig = {
+  player: {},
+  playerId: "p1",
+  autoplay: false,
+  entry: { id: "entry-1" } as any,
+  muted: false,
+  playerPluginId: "test-plugin",
+  screenConfig: { foo: "bar" },
+  playerRole: PlayerRole.Cell,
+};
+
+const installPluginWithProtocol = (
+  protocolReturn: any | ((screenConfig: any, entry: any) => any)
+) => {
+  const playerProtocol =
+    typeof protocolReturn === "function"
+      ? protocolReturn
+      : () => protocolReturn;
+
+  mockAppStoreGet.mockImplementation((key: string) =>
+    key === "plugins" ? { "test-plugin": {} } : null
+  );
+
+  mockFindPluginByIdentifier.mockReturnValue({
+    module: { playerProtocol },
+  });
+};
+
+describe("playerFactory", () => {
+  beforeEach(() => {
+    mockAppStoreGet.mockReset();
+    mockFindPluginByIdentifier.mockReset();
+  });
+
+  it("resolves with controller and Component when playerProtocol returns synchronously", async () => {
+    installPluginWithProtocol({
+      Component: fakeComponent,
+      controllerClass: FakeController,
+    });
+
+    const item = await playerFactory(baseConfig);
+
+    expect(item).not.toBeNull();
+    expect(item?.Component).toBe(fakeComponent);
+    expect(item?.controller).toBeInstanceOf(FakeController);
+
+    expect((item?.controller as FakeController).receivedConfig).toBe(
+      baseConfig
+    );
+  });
+
+  it("resolves with controller and Component when playerProtocol returns a Promise (delayed import)", async () => {
+    installPluginWithProtocol(async () => ({
+      Component: fakeComponent,
+      controllerClass: FakeController,
+    }));
+
+    const item = await playerFactory(baseConfig);
+
+    expect(item).not.toBeNull();
+    expect(item?.Component).toBe(fakeComponent);
+    expect(item?.controller).toBeInstanceOf(FakeController);
+  });
+
+  it("passes screenConfig and entry through to playerProtocol", async () => {
+    const playerProtocol = jest.fn(() => ({
+      Component: fakeComponent,
+      controllerClass: FakeController,
+    }));
+
+    mockAppStoreGet.mockImplementation((key: string) =>
+      key === "plugins" ? { "test-plugin": {} } : null
+    );
+
+    mockFindPluginByIdentifier.mockReturnValue({ module: { playerProtocol } });
+
+    await playerFactory(baseConfig);
+
+    expect(playerProtocol).toHaveBeenCalledWith(
+      baseConfig.screenConfig,
+      baseConfig.entry
+    );
+  });
+
+  it("resolves to null when playerPluginId is missing", async () => {
+    expect(
+      await playerFactory({ ...baseConfig, playerPluginId: "" } as any)
+    ).toBeNull();
+  });
+
+  it("resolves to null when appStore has no plugins", async () => {
+    mockAppStoreGet.mockReturnValue(null);
+
+    expect(await playerFactory(baseConfig)).toBeNull();
+  });
+
+  it("resolves to null when the plugin has no playerProtocol", async () => {
+    mockAppStoreGet.mockImplementation((key: string) =>
+      key === "plugins" ? { "test-plugin": {} } : null
+    );
+
+    mockFindPluginByIdentifier.mockReturnValue({ module: {} });
+
+    expect(await playerFactory(baseConfig)).toBeNull();
+  });
+
+  it("resolves to null when playerProtocol returns without a Component", async () => {
+    installPluginWithProtocol({ controllerClass: FakeController });
+
+    expect(await playerFactory(baseConfig)).toBeNull();
+  });
+
+  it("resolves to null when playerProtocol returns without a controllerClass", async () => {
+    installPluginWithProtocol({ Component: fakeComponent });
+
+    expect(await playerFactory(baseConfig)).toBeNull();
+  });
+
+  it("rejects when playerProtocol throws synchronously", async () => {
+    installPluginWithProtocol(() => {
+      throw new Error("boom");
+    });
+
+    await expect(playerFactory(baseConfig)).rejects.toThrow("boom");
+  });
+});