@applicaster/zapp-react-native-utils 14.0.0-alpha.8387612031 → 14.0.0-alpha.8583696651

package/manifestUtils/progressBar/__tests__/mobileProgressBar.test.js

@@ -18,36 +18,6 @@ describe("mobileProgressBar", () => {
     ]),
   });
 
-  // const timeRemainingLabelConditions = (condition) => ({
-  //   rules: "all_conditions",
-  //   conditional_fields: compact([
-  //     {
-  //       key: "assets/progress_bar_switch",
-  //       condition_value: true,
-  //     },
-  //     {
-  //       key: "assets/progress_bar_time_remaining_label_enable",
-  //       condition_value: true,
-  //     },
-  //     condition,
-  //   ]),
-  // });
-
-  // const watchedLabelConditions = (condition) => ({
-  //   rules: "all_conditions",
-  //   conditional_fields: compact([
-  //     {
-  //       key: "assets/progress_bar_switch",
-  //       condition_value: true,
-  //     },
-  //     {
-  //       key: "assets/progress_bar_watched_label_enable",
-  //       condition_value: true,
-  //     },
-  //     condition,
-  //   ]),
-  // });
-
   it("generate progress-bar configuration - enabled and with bottom_of_cell", () => {
     const enable = true;
     const hideUnwatched = true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applicaster/zapp-react-native-utils",
-  "version": "14.0.0-alpha.8387612031",
+  "version": "14.0.0-alpha.8583696651",
   "description": "Applicaster Zapp React Native utilities package",
   "main": "index.js",
   "types": "index.d.ts",
@@ -27,7 +27,7 @@
   },
   "homepage": "https://github.com/applicaster/quickbrick#readme",
   "dependencies": {
-    "@applicaster/applicaster-types": "14.0.0-alpha.8387612031",
+    "@applicaster/applicaster-types": "14.0.0-alpha.8583696651",
     "buffer": "^5.2.1",
     "camelize": "^1.0.0",
     "dayjs": "^1.11.10",

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/_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

@@ -1,4 +1,4 @@
-import { take, map, trim } from "lodash";
+import { map, take, trim } from "../utils";
 import { selectActionButtons } from "../conf/player/selectors";
 
 /**

package/playerUtils/index.ts

@@ -5,6 +5,7 @@ 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";
 
@@ -97,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/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,25 +1,27 @@
 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");
 
@@ -32,10 +34,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 +46,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",