@applicaster/zapp-react-native-utils 13.0.0-alpha.4454978740 → 13.0.0-alpha.4514355105

package/functionUtils/index.ts

@@ -1,5 +1,5 @@
 import * as R from "ramda";
-import { useRef } from "react";
+import { useCallback, useEffect, useRef } from "react";
 
 /**
  *
@@ -9,31 +9,44 @@ import { useRef } from "react";
  */
 export const useThrottle = (callback: () => void, delay: number) => {
   const lastCallRef = useRef<number>(0);
-  const timeoutRef = useRef<any | null>(null);
+  const timeoutRef = useRef<NodeJS.Timeout | null>(null);
+  const callbackRef = useRef<() => void>(callback);
 
-  const throttledFunction = () => {
+  useEffect(() => {
+    callbackRef.current = callback;
+  }, [callback]);
+
+  const throttledFunction = useCallback(() => {
     const now = Date.now();
 
     if (now - lastCallRef.current >= delay) {
-      callback();
+      callbackRef.current();
       lastCallRef.current = now;
     } else if (!timeoutRef.current) {
       const remainingTime = delay - (now - lastCallRef.current);
 
       timeoutRef.current = setTimeout(() => {
-        callback();
+        callbackRef.current();
         lastCallRef.current = Date.now();
         timeoutRef.current = null;
       }, remainingTime);
     }
-  };
+  }, [delay]);
 
-  const cancel = () => {
+  const cancel = useCallback(() => {
     if (timeoutRef.current) {
       clearTimeout(timeoutRef.current);
       timeoutRef.current = null;
     }
-  };
+  }, []);
+
+  useEffect(() => {
+    return () => {
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+    };
+  }, []);
 
   return { throttledFunction, cancel };
 };

package/manifestUtils/defaultManifestConfigurations/player.js

@@ -50,6 +50,14 @@ function getPlayerConfiguration({ platform }) {
         label_tooltip:
           "Set the query params which control the size of the image e.g width, height. This will help to optimize the loading time, when magic background is enabled.",
       },
+      {
+        key: "audio_player_background_image_default_color",
+        label: "Audio Player Background Image Default Color",
+        initial_value: "",
+        type: "text_input",
+        label_tooltip:
+          "Set the default color for the audio player background image if not image or set of gradient colors are not provided.",
+      },
     ],
   };
 

package/manifestUtils/fonts/index.js

@@ -224,12 +224,11 @@ function fontKey(label, defaults, conditionalField = null) {
   return fields;
 }
 
-function tvMenuLabel(label, description, defaults) {
-  return fieldsGroup(
-    label,
-    description,
-    generateFieldsFromDefaults(label, defaults, TV_MENU_LABEL_FIELDS)
-  );
+function tvMenuLabel(label, description, defaults, fields = []) {
+  return fieldsGroup(label, description, [
+    ...fields,
+    ...generateFieldsFromDefaults(label, defaults, TV_MENU_LABEL_FIELDS),
+  ]);
 }
 
 function mobileCellLabel(label, description, defaults, groupFolded) {

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");
+  });
+});