@applicaster/zapp-react-native-utils 13.0.0-alpha.1150285364 → 13.0.0-alpha.1212224153

package/appUtils/HooksManager/Hook.ts

@@ -16,7 +16,7 @@ const BASE_HOOK_PROPERTIES = ["screen_id", "identifier", "weight"];
  * @returns {number} index
  */
 const hookState: (
-  arg0: (typeof HOOKS_EVENTS)[keyof typeof HOOKS_EVENTS]
+  arg0: typeof HOOKS_EVENTS[keyof typeof HOOKS_EVENTS]
 ) => number = R.indexOf(R.__, R.values(HOOKS_EVENTS));
 
 /**
@@ -62,7 +62,7 @@ export class Hook implements HookInterface {
    * @param {Array<Any>} args variadic arguments to invoke the handler with
    */
   setStateAndNotify(
-    event: (typeof HOOKS_EVENTS)[keyof typeof HOOKS_EVENTS],
+    event: typeof HOOKS_EVENTS[keyof typeof HOOKS_EVENTS],
     ...args
   ) {
     this.state = hookState(event);

package/appUtils/HooksManager/types.ts

@@ -103,7 +103,7 @@ export interface Hook<T extends HookModule = HookModule> {
   identifier: string;
   configuration: T["configuration"];
   setStateAndNotify(
-    event: (typeof HOOKS_EVENTS)[keyof typeof HOOKS_EVENTS],
+    event: typeof HOOKS_EVENTS[keyof typeof HOOKS_EVENTS],
     opts: {
       error?: typeof Error;
       route?: string;
@@ -112,7 +112,7 @@ export interface Hook<T extends HookModule = HookModule> {
     }
   );
   general?: {
-    transition_type: (typeof HOOKS_EVENTS)[keyof typeof HOOKS_EVENTS];
+    transition_type: typeof HOOKS_EVENTS[keyof typeof HOOKS_EVENTS];
     allow_screen_plugin_presentation: boolean;
     is_flow_blocker: boolean;
   };

package/appUtils/contextKeysManager/contextResolver.ts

@@ -42,16 +42,12 @@ export const resolveObjectValues = async (
 
   const resolvedEntries = await Promise.all(
     entries.map(async ([key, value]) => {
-      if (typeof value !== "string") {
-        return [key, value];
-      }
+      const regex = /@{([^/]+)\/([^}]*)}/;
 
-      if (!value.startsWith("@")) {
+      if (typeof value !== "string") {
         return [key, value];
       }
 
-      const regex = /@{([^/]+)\/([^}]*)}/;
-
       const match = (value as string).match(regex);
 
       if (match) {

package/appUtils/focusManager/index.ts

@@ -13,7 +13,6 @@ import {
 import { subscriber } from "../../functionUtils";
 import { coreLogger } from "../../logger";
 import { ACTION } from "./utils/enums";
-
 const logger = coreLogger.addSubsystem("focusManager");
 
 const isFocusEnabled = (focusableItem): boolean => {
@@ -326,6 +325,8 @@ export const focusManager = (function () {
         },
       });
 
+      currentFocusNode = focusCandidate;
+
       focusableItem && setFocus(focusCandidate.id, null);
 
       return { success: true };
@@ -476,7 +477,7 @@ export const focusManager = (function () {
   function isCurrentFocusOnTheTopScreen() {
     const routes = R.pathOr([], ["root", "children"], focusableTree);
 
-    if (currentFocusNode && routes.length <= 1) {
+    if (routes.length <= 1) {
       // there is only one or zero routes
       return true;
     }

package/appUtils/platform/platformUtils.ts

@@ -81,12 +81,9 @@ export class ClosedCaptioningManager {
 
   static getInstance(): ClosedCaptioningManager {
     if (!ClosedCaptioningManager.ccManagerInstance) {
-      log_debug("ClosedCaptioningManager: Creating new instance");
       ClosedCaptioningManager.ccManagerInstance = new ClosedCaptioningManager();
     }
 
-    log_debug("ClosedCaptioningManager: Returning existing instance");
-
     return ClosedCaptioningManager.ccManagerInstance;
   }
 
@@ -95,41 +92,23 @@ export class ClosedCaptioningManager {
       PLATFORM_KEYS.deviceClosedCaptioningEnabled
     );
 
-    if (existingState !== null) {
-      log_debug(
-        `ClosedCaptioningManager: Setting initial state to ${existingState}`
-      );
+    log_debug("Initializing closed captioning manager", { existingState });
 
+    if (existingState !== null) {
       this.ccState$.next(existingState === "true" || existingState === true);
-    } else {
-      log_debug("ClosedCaptioningManager: No existing state found");
     }
 
     if (hasVizioAPIs()) {
-      log_debug("ClosedCaptioningManager: Setting closed captioning handler");
-
       window.VIZIO!.setClosedCaptionHandler((isCCEnabled) => {
-        log_debug(
-          "ClosedCaptioningManager: There was a change in the CC state",
-          { isCCEnabled }
-        );
+        log_debug("CC state changed", { isCCEnabled });
 
         sessionStorage.setItem(
           PLATFORM_KEYS.deviceClosedCaptioningEnabled,
           isCCEnabled
         );
 
-        log_debug(
-          "ClosedCaptioningManager: Saved CC state to session storage",
-          { isCCEnabled }
-        );
-
         this.ccState$.next(isCCEnabled);
       });
-    } else {
-      log_debug(
-        "ClosedCaptioningManager: Vizio APIs are not available, skipping setup"
-      );
     }
   }
 

package/appUtils/playerManager/player.ts

@@ -154,8 +154,8 @@ export class Player {
     this.isSeeking()
       ? this.playerState.seekPosition
       : this.playerState.adState
-        ? this.playerState.adState.adPosition
-        : this.playerState.contentPosition;
+      ? this.playerState.adState.adPosition
+      : this.playerState.contentPosition;
 
   getEntry = (): ZappEntry | null => this.entry;
 

package/idleUtils/index.ts

@@ -1,4 +1,4 @@
-export { withTimeout, withTimeout$ } from "./withTimeout";
+export { withTimeout } from "./withTimeout";
 
 export { onIdle } from "./onIdle";
 

package/idleUtils/withTimeout.ts

@@ -1,20 +1,7 @@
-import { of, Observable } from "rxjs";
-import { delay } from "rxjs/operators";
-
-export const withTimeout = (timeout: number): Promise<void> => {
-  return new Promise<void>((resolve) => {
+export const withTimeout = (timeout: number) => {
+  return new Promise((resolve) => {
     setTimeout(() => {
       resolve(undefined);
     }, timeout);
   });
 };
-
-/**
- * Creates an observable that emits a single value after a specified timeout.
- *
- * @param timeout - The delay duration in milliseconds before emitting the value.
- * @returns An observable that emits `undefined` after the specified timeout.
- */
-export const withTimeout$ = (timeout: number): Observable<void> => {
-  return of(undefined).pipe(delay(timeout));
-};

package/manifestUtils/__tests__/createConfig.test.js

@@ -78,6 +78,8 @@ describe("createConfig", () => {
       extend: "styles",
     })(props);
 
+    console.log(mockGenerators.styles.mock.calls);
+
     expect(mockGenerators.styles).toBeCalledWith(props);
   });
 

package/manifestUtils/sharedConfiguration/screenPicker/__tests__/utils.test.js

@@ -0,0 +1,304 @@
+// @ts-nocheck
+import utils from "../utils";
+
+describe("generateFontConfiguration", () => {
+  it("should generate default configuration for tvos", () => {
+    const expected = [
+      {
+        initial_value: 20,
+        label: "tvOS font Size",
+        key: "tvos_font_size",
+        type: "number_input",
+      },
+      {
+        initial_value: 40,
+        label: "tvOS line Height",
+        key: "tvos_line_height",
+        type: "number_input",
+      },
+      {
+        initial_value: 0.4,
+        label: "tvOS letter Spacing",
+        key: "tvos_letter_spacing",
+        type: "number_input",
+      },
+    ];
+
+    const platforms = {
+      tvos: "tvOS",
+    };
+
+    const generatedFontConfiguration =
+      utils.generateFontConfiguration(platforms);
+
+    expect(generatedFontConfiguration).toEqual(expected);
+  });
+
+  it("should generate default configuration for android_tv", () => {
+    const expected = [
+      {
+        initial_value: 20,
+        label: "Android TV font Size",
+        key: "android_tv_font_size",
+        type: "number_input",
+      },
+      {
+        initial_value: 40,
+        label: "Android TV line Height",
+        key: "android_tv_line_height",
+        type: "number_input",
+      },
+      {
+        initial_value: 0.4,
+        label: "Android TV letter Spacing",
+        key: "android_tv_letter_spacing",
+        type: "number_input",
+      },
+    ];
+
+    const platforms = {
+      android_tv: "Android TV",
+    };
+
+    const generatedFontConfiguration =
+      utils.generateFontConfiguration(platforms);
+
+    expect(generatedFontConfiguration).toEqual(expected);
+  });
+
+  it("should generate default configuration for lg_tv", () => {
+    const expected = [
+      {
+        initial_value: 20,
+        label: "LG TV font Size",
+        key: "lg_tv_font_size",
+        type: "number_input",
+      },
+      {
+        initial_value: 40,
+        label: "LG TV line Height",
+        key: "lg_tv_line_height",
+        type: "number_input",
+      },
+      {
+        initial_value: 0.4,
+        label: "LG TV letter Spacing",
+        key: "lg_tv_letter_spacing",
+        type: "number_input",
+      },
+    ];
+
+    const platforms = {
+      lg_tv: "LG TV",
+    };
+
+    const generatedFontConfiguration =
+      utils.generateFontConfiguration(platforms);
+
+    expect(generatedFontConfiguration).toEqual(expected);
+  });
+
+  it("should generate default configuration for samsung_tv", () => {
+    const expected = [
+      {
+        initial_value: 20,
+        label: "Samsung TV font Size",
+        key: "samsung_tv_font_size",
+        type: "number_input",
+      },
+      {
+        initial_value: 40,
+        label: "Samsung TV line Height",
+        key: "samsung_tv_line_height",
+        type: "number_input",
+      },
+      {
+        initial_value: 0.4,
+        label: "Samsung TV letter Spacing",
+        key: "samsung_tv_letter_spacing",
+        type: "number_input",
+      },
+    ];
+
+    const platforms = {
+      samsung_tv: "Samsung TV",
+    };
+
+    const generatedFontConfiguration =
+      utils.generateFontConfiguration(platforms);
+
+    expect(generatedFontConfiguration).toEqual(expected);
+  });
+});
+
+test("conditional_rule helper should return correct object", () => {
+  expect(utils.conditional_rule("a", "b")).toMatchObject({
+    key: "a",
+    condition_value: "b",
+  });
+});
+
+test("createConditionalConfig helper should return correct object", () => {
+  expect(
+    utils.createConditionalConfig([
+      ["a", "b"],
+      ["c", "d"],
+    ])
+  ).toEqual({
+    rules: "conditional",
+    conditional_fields: [
+      {
+        key: "a",
+        condition_value: "b",
+      },
+      {
+        key: "c",
+        condition_value: "d",
+      },
+    ],
+  });
+});
+
+test("conditional_horizontal_type should contain correct parameters", () => {
+  expect(
+    utils.conditional_horizontal_type_item_fixed.conditional_fields[0]
+  ).toMatchObject({
+    key: "styles/screen_picker_type",
+    condition_value: "horizontal",
+  });
+});
+
+test("conditional_vertical_type should contain correct parameters", () => {
+  expect(utils.conditional_vertical_type.conditional_fields[0]).toMatchObject({
+    key: "styles/screen_picker_type",
+    condition_value: "vertical",
+  });
+});
+
+test("conditional_horizontal_type_item_fixed should contain correct parameters", () => {
+  expect(
+    utils.conditional_horizontal_type_item_fixed.conditional_fields[0]
+  ).toMatchObject({
+    key: "styles/screen_picker_type",
+    condition_value: "horizontal",
+  });
+
+  expect(
+    utils.conditional_horizontal_type_item_fixed.conditional_fields[1]
+  ).toMatchObject({
+    key: "styles/screen_picker_item_size",
+    condition_value: "fixed",
+  });
+});
+
+test("conditional_horizontal_display_type_fixed should contain correct parameters", () => {
+  expect(
+    utils.conditional_horizontal_display_type_fixed.conditional_fields[0]
+  ).toMatchObject({
+    key: "styles/screen_picker_type",
+    condition_value: "horizontal",
+  });
+
+  expect(
+    utils.conditional_horizontal_display_type_fixed.conditional_fields[1]
+  ).toMatchObject({
+    key: "styles/screen_picker_horizontal_display_type",
+    condition_value: "fixed",
+  });
+});
+
+test("conditional_horizontal_display_type_fixed should contain correct parameters", () => {
+  expect(
+    utils.conditional_horizontal_asset_on.conditional_fields[0]
+  ).toMatchObject({
+    key: "styles/screen_picker_type",
+    condition_value: "horizontal",
+  });
+
+  expect(
+    utils.conditional_horizontal_asset_on.conditional_fields[1]
+  ).toMatchObject({
+    key: "styles/screen_picker_asset_switch",
+    condition_value: true,
+  });
+});
+
+describe("createVariationFields", () => {
+  const defaultInput = {
+    key: "somekey",
+    label: "default somekey label",
+    variants: [
+      {
+        initial_value: "a",
+      },
+      {
+        initial_value: "b",
+        label: "custom label",
+      },
+    ],
+  };
+
+  const config = utils.createVariationFields(defaultInput);
+
+  it("should return array containing object for conditional_vertical_type", () => {
+    expect(config[0].rules).toBe("conditional");
+
+    expect(config[0].conditional_fields).toEqual([
+      {
+        key: "styles/screen_picker_type",
+        condition_value: "vertical",
+      },
+    ]);
+
+    expect(config[0].type).toBe("number_input");
+    expect(config[0].key).toBe("screen_picker_vertical_somekey");
+    expect(config[0].label).toBe("default somekey label");
+    expect(config[0].initial_value).toBe("a");
+  });
+
+  it("should return array containing object for conditional_horizontal_type", () => {
+    expect(config[1].rules).toBe("conditional");
+
+    expect(config[1].conditional_fields).toEqual([
+      {
+        key: "styles/screen_picker_type",
+        condition_value: "horizontal",
+      },
+    ]);
+
+    expect(config[1].type).toBe("number_input");
+    expect(config[1].key).toBe("screen_picker_horizontal_somekey");
+    expect(config[1].label).toBe("custom label");
+    expect(config[1].initial_value).toBe("b");
+  });
+
+  it("should accept custom prefix (empty)", () => {
+    const config = utils.createVariationFields({
+      ...defaultInput,
+      prefix: "",
+    });
+
+    expect(config[0].key).toBe("vertical_somekey");
+    expect(config[1].key).toBe("horizontal_somekey");
+  });
+
+  it("should accept custom prefix (string)", () => {
+    const config = utils.createVariationFields({
+      ...defaultInput,
+      prefix: "string",
+    });
+
+    expect(config[0].key).toBe("string_vertical_somekey");
+    expect(config[1].key).toBe("string_horizontal_somekey");
+  });
+
+  it("should accept custom type (string)", () => {
+    const config = utils.createVariationFields({
+      ...defaultInput,
+      type: "text_input",
+    });
+
+    expect(config[0].type).toBe("text_input");
+    expect(config[1].type).toBe("text_input");
+  });
+});