@applicaster/zapp-react-dom-app 12.0.0-rc.7 → 12.0.0-rc.71

package/App/InteractionManager/index.tsx

@@ -592,6 +592,12 @@ export function withInteractionManager(Component: React.FC) {
           focusManager.moveFocus(direction);
         }
 
+        if (!isDialogVisible) {
+          // run focus recovery on user interaction attempt
+          // probably we failed to set initial focus for some reason
+          focusManager.recoverFocus();
+        }
+
         if (
           displayState === DISPLAY_STATES.PLAYER ||
           displayState === DISPLAY_STATES.HUD
@@ -656,6 +662,9 @@ export function withInteractionManager(Component: React.FC) {
 
     onConfirmDialogClose() {
       this.confirmDialog.hideDialog();
+
+      // restore initial focus after closing dialog
+      focusManager.setInitialFocus();
     }
 
     render() {

package/App/Loader/appLoader.js

@@ -8,11 +8,7 @@ export const appLoaderImpl =
   ) =>
   async (dispatch, getState) => {
     try {
-      const {
-        plugins,
-        pluginConfigurations,
-        remoteConfigurations: { localizations },
-      } = getState();
+      const { plugins, pluginConfigurations } = getState();
 
       // Await crucial tasks
       await loadLocale();
@@ -20,7 +16,7 @@ export const appLoaderImpl =
       await loadAnalyticsPlugins(plugins, pluginConfigurations);
 
       // Remaining loaders
-      const loaders = [loadDomPlugins(plugins), setUpRTL(localizations)];
+      const loaders = [loadDomPlugins(plugins), setUpRTL()];
 
       // Await for the remaining tasks and return when they are all complete
       await Promise.all(loaders);

package/App/Loader/setUpRTL.js

@@ -1,7 +1,7 @@
-import { getIsRTLFromLocalizations } from "@applicaster/zapp-react-native-utils/localizationUtils";
+import { getIsRTL } from "@applicaster/zapp-react-native-utils/localizationUtils";
 import { I18nManager } from "react-native";
 
-export async function setUpRTL(localizations) {
-  const isRTL = getIsRTLFromLocalizations(localizations);
+export async function setUpRTL() {
+  const isRTL = getIsRTL();
   I18nManager.forceRTL(isRTL);
 }

package/App/Loader/utils/__tests__/getLanguageCode.test.js

@@ -26,7 +26,6 @@ describe("getLanguageCode", () => {
 
     // verify
     expect(result).toEqual(locale);
-    expect(setLanguageCodeToLocalStorage).toHaveBeenCalledWith(locale);
   });
 
   it("return value from local-storage", async () => {

package/App/Loader/utils/index.js

@@ -8,7 +8,7 @@ export const getLanguageCodeFromLocalStorage = () => {
   return NativeModules.LocalStorage.getItem(UI_LANGUAGE);
 };
 
-export const setLanguageCodeToLocalStorage = async (languageCode) => {
+export const persistLanguageSelection = async (languageCode) => {
   await NativeModules.SessionStorage.setItem(UI_LANGUAGE, languageCode);
 
   return NativeModules.LocalStorage.setItem(UI_LANGUAGE, languageCode);
@@ -61,32 +61,34 @@ export const getLanguageCodeImpl =
   (
     GetLanguageCodeFromLocalStorage,
     GetAvailableAppLanguages,
-    PickBestMatchedLanguage,
-    SetLanguageCodeToLocalStorage
+    PickBestMatchedLanguage
   ) =>
   async (locale) => {
     const languageFromLocalStorage = await GetLanguageCodeFromLocalStorage();
 
     if (languageFromLocalStorage) {
       return languageFromLocalStorage;
-    } else {
-      const availableAppLanguages = GetAvailableAppLanguages();
+    }
 
-      const pickedLanguage = PickBestMatchedLanguage(
-        locale,
-        availableAppLanguages
-      );
+    const availableAppLanguages = GetAvailableAppLanguages();
 
-      await SetLanguageCodeToLocalStorage(pickedLanguage);
+    const pickedLanguage = PickBestMatchedLanguage(
+      locale,
+      availableAppLanguages
+    );
 
-      return pickedLanguage;
-    }
+    return pickedLanguage;
   };
 
 /**
- * Supported platforms: [Samsung] TODO: LG
- * This function is adding languageLocale and countryLocale to the QuickBrickCommunicationModule
- * @return Promise
+/**
+ * Loads and sets locale-related information in the QuickBrickCommunicationModule.
+ * This function adds uiLanguage, countryLocale, languageLocale, and languageCode to the module.
+ *
+ * @param {Function} GetLocale - Function to retrieve the current locale.
+ * @param {Function} GetLanguageCode - Function to determine the language code based on available languages.
+ * @param {Object} quickBrickCommunicationModule - The module to be updated with locale information.
+ * @returns {Promise<Function>} An async function that loads and sets the locale information.
  * Warning! This function mutates QuickBrickCommunicationModule
  */
 export const loadLocaleImpl =
@@ -101,14 +103,13 @@ export const loadLocaleImpl =
       quickBrickCommunicationModule.countryLocale = R.toUpper(countryLocale);
     }
 
-    // setup languageCode
     const languageCode = await GetLanguageCode(locale);
     quickBrickCommunicationModule.languageCode = languageCode;
+    quickBrickCommunicationModule.uiLanguage = languageCode;
   };
 
 export const getLanguageCode = getLanguageCodeImpl(
   getLanguageCodeFromLocalStorage,
   getAvailableAppLanguages,
-  pickBestMatchedLanguage,
-  setLanguageCodeToLocalStorage
+  pickBestMatchedLanguage
 );

package/Polyfills/AnalyticsBridge/index.ts

@@ -105,7 +105,11 @@ function isInvalidAnalyticsData(eventName, payload = null) {
 
 export const AnalyticsBridge = (function () {
   let registeredAnalyticPlugins: {
-    module: { sendEvent: Function; initialize?: Function };
+    module: {
+      sendEvent: Function;
+      initialize?: Function;
+      getPlayerConfiguration?: Function;
+    };
     configuration?: any;
   }[] = [];
 

package/Polyfills/AppLoaderBridge/utils/enums.ts

@@ -8,4 +8,5 @@ export enum STORAGE {
 export enum STORE_PLATFORM {
   lg = "lg_content_store",
   samsung = "samsung_app_store",
+  vizio = "vizio_app_store",
 }

package/Polyfills/QuickBrickCommunicationModule/__tests__/index.test.js

@@ -0,0 +1,225 @@
+const mockPersistLanguageSelection = jest.fn();
+
+jest.mock("../../../App/Loader/utils", () => ({
+  persistLanguageSelection: mockPersistLanguageSelection,
+}));
+
+const mockGetAppData = jest.fn();
+
+jest.mock("../../AppData", () => ({
+  getAppData: mockGetAppData,
+}));
+
+jest.mock("@applicaster/zapp-react-native-bridge/QuickBrick", () => ({
+  QUICK_BRICK_EVENTS: {
+    QUICK_BRICK_READY: "QUICK_BRICK_READY",
+    FORCE_APP_RELOAD: "FORCE_APP_RELOAD",
+  },
+}));
+
+const mocked_storage = {
+  "applicaster.v2_::_uiLanguage": "en-UK",
+};
+
+global.window.location = {
+  reload: jest.fn(),
+};
+
+global.window.localStorage = {
+  getItem: jest.fn((key) => mocked_storage[key] || null),
+  setItem: jest.fn((key, value) => {
+    mocked_storage[key] = value;
+  }),
+  removeItem: jest.fn((key) => {
+    delete mocked_storage[key];
+  }),
+  clear: jest.fn(),
+  length: 1,
+  key: jest.fn(),
+};
+
+const BASE_MOCK_APP_DATA = {
+  accountsAccountId: "abcid123",
+  appFamilyId: 1710,
+  appName: "App.TV",
+  buildVersion: 247,
+  bundleIdentifier: "com.bundleIdentifier",
+  deviceTarget: "samsung_tv",
+  languages: ["en", "en-US", "fr", "fr-FR"],
+  locale: "en",
+  quickBrickVersion: "11.1.13",
+  quickBrickEvent: () => {},
+  setAppLanguage: () => {},
+  initialProps: {},
+  riversConfigurationId: "riverid123",
+  sdkVersion: "1.0.0",
+  store: "samsung",
+  urlSchemePrefix: "app-tv",
+  versionId: "version1233",
+  versionName: "1.0.8",
+  bver: "1.0.8",
+  os_type: "web",
+  platform: "samsung_tv",
+};
+
+const getMockAppData = (overrides = {}) => ({
+  ...BASE_MOCK_APP_DATA,
+  ...overrides,
+});
+
+describe("QuickBrickCommunicationModule Polyfill", () => {
+  let originalWindow;
+  let QuickBrickModule;
+  let mockAppData;
+
+  beforeEach(() => {
+    jest.resetModules();
+    originalWindow = global.window;
+
+    // Get fresh mockAppData for each test
+    mockAppData = getMockAppData();
+    mockGetAppData.mockReturnValue(mockAppData);
+
+    window.localStorage.getItem.mockClear();
+    window.localStorage.setItem.mockClear();
+    window.localStorage.removeItem.mockClear();
+    window.localStorage.clear.mockClear();
+
+    QuickBrickModule = require("../index");
+  });
+
+  afterEach(() => {
+    global.window = originalWindow;
+    jest.clearAllMocks();
+  });
+
+  describe("getMatchingLanguageFromBuildData", () => {
+    it("should return default locale (en) if there are no languages listed in build time parameters", () => {
+      window.localStorage.getItem.mockReturnValue(undefined);
+      global.window.navigator.language = "ru-RU";
+      mockGetAppData.mockReturnValue(getMockAppData({ languages: null }));
+
+      const result = QuickBrickModule.getMatchingLanguageFromBuildData();
+
+      expect(result).toEqual({
+        uiLanguage: "en",
+        languageCode: "en",
+        countryLocale: "",
+        languageLocale: "en",
+      });
+    });
+
+    it("should fallback to default language if browser / device locale (en-UK) does not match list of supported languages", () => {
+      // localizations: ["en", "en-US", "fr", "fr-FR"], device_language: en, device_region: UK -> ui: en, language: en, region: UK
+
+      global.window.navigator.language = "en-UK";
+      const result = QuickBrickModule.getMatchingLanguageFromBuildData();
+
+      expect(result).toEqual({
+        uiLanguage: "en",
+        languageCode: "en",
+        countryLocale: "",
+        languageLocale: "en",
+      });
+    });
+
+    it("should use browser / device locale (en-US) when it matches one of the supported languages", () => {
+      // localizations: ["en", "en-US", "fr", "fr-FR"], device_language: en, device_region: US -> ui: en-US, language: en, region: US
+
+      global.window.navigator.language = "en-US";
+      const result = QuickBrickModule.getMatchingLanguageFromBuildData();
+
+      expect(result).toEqual({
+        uiLanguage: "en-US",
+        languageCode: "en",
+        countryLocale: "US",
+        languageLocale: "en-US",
+      });
+    });
+
+    it("should fallback to default language if browser / device locale (ru-RU) does not match list of supported languages", () => {
+      // localizations: ["en", "en-US", "fr", "fr-FR"], device_language: ru, device_region: RU -> ui: en, language: en, region: ""
+      global.window.navigator.language = "ru-RU";
+      const result = QuickBrickModule.getMatchingLanguageFromBuildData();
+
+      expect(result).toEqual({
+        uiLanguage: "en",
+        languageCode: "en",
+        countryLocale: "",
+        languageLocale: "en",
+      });
+    });
+
+    it("should use browser / device locale (fr-FR) when it matches one of the supported language", () => {
+      // localizations: ["en", "en-US", "fr", "fr-FR"], device_language: fr, device_region: FR -> ui: fr, language: fr, region: FR
+      global.window.navigator.language = "fr-FR";
+      const result = QuickBrickModule.getMatchingLanguageFromBuildData();
+
+      expect(result).toEqual({
+        uiLanguage: "fr-FR",
+        languageCode: "fr",
+        countryLocale: "FR",
+        languageLocale: "fr-FR",
+      });
+    });
+
+    it("should use user-selected language (en-US) if it was persisted in local storage", () => {
+      window.localStorage.getItem.mockReturnValue("en-US");
+
+      const result = QuickBrickModule.getMatchingLanguageFromBuildData();
+
+      expect(window.localStorage.getItem).toHaveBeenCalled();
+
+      expect(result).toEqual({
+        uiLanguage: "en-US",
+        languageCode: "en",
+        countryLocale: "US",
+        languageLocale: "en-US",
+      });
+    });
+
+    it("should use locale (fr-FR) from browser / device if no user selection is found in storage", () => {
+      window.localStorage.getItem.mockReturnValue(undefined);
+      global.window.navigator.language = "fr-FR";
+      const result = QuickBrickModule.getMatchingLanguageFromBuildData();
+
+      expect(result).toEqual({
+        uiLanguage: "fr-FR",
+        languageCode: "fr",
+        countryLocale: "FR",
+        languageLocale: "fr-FR",
+      });
+    });
+  });
+
+  describe("setAppLanguage", () => {
+    it("should persist language selection and reload the page", async () => {
+      await QuickBrickModule.setAppLanguage("fr-FR");
+
+      expect(mockPersistLanguageSelection).toHaveBeenCalledWith("fr-FR");
+      expect(window.location.reload).toHaveBeenCalled();
+    });
+  });
+
+  describe("QuickBrickCommunicationModule", () => {
+    it("should initialize with the required app data", () => {
+      expect(QuickBrickModule.QuickBrickCommunicationModule).toMatchObject({
+        ...mockAppData,
+        platform: mockAppData.deviceTarget,
+        setAppLanguage: expect.any(Function),
+      });
+    });
+
+    it("should include locale data after calling getMatchingLanguageBuildData", () => {
+      const localeData = QuickBrickModule.getMatchingLanguageFromBuildData();
+      const result = { ...mockAppData, ...localeData };
+
+      Object.entries(result).forEach(([key, value]) => {
+        expect(QuickBrickModule.QuickBrickCommunicationModule).toHaveProperty(
+          key,
+          typeof value === "function" ? expect.any(Function) : value
+        );
+      });
+    });
+  });
+});

package/Polyfills/QuickBrickCommunicationModule/index.js

@@ -1,8 +1,15 @@
 import * as R from "ramda";
 
-import * as AppDataPolyfill from "../AppData";
-import { setLanguageCodeToLocalStorage } from "../../App/Loader/utils";
+import { persistLanguageSelection } from "../../App/Loader/utils";
+
+import { getAppData } from "../AppData";
 import { QUICK_BRICK_EVENTS } from "@applicaster/zapp-react-native-bridge/QuickBrick";
+import { createLogger } from "@applicaster/zapp-react-native-utils/logger";
+
+const { log_error, log_debug, log_warning } = createLogger({
+  category: "QuickBrickCommunicationModule",
+  subsystem: "zapp-react-dom-app",
+});
 
 const QuickBrickEventEmitter = {};
 
@@ -63,98 +70,154 @@ try {
   console.warn("cannot assign QuickBrickEvents to window", e.message);
 }
 
-function quickBrickEvent(eventName, payload) {
+export function quickBrickEvent(eventName, payload) {
   QuickBrickEventEmitter.sendEvent(eventName, payload);
 }
 
 const initialProps = {}; // required for legacy plugins;
 
-function getBrowserLocale() {
+/**
+ * Retrieves the browser locale, which represents the device locale for SmartTVs.
+ *
+ * @returns {string|undefined} The browser locale string (e.g., "en-US") or undefined if an error occurs.
+ *
+ * TODO: We can later get more accurate locale data with device APIs, if needed
+ */
+export function getBrowserLocale() {
   try {
     return window.navigator.language;
   } catch (e) {
-    // eslint-disable-next-line no-console
-    console.error("Could not determine browser locale", e);
+    log_error("Could not determine locale", e);
   }
 }
 
-function formatLocale(locale) {
-  return locale?.toLowerCase()?.split("-");
-}
-
-const browserLocale = getBrowserLocale();
-const [languageCode, countryLocale] = formatLocale(browserLocale) || ["", ""];
-
-const setAppLanguage = async (languageCode) => {
-  await setLanguageCodeToLocalStorage(languageCode);
+/**
+ * Updates the UI language, persists the selection, and reloads the application.
+ * This method is used by the QuickBrick Language Selector to change the app's language.
+ *
+ * @param {string} uiLanguage - en-UK, en-US, etc.
+ * @returns {Promise<void>}
+ *
+ * Usage: plugins/quick-brick-language-selector/src/utils/index.ts
+ */
+export const setAppLanguage = async (uiLanguage) => {
+  await persistLanguageSelection(uiLanguage);
 
-  // reload web page
   window.location.reload();
 };
 
-const buildTimeData = AppDataPolyfill.getAppData();
-
-// TODO - move to a better place
-const getMatchingLanguageFromBuildData = () => {
+const buildTimeData = getAppData();
+
+/**
+ * This method retrieves the all of the language data we need from the build data, and the browser locale.
+ * @returns localeData
+ * @returns localeData.uiLanguage - The language code to use for the app.
+ * @returns localeData.countryLocale - The country locale code.
+ * @returns localeData.languageLocale - The language locale code.
+ * @returns localeData.languageCode - The language code.
+ */
+export const getMatchingLanguageFromBuildData = () => {
+  // Locale is a build time value we get from Zapp, so we can use it as a fallback
   const { locale, languages } = buildTimeData || {};
+  const browserLocale = getBrowserLocale();
+
+  if (!Array.isArray(languages)) {
+    log_error("Missing required 'languages' from the build time data.", {
+      buildTimeData,
+    });
+
+    return {
+      uiLanguage: locale,
+      languageCode: locale,
+      countryLocale: "",
+      languageLocale: locale,
+    };
+  }
 
-  // TODO: refactor: tryAndResolve used in Storage is promise
   const userSelectedLanguage = window.localStorage.getItem(
     "applicaster.v2_::_uiLanguage"
   );
 
-  if (!locale && !Array.isArray(languages)) {
-    // eslint-disable-next-line no-console
-    console.error("Missing required 'locale' and 'language' build time data.");
-
-    // Default language
-    return locale;
-  }
-
   if (userSelectedLanguage) {
-    if (languages.includes(userSelectedLanguage)) {
-      return userSelectedLanguage;
+    if (languages.find((lang) => lang === userSelectedLanguage)) {
+      const [languageCode, countryLocale] = userSelectedLanguage.split("-");
+
+      return {
+        uiLanguage: userSelectedLanguage,
+        languageCode,
+        countryLocale: countryLocale || "",
+        languageLocale: userSelectedLanguage,
+      };
     }
 
-    // eslint-disable-next-line no-console
-    console.log(
-      "User selected language is not present in available localizations, performing autoselect"
+    log_debug(
+      "User selected language is not present in available localizations, selecting language using browser or device locale",
+
+      { userSelectedLanguage, languages }
     );
   }
 
   if (!browserLocale) {
-    // eslint-disable-next-line no-console
-    console.error("Could not determine browser locale.");
+    log_warning(
+      "Could not use browser or device locale to determine language, falling back to default locale",
+      { browserLocale, locale }
+    );
 
-    return locale;
+    return {
+      uiLanguage: locale,
+      languageCode: locale,
+      countryLocale: "",
+      languageLocale: locale,
+    };
   }
 
-  // Match locale "en-UK"
-  const localeMatch = languages.find((lang) => lang === browserLocale);
+  // Exact match
+  const [browserLanguageCode, browserCountryLocale] = browserLocale.split("-");
+  const browserLocaleMatch = languages.find((lang) => lang === browserLocale);
 
-  if (localeMatch) {
-    return localeMatch;
+  if (browserLocaleMatch) {
+    return {
+      uiLanguage: browserLocaleMatch,
+      languageCode: browserLanguageCode,
+      countryLocale: browserCountryLocale || "",
+      languageLocale: browserLocaleMatch,
+    };
   }
 
-  // Match language "en"
-  const languageMatch = languages.find((lang) => lang === languageCode);
+  // If there is no user-selected language, or the user-selected language is not found in the list of supported languages,
+  // and the browser locale is also not found in the list of supported languages,
+  // then fallback to the default language from the list of supported languages, while preserving the country locale from the browser.
+  const defaultLanguage = languages[0];
 
-  if (languageMatch) {
-    return languageMatch;
-  }
+  if (defaultLanguage) {
+    const [languageCode, countryLocale] = defaultLanguage.split("-");
 
-  // Default language
-  return locale;
+    const defaultLocale = {
+      uiLanguage: defaultLanguage,
+      languageCode,
+      countryLocale: countryLocale || "",
+      languageLocale: defaultLanguage,
+    };
+
+    log_debug(
+      "Locale not found in the list of supported languages, falling back to the default language locale",
+      { defaultLocale, browserLocale, languages }
+    );
+
+    return defaultLocale;
+  }
 };
 
+const localeData = getMatchingLanguageFromBuildData();
+
+/**
+ * QuickBrickCommunicationModule object is a Polyfill that mimicks how we interface with the Native platforms
+ */
 export const QuickBrickCommunicationModule = {
   quickBrickEvent,
   initialProps,
   ...buildTimeData,
+  ...localeData,
   platform: buildTimeData.deviceTarget,
-  languageLocale: languageCode,
-  countryLocale,
   setAppLanguage,
-  countryCode: countryLocale,
-  uiLanguage: getMatchingLanguageFromBuildData(),
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applicaster/zapp-react-dom-app",
-  "version": "12.0.0-rc.7",
+  "version": "12.0.0-rc.71",
   "description": "Zapp App Component for Applicaster's Quick Brick React Native App",
   "main": "index.js",
   "scripts": {
@@ -22,11 +22,11 @@
   },
   "homepage": "https://github.com/applicaster/zapp-react-dom-app#readme",
   "dependencies": {
-    "@applicaster/zapp-react-dom-ui-components": "12.0.0-rc.7",
-    "@applicaster/zapp-react-native-bridge": "12.0.0-rc.7",
-    "@applicaster/zapp-react-native-redux": "12.0.0-rc.7",
-    "@applicaster/zapp-react-native-ui-components": "12.0.0-rc.7",
-    "@applicaster/zapp-react-native-utils": "12.0.0-rc.7",
+    "@applicaster/zapp-react-dom-ui-components": "12.0.0-rc.71",
+    "@applicaster/zapp-react-native-bridge": "12.0.0-rc.71",
+    "@applicaster/zapp-react-native-redux": "12.0.0-rc.71",
+    "@applicaster/zapp-react-native-ui-components": "12.0.0-rc.71",
+    "@applicaster/zapp-react-native-utils": "12.0.0-rc.71",
     "abortcontroller-polyfill": "^1.7.5",
     "history": "^4.7.2",
     "react-router-dom": "^5.1.2",

package/App/Loader/utils/__tests__/getAvailableAppLanguages.test.js

@@ -1,35 +0,0 @@
-import { getAvailableAppLanguagesImpl as getAvailableAppLanguages } from "..";
-
-describe("getAvailableAppLanguages", () => {
-  it("return list of languages", () => {
-    // setup
-    const appStore = {
-      get: () => ({
-        localizations: {
-          en: "en_value",
-          de: "de_value",
-          fr: "fr_value",
-          "en-UK": "en-UK_value",
-          "en-GB": "en-GB_value",
-        },
-      }),
-    };
-
-    // verify
-    expect(getAvailableAppLanguages(appStore)).toEqual([
-      "en",
-      "de",
-      "fr",
-      "en-UK",
-      "en-GB",
-    ]);
-  });
-
-  it("return list of languages", () => {
-    // setup
-    const appStore = undefined;
-
-    // verify
-    expect(getAvailableAppLanguages(appStore)).toEqual([]);
-  });
-});