@applicaster/zapp-react-native-utils 14.0.0-rc.9 → 15.0.0-rc.2

package/playerUtils/__tests__/configurationUtils.test.ts

@@ -1,72 +1,8 @@
 import * as utils from "../configurationUtils";
 
-const { modifyDefaultConfigValues, parseLanguageTracks } = utils;
-
-const configuration = {
-  general: { fields: [{ key: "general_1", initial_value: true }] },
-  styles: { fields: [{ key: "styles_1", initial_value: true }] },
-  localizations: {
-    fields: [{ key: "localizations_1", initial_value: true, label: "label" }],
-  },
-  custom_configuration_fields: [
-    { key: "custom_configuration_fields_1", initial_value: true },
-    { key: "custom_configuration_fields_2", initial_value: "black" },
-    {
-      group: true,
-      fields: [{ key: "custom_configuration_fields_3", initial_value: "red" }],
-    },
-  ],
-};
+const { parseLanguageTracks } = utils;
 
 describe("utilities", () => {
-  describe("modifyDefaultConfigValues", () => {
-    it("should not modify the configuration if a map key doesn't exist in configuration ", function () {
-      const res = modifyDefaultConfigValues(configuration, {
-        custom_configuration_fields: {
-          non_existing_key: { initial_value: "true" },
-        },
-      });
-
-      expect(res).toEqual(configuration);
-    });
-
-    it("should modify the key from mapping", function () {
-      const currentResult = modifyDefaultConfigValues(configuration, {
-        styles: { styles_1: { initial_value: false } },
-      });
-
-      expect(currentResult.styles.fields[0].initial_value).toBe(false);
-    });
-
-    it("should add extra keys the key from mapping", function () {
-      const currentResult = modifyDefaultConfigValues(configuration, {
-        styles: { styles_1: { extra_key: false } },
-      });
-
-      expect(currentResult.styles.fields[0].extra_key).toBeDefined();
-    });
-
-    it("should not remove existing keys that aren't being overwritten", function () {
-      const currentResult = modifyDefaultConfigValues(configuration, {
-        localizations: { localizations_1: { initial_value: false } },
-      });
-
-      expect(currentResult.localizations.fields[0].label).toBeDefined();
-    });
-
-    it("should modify values in groups as well", function () {
-      const currentResult = modifyDefaultConfigValues(configuration, {
-        custom_configuration_fields: {
-          custom_configuration_fields_3: { initial_value: "blue" },
-        },
-      });
-
-      expect(
-        currentResult.custom_configuration_fields[2].fields[0].initial_value
-      ).toBe("blue");
-    });
-  });
-
   describe("parseLanguageTracks", () => {
     const textTrack = { index: 0, id: "text-0" };
     const audioTrack = { index: 0, id: "audio-0" };

package/playerUtils/__tests__/getPlayerActionButtons.test.ts

@@ -0,0 +1,54 @@
+import { getPlayerActionButtons } from "../getPlayerActionButtons";
+import { selectActionButtons } from "../../conf/player/selectors";
+
+jest.mock("../../conf/player/selectors", () => ({
+  selectActionButtons: jest.fn(),
+}));
+
+describe("getPlayerActionButtons", () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("returns an empty array if selectActionButtons returns undefined", () => {
+    (selectActionButtons as jest.Mock).mockReturnValue(undefined);
+    const result = getPlayerActionButtons({});
+    expect(result).toEqual([]);
+  });
+
+  it("returns an empty array if selectActionButtons returns null", () => {
+    (selectActionButtons as jest.Mock).mockReturnValue(null);
+    const result = getPlayerActionButtons({});
+    expect(result).toEqual([]);
+  });
+
+  it("returns an empty array if selectActionButtons returns empty string", () => {
+    (selectActionButtons as jest.Mock).mockReturnValue("");
+    const result = getPlayerActionButtons({});
+    expect(result).toEqual([]);
+  });
+
+  it("returns the first two trimmed action buttons", () => {
+    (selectActionButtons as jest.Mock).mockReturnValue(" play , pause , stop ");
+    const result = getPlayerActionButtons({});
+    expect(result).toEqual(["play", "pause"]);
+  });
+
+  it("returns only one button if only one is present", () => {
+    (selectActionButtons as jest.Mock).mockReturnValue(" play ");
+    const result = getPlayerActionButtons({});
+    expect(result).toEqual(["play"]);
+  });
+
+  it("trims whitespace from button names", () => {
+    (selectActionButtons as jest.Mock).mockReturnValue("  play  ,   pause  ");
+    const result = getPlayerActionButtons({});
+    expect(result).toEqual(["play", "pause"]);
+  });
+
+  it("returns an empty array if selectActionButtons returns only commas", () => {
+    (selectActionButtons as jest.Mock).mockReturnValue(" , , ");
+    const result = getPlayerActionButtons({});
+    expect(result).toEqual(["", ""]);
+  });
+});

package/playerUtils/_internals/__tests__/utils.test.ts

@@ -0,0 +1,71 @@
+import { getAllFields, getConfigurationDiff } from "../utils";
+
+describe("getAllFields", () => {
+  it("should return all field keys from flat configs", () => {
+    const config1 = {
+      fields: [{ key: "foo" }, { key: "bar" }],
+    };
+
+    const config2 = {
+      fields: [{ key: "baz" }],
+    };
+
+    expect(getAllFields(config1, config2)).toEqual(["foo", "bar", "baz"]);
+  });
+
+  it("should handle grouped fields", () => {
+    const config = {
+      fields: [
+        {
+          group: true,
+          fields: [{ key: "grouped1" }, { key: "grouped2" }],
+        },
+        { key: "single" },
+      ],
+    };
+
+    expect(getAllFields(config)).toEqual(["grouped1", "grouped2", "single"]);
+  });
+
+  it("should filter out fields without a key", () => {
+    const config = {
+      fields: [{ key: "foo" }, { notAKey: "bar" }],
+    };
+
+    expect(getAllFields(config)).toEqual(["foo"]);
+  });
+
+  it("should return an empty array if no fields are present", () => {
+    expect(getAllFields({})).toEqual([]);
+  });
+});
+
+describe("getConfigurationDiff", () => {
+  it("should return keys in defaultConfig not present in config", () => {
+    const defaultConfig = ["foo", "bar", "baz"];
+    const config = { foo: 1, baz: 2 };
+
+    expect(getConfigurationDiff(defaultConfig, config)).toEqual(["bar"]);
+  });
+
+  it("should return all keys if config is empty", () => {
+    const defaultConfig = ["foo", "bar"];
+    const config = {};
+
+    expect(getConfigurationDiff(defaultConfig, config)).toEqual(["foo", "bar"]);
+  });
+
+  it("should return an empty array if all keys are present", () => {
+    const defaultConfig = ["foo"];
+    const config = { foo: 1 };
+
+    expect(getConfigurationDiff(defaultConfig, config)).toEqual([]);
+  });
+
+  it("should return defaultConfig if config has no matching keys", () => {
+    const defaultConfig = ["foo", "bar"];
+    const config = { baz: 1 };
+
+    expect(getConfigurationDiff(defaultConfig, config)).toEqual(["foo", "bar"]);
+  });
+});

package/playerUtils/_internals/index.ts

@@ -0,0 +1 @@
+export * from "./utils";

package/playerUtils/_internals/utils.ts

@@ -0,0 +1,31 @@
+import {
+  flatMap,
+  get,
+  flatten,
+  difference,
+} from "@applicaster/zapp-react-native-utils/utils";
+
+const extractFields = (field: any) => {
+  if (field.group === true) {
+    return field.fields;
+  }
+
+  return field;
+};
+
+export const getAllFields = (...configs: any[]) => {
+  const allFields = flatMap(configs, (config) => get(config, "fields", []));
+
+  const processedFields = flatten(allFields.map(extractFields))
+    .map((field) => get(field, "key"))
+    .filter(Boolean);
+
+  return processedFields;
+};
+
+export const getConfigurationDiff = (
+  defaultConfig,
+  config: Record<string, any>
+) => {
+  return difference(defaultConfig, Object.keys(config));
+};

package/playerUtils/configurationUtils.ts

@@ -1,50 +1,6 @@
 import { parseJsonIfNeeded } from "../functionUtils";
 import * as R from "ramda";
 
-import { getNativeName as nativeNameUtil } from "../localizationUtils/localeLanguage";
-
-export const modifyDefaultConfigValues = (
-  configuration: ConfigurationKeys,
-  mapping: ConfigValuesMapping
-): DefaultConfiguration => {
-  return R.mapObjIndexed((value, key) => {
-    const isFieldlessKey = key === "custom_configuration_fields";
-    const keyMapping = mapping[key];
-    const fields = value?.fields || value;
-
-    if (!keyMapping) {
-      return value;
-    }
-
-    const mapper = (obj) => {
-      if (obj.fields) {
-        return R.mergeLeft({ fields: R.map(mapper)(obj.fields) })(obj);
-      }
-
-      return R.mergeLeft(keyMapping?.[obj.key])(obj);
-    };
-
-    const mappedFields = R.map(mapper)(fields);
-
-    return R.unless(() => isFieldlessKey, R.objOf("fields"))(mappedFields);
-  })(configuration);
-};
-
-export function nativeName(localeCode) {
-  try {
-    const {
-      getNativeName,
-    } = require("@applicaster/zapp-react-native-utils/localizationUtils/localeLanguage");
-
-    return getNativeName(localeCode);
-  } catch (error) {
-    // eslint-disable-next-line no-console
-    console.warn("Could not load localeLanguage utils from QB", error);
-
-    return nativeNameUtil(localeCode);
-  }
-}
-
 const setTrackType = R.curry(
   (
     type: QuickBrickPlayer.TrackType,

package/playerUtils/getPlayerActionButtons.ts

@@ -0,0 +1,17 @@
+import { map, take, trim } from "../utils";
+import { selectActionButtons } from "../conf/player/selectors";
+
+/**
+ * Returns the first two action buttons from the configuration.
+ * @param {Object} configuration - The player configuration object.
+ * @returns {Array} An array containing the first two action buttons.
+ */
+export const getPlayerActionButtons = (configuration: any) => {
+  const buttonsString = selectActionButtons(configuration);
+
+  if (!buttonsString) {
+    return [];
+  }
+
+  return take(2, map(buttonsString.split(","), trim));
+};

package/playerUtils/index.ts

@@ -5,6 +5,9 @@ import { isFilledArray } from "@applicaster/zapp-react-native-utils/arrayUtils";
 import { isTV } from "@applicaster/zapp-react-native-utils/reactUtils";
 
 import { getBoolFromConfigValue } from "../configurationUtils";
+import { Dimensions } from "react-native";
+
+export { getPlayerActionButtons } from "./getPlayerActionButtons";
 
 /**
  * Gets duration value from player manager, and from extensions
@@ -95,3 +98,53 @@ export const isAudioItem = (item: Option<ZappEntry>) => {
 export const isInlineTV = (screenData) => {
   return isTV() && isFilledArray(screenData?.ui_components);
 };
+
+const isPercentage = (value: string | number): boolean => {
+  if (typeof value === "string") {
+    return value.includes("%");
+  }
+
+  return false;
+};
+
+const getPercentageOf = (percent: string, value: number) => {
+  const percentageValue = parseFloat(percent.replace("%", ""));
+
+  if (isNaN(percentageValue)) {
+    return value;
+  }
+
+  return (value * percentageValue) / 100;
+};
+
+type DimensionsT = {
+  width: number | string;
+  height: number | string | undefined;
+  aspectRatio?: number;
+};
+
+export const getTabletWidth = (
+  tablet_landscape_sidebar_width,
+  dimensions: DimensionsT
+) => {
+  const { width: SCREEN_WIDTH } = Dimensions.get("screen");
+
+  const { width } = dimensions;
+  let widthValue = Number(width);
+
+  if (isPercentage(width)) {
+    widthValue = getPercentageOf(width.toString(), SCREEN_WIDTH);
+  }
+
+  const sidebarWidth = Number(tablet_landscape_sidebar_width?.replace("%", ""));
+
+  if (tablet_landscape_sidebar_width?.includes("%")) {
+    return widthValue * (1 - sidebarWidth / 100);
+  }
+
+  if (Number.isNaN(sidebarWidth)) {
+    return widthValue * 0.65;
+  }
+
+  return widthValue - sidebarWidth;
+};

package/playerUtils/usePlayerTTS.ts

@@ -0,0 +1,21 @@
+import * as React from "react";
+import { usePlayer } from "@applicaster/zapp-react-native-utils/appUtils/playerManager/usePlayer";
+import { useAccessibilityManager } from "@applicaster/zapp-react-native-utils/appUtils/accessibilityManager/hooks";
+import { PlayerTTS } from "@applicaster/zapp-react-native-utils/playerUtils/PlayerTTS";
+
+export const usePlayerTTS = () => {
+  const player = usePlayer();
+  const accessibilityManager = useAccessibilityManager({});
+
+  React.useEffect(() => {
+    if (player && accessibilityManager) {
+      const playerTTS = new PlayerTTS(player, accessibilityManager);
+      const unsubscribe = playerTTS.init();
+
+      return () => {
+        unsubscribe();
+        playerTTS.destroy();
+      };
+    }
+  }, [player, accessibilityManager]);
+};

package/playerUtils/useValidatePlayerConfig.tsx

@@ -1,34 +1,37 @@
 import * as React from "react";
-import * as R from "ramda";
-import generateConfiguration from "./configurationGenerator";
 import { createLogger } from "../logger";
+import { createConfig } from "../manifestUtils/createConfig";
+import { getAllFields, getConfigurationDiff } from "./_internals";
 
 export const logger = createLogger({
   category: "useValidatePlayerConfig",
   subsystem: "useValidatePlayerConfig",
 });
 
-const configuration = generateConfiguration();
+/** Default Player Configuration */
+const {
+  styles,
+  general,
+  localizations,
+  custom_configuration_fields,
+}: DefaultConfiguration = createConfig(
+  () => {
+    return {};
+  },
+  { extend: "player" }
+) as any;
+
+const QBPlayerConfigFields = getAllFields(
+  styles,
+  general,
+  localizations,
+  custom_configuration_fields
+);
 
 export const useValidatePlayerConfig = (config) => {
   React.useEffect(() => {
     try {
-      const QBPlayerConfigFields = R.compose(
-        R.map(R.prop("key")),
-        R.flatten,
-        R.map(R.compose(R.when(R.propEq("group", true), R.prop("fields")))),
-        R.concat
-      )(
-        configuration.styles.fields,
-        configuration.general.fields,
-        configuration.localizations.fields,
-        configuration.custom_configuration_fields
-      );
-
-      const diff = R.compose(
-        R.difference(QBPlayerConfigFields),
-        R.keys
-      )(config);
+      const diff = getConfigurationDiff(QBPlayerConfigFields, config);
 
       logger.log_info(
         "Missing following configuration properties. Some elements of the player may not work correctly. Check QuickBrickPlayerPlugin for the configuration reference https://github.com/applicaster/QuickBrick/tree/main/plugins/zapp-react-native-default-player/manifests",

package/reactHooks/autoscrolling/__tests__/useTrackedView.test.tsx

@@ -1,27 +1,31 @@
 import React from "react";
 
-import { act, renderHook } from "@testing-library/react-hooks";
+import { renderHook } from "@testing-library/react-hooks";
+import { act, waitFor } from "@testing-library/react-native";
 import { Provider } from "react-redux";
 import configureStore from "redux-mock-store";
+import { useTrackedView } from "../useTrackedView";
 
 const mockUpdateComponentsPositions = jest.fn();
 
 jest.mock(
   "@applicaster/zapp-react-native-ui-components/Contexts/ScreenTrackedViewPositionsContext",
   () => ({
-    useScreenTrackedViewPositionsContext: jest.fn().mockReturnValue({
+    useScreenTrackedViewPositionsContext: jest.fn(() => ({
       updateComponentsPositions: mockUpdateComponentsPositions,
       value: {
         "123": { componentId: "123", centerX: 0.4, centerY: 0.5 },
         "124": { componentId: "124", centerX: 0.2, centerY: 0.3 },
       },
-    }),
+    })),
   })
 );
 
-jest.useFakeTimers({ legacyFakeTimers: true });
+jest.useFakeTimers();
 
-jest.mock("@applicaster/zapp-react-native-utils/reactHooks/navigation");
+jest.mock(
+  "@applicaster/zapp-react-native-utils/reactHooks/navigation/useNavigation"
+);
 
 const mockStore = configureStore();
 
@@ -32,10 +36,8 @@ const Wrapper = ({ children }: { children: React.ReactChild }) => (
   <Provider store={store}>{children}</Provider>
 );
 
-const { useTrackedView } = require("../useTrackedView");
-
 describe("useTrackCurrentAutoScrollingElement", () => {
-  it("should update position for selected component - onViewportEnter", () => {
+  it("should update position for selected component - onViewportEnter", async () => {
     const { result } = renderHook(() => useTrackedView("123"), {
       wrapper: Wrapper,
     });
@@ -46,14 +48,13 @@ describe("useTrackCurrentAutoScrollingElement", () => {
       rect: { left: 1, right: 1, top: 1, bottom: 1 },
     };
 
-    act(async () => {
-      await result.current.onPositionUpdated(mockRect);
+    act(() => {
+      result.current.onPositionUpdated(mockRect);
     });
 
-    // Fast-forward until all timers have been executed
-    jest.runAllTimers();
-
-    expect(result.current.inViewPort).toBe(true);
+    await waitFor(() => {
+      expect(result.current.inViewPort).toBe(true);
+    });
 
     expect(mockUpdateComponentsPositions).toHaveBeenCalledWith(
       "123",

package/reactHooks/cell-click/__tests__/index.test.js

@@ -26,6 +26,9 @@ jest.mock("@applicaster/zapp-react-native-utils/analyticsUtils/", () => ({
 }));
 
 jest.mock("@applicaster/zapp-react-native-utils/reactHooks/screen", () => ({
+  ...jest.requireActual(
+    "@applicaster/zapp-react-native-utils/reactHooks/screen"
+  ),
   useTargetScreenData: jest.fn(() => ({})),
   useCurrentScreenData: jest.fn(() => ({})),
 }));

package/reactHooks/cell-click/index.ts

@@ -16,7 +16,8 @@ import { ActionExecutorContext } from "@applicaster/zapp-react-native-utils/acti
 import { isFunction, noop } from "../../functionUtils";
 import { useSendAnalyticsOnPress } from "../analytics";
 import { logOnPress, warnEmptyContentType } from "./helpers";
-import { useCurrentScreenData } from "../screen";
+import { useCurrentScreenData, useScreenContext } from "../screen";
+import { useScreenStateStore } from "../navigation/useScreenStateStore";
 
 /**
  * If onCellTap is defined execute the function and
@@ -42,10 +43,12 @@ export const useCellClick = ({
 }: Props): onPressReturnFn => {
   const { push, currentRoute } = useNavigation();
   const { pathname } = useRoute();
+  const screenStateStore = useScreenStateStore();
 
   const onCellTap: Option<Function> = React.useContext(CellTapContext);
   const actionExecutor = React.useContext(ActionExecutorContext);
   const screenData = useCurrentScreenData();
+  const screenState = useScreenContext()?.options;
 
   const cellSelectable = toBooleanWithDefaultTrue(
     component?.rules?.component_cells_selectable
@@ -83,6 +86,9 @@ export const useCellClick = ({
         await actionExecutor?.handleEntryActions(selectedItem, {
           component,
           screenData,
+          screenState,
+          screenRoute: pathname,
+          screenStateStore,
         });
       }
 
@@ -117,6 +123,7 @@ export const useCellClick = ({
       push,
       sendAnalyticsOnPress,
       screenData,
+      screenState,
     ]
   );
 

package/reactHooks/debugging/__tests__/index.test.js

@@ -12,7 +12,6 @@ describe("Debug utils", () => {
     // Clear the timers object
     Object.keys(timers).forEach((key) => delete timers[key]);
 
-    // Mock performance.now()
     // eslint-disable-next-line no-undef
     performanceNowMock = jest.spyOn(performance, "now");
     performanceNowMock.mockReturnValue(0); // Initial value