@applicaster/zapp-react-native-utils 15.0.0-alpha.3752284136 → 15.0.0-alpha.4057265013

package/errorUtils/__tests__/getParsedResponse.test.ts

@@ -0,0 +1,188 @@
+import { getParsedResponse } from "../index";
+import { RESPONSES } from "../errorCodes";
+
+describe("getParsedResponse", () => {
+  it("should parse error with response status code from response.data", () => {
+    const err = {
+      response: {
+        data: {
+          statusCode: 404,
+          message: "Resource not found",
+        },
+        config: {
+          url: "https://api.example.com/data",
+          params: { id: 123 },
+        },
+      },
+      name: "AxiosError",
+      context: { userId: "user123" },
+    };
+
+    const result = getParsedResponse(err);
+
+    expect(result.message).toBe("Error: Resource not found");
+    expect(result.data.statusCode).toBe("404");
+    expect(result.data.url).toBe("https://api.example.com/data");
+    expect(result.data.params).toEqual({ id: 123 });
+    expect(result.data.context).toEqual({ userId: "user123" });
+    expect(result.data.name).toBe("AxiosError");
+    expect(result.jsOnly).toBe(false);
+    expect(result.exception).toBe(result.message);
+  });
+
+  it("should parse error with response status code from response.status", () => {
+    const err = {
+      response: {
+        status: 500,
+        config: {
+          url: "https://api.example.com/data",
+        },
+      },
+    };
+
+    const result = getParsedResponse(err);
+
+    expect(result.message).toBe(`Error: ${RESPONSES[500]}`);
+    expect(result.data.statusCode).toBe("500");
+  });
+
+  it("should handle error with request but no response", () => {
+    const err = {
+      request: {},
+      message: "Network timeout",
+      config: {
+        url: "https://api.example.com/data",
+        params: { test: "value" },
+      },
+      name: "NetworkError",
+      context: { app: "test" },
+    };
+
+    const result = getParsedResponse(err);
+
+    expect(result.message).toBe("Error: Network timeout");
+    expect(result.data.url).toBe("https://api.example.com/data");
+    expect(result.data.params).toEqual({ test: "value" });
+    expect(result.data.name).toBe("NetworkError");
+    expect(result.data.context).toEqual({ app: "test" });
+    expect(result.jsOnly).toBe(false);
+  });
+
+  it("should handle error with request but no response and no message", () => {
+    const err = {
+      request: {},
+      config: {
+        url: "https://api.example.com/data",
+      },
+    };
+
+    const result = getParsedResponse(err);
+
+    expect(result.message).toBe(`Error: ${RESPONSES.noResponse}`);
+  });
+
+  it("should handle error with neither response nor request", () => {
+    const err = {
+      message: "Failed to set up request",
+      config: {
+        url: "https://api.example.com/data",
+      },
+    };
+
+    const result = getParsedResponse(err);
+
+    expect(result.message).toBe("Error: Failed to set up request");
+  });
+
+  it("should handle error with neither response nor request and no message", () => {
+    const err = {
+      config: {
+        url: "https://api.example.com/data",
+      },
+    };
+
+    const result = getParsedResponse(err);
+
+    expect(result.message).toBe(`Error: ${RESPONSES.unknown}`);
+  });
+
+  it("should handle null error", () => {
+    const err = null;
+
+    const result = getParsedResponse(err);
+
+    expect(result.message).toBe(`Error: ${RESPONSES.unknown}`);
+
+    expect(result.data).toEqual({
+      context: undefined,
+      name: undefined,
+      params: undefined,
+      url: undefined,
+    });
+  });
+
+  it("should handle undefined error", () => {
+    const err = undefined;
+
+    const result = getParsedResponse(err);
+
+    expect(result.message).toBe(`Error: ${RESPONSES.unknown}`);
+  });
+
+  it("should extract params from err.config when response is not present", () => {
+    const err = {
+      request: {},
+      message: "Request failed",
+      config: {
+        url: "https://api.example.com/data",
+        params: { key: "value" },
+      },
+    };
+
+    const result = getParsedResponse(err);
+
+    expect(result.data.params).toEqual({ key: "value" });
+    expect(result.data.url).toBe("https://api.example.com/data");
+  });
+
+  it("should prioritize response config over error config", () => {
+    const err = {
+      response: {
+        status: 404,
+        config: {
+          url: "https://api.example.com/response-url",
+          params: { from: "response" },
+        },
+      },
+      config: {
+        url: "https://api.example.com/error-url",
+        params: { from: "error" },
+      },
+    };
+
+    const result = getParsedResponse(err);
+
+    expect(result.data.url).toBe("https://api.example.com/response-url");
+    expect(result.data.params).toEqual({ from: "response" });
+  });
+
+  it("should handle response with custom status codes", () => {
+    const err = {
+      response: {
+        data: {
+          statusCode: 418,
+          message: "I'm a teapot",
+        },
+        status: 418,
+        config: {
+          url: "https://api.example.com/coffee",
+        },
+      },
+    };
+
+    const result = getParsedResponse(err);
+
+    expect(result.message).toBe("Error: I'm a teapot");
+    expect(result.data.statusCode).toBe("418");
+  });
+});

package/errorUtils/__tests__/invariant.test.ts

@@ -0,0 +1,112 @@
+import { invariant } from "../index";
+
+// Mock __DEV__ global
+declare global {
+  var __DEV__: boolean;
+}
+
+describe("invariant", () => {
+  const originalDev = global.__DEV__;
+
+  afterEach(() => {
+    global.__DEV__ = originalDev;
+  });
+
+  describe("in development mode", () => {
+    beforeEach(() => {
+      global.__DEV__ = true;
+    });
+
+    it("should not throw when condition is true", () => {
+      expect(() => {
+        invariant(true, "This should not throw");
+      }).not.toThrow();
+    });
+
+    it("should throw when condition is false", () => {
+      expect(() => {
+        invariant(false, "This should throw");
+      }).toThrow("This should throw");
+    });
+
+    it("should throw with correct error message", () => {
+      const errorMessage = "Custom error message";
+
+      expect(() => {
+        invariant(false, errorMessage);
+      }).toThrow(errorMessage);
+    });
+
+    it("should not throw when condition is truthy value", () => {
+      expect(() => {
+        invariant(1 as any, "Should not throw");
+      }).not.toThrow();
+
+      expect(() => {
+        invariant("string" as any, "Should not throw");
+      }).not.toThrow();
+
+      expect(() => {
+        invariant({} as any, "Should not throw");
+      }).not.toThrow();
+
+      expect(() => {
+        invariant([] as any, "Should not throw");
+      }).not.toThrow();
+    });
+
+    it("should throw when condition is falsy value", () => {
+      expect(() => {
+        invariant(0 as any, "Should throw for 0");
+      }).toThrow("Should throw for 0");
+
+      expect(() => {
+        invariant("" as any, "Should throw for empty string");
+      }).toThrow("Should throw for empty string");
+
+      expect(() => {
+        invariant(null as any, "Should throw for null");
+      }).toThrow("Should throw for null");
+
+      expect(() => {
+        invariant(undefined as any, "Should throw for undefined");
+      }).toThrow("Should throw for undefined");
+
+      expect(() => {
+        invariant(NaN as any, "Should throw for NaN");
+      }).toThrow("Should throw for NaN");
+    });
+  });
+
+  describe("in production mode", () => {
+    beforeEach(() => {
+      global.__DEV__ = false;
+    });
+
+    it("should not throw when condition is true", () => {
+      expect(() => {
+        invariant(true, "This should not throw");
+      }).not.toThrow();
+    });
+
+    it("should not throw when condition is false", () => {
+      expect(() => {
+        invariant(false, "This should not throw in production");
+      }).not.toThrow();
+    });
+
+    it("should not throw for any condition", () => {
+      expect(() => {
+        invariant(0 as any, "Should not throw in production");
+      }).not.toThrow();
+
+      expect(() => {
+        invariant(null as any, "Should not throw in production");
+      }).not.toThrow();
+
+      expect(() => {
+        invariant(undefined as any, "Should not throw in production");
+      }).not.toThrow();
+    });
+  });
+});

package/headersUtils/__tests__/headersUtils.test.js

@@ -1,6 +1,15 @@
 import { appStore } from "@applicaster/zapp-react-native-redux/AppStore";
 import { getAppDataHeaders } from "../index";
 
+const mockUILanguage = "en-US";
+
+jest.mock(
+  "@applicaster/zapp-react-native-utils/appUtils/localizationsHelper",
+  () => ({
+    getUILanguage: jest.fn(() => mockUILanguage),
+  })
+);
+
 describe("getAppDataHeaders", () => {
   const mockAppData = {
     riversConfigurationId: "test-layout",
@@ -25,7 +34,7 @@ describe("getAppDataHeaders", () => {
     const expectedHeaders = {
       "x-applicaster-layout-id": mockAppData.riversConfigurationId,
       "x-applicaster-screen-id": screenId,
-      "x-applicaster-language-code": mockAppData.languageCode,
+      "x-applicaster-language-code": mockUILanguage,
       "x-applicaster-version-number": mockAppData.version_name,
       "x-applicaster-platform": mockAppData.platform,
       "x-applicaster-country-code": mockAppData.countryCode,
@@ -33,6 +42,7 @@ describe("getAppDataHeaders", () => {
         mockAppData.signedDeviceInfoToken,
       "x-applicaster-device-make": mockAppData.deviceMake,
       "x-applicaster-device-model": mockAppData.deviceModel,
+      "x-applicaster-uuid": undefined,
     };
 
     const headers = getAppDataHeaders(screenId);

package/headersUtils/index.ts

@@ -1,6 +1,7 @@
 import { appStore } from "@applicaster/zapp-react-native-redux/AppStore";
 import { getPlatform } from "@applicaster/zapp-react-native-utils/reactUtils";
 import { utilsLogger } from "../logger";
+import { getUILanguage } from "../localizationUtils";
 
 const logger = utilsLogger.addSubsystem("headersUtils");
 
@@ -21,7 +22,7 @@ export const getAppDataHeaders = (screenId: string) => {
     "x-applicaster-layout-id":
       appData.riversConfigurationId || appData.rivers_configuration_id,
     "x-applicaster-screen-id": screenId,
-    "x-applicaster-language-code": appData.languageCode,
+    "x-applicaster-language-code": getUILanguage(),
     "x-applicaster-version-number": appData.version_name || appData.versionName,
     "x-applicaster-platform": (platform || appData.platform).toLowerCase(),
     "x-applicaster-country-code": appData.countryCode,

package/manifestUtils/defaultManifestConfigurations/player.js

@@ -331,6 +331,35 @@ function getPlayerConfiguration({ platform, version }) {
         label_tooltip: "Hint for skip intro button accessibility",
         type: "text_input",
       },
+      {
+        type: "text_input",
+        label: "Text Tracks Label",
+        key: "text_tracks_label",
+        initial_value: "Subtitles",
+        label_tooltip: "Label for the text tracks list",
+      },
+      {
+        type: "text_input",
+        label: "Audio Tracks Label",
+        key: "audio_tracks_label",
+        initial_value: "Audio",
+        label_tooltip: "Label for the audio tracks list",
+      },
+      {
+        type: "text_input",
+        label: "Off Track Label",
+        key: "off_track_label",
+        initial_value: "Off",
+        label_tooltip: "Label for the 'Off' option in text tracks list",
+      },
+      {
+        type: "text_input",
+        label: "Default Track Label",
+        key: "default_track_label",
+        initial_value: "Default",
+        label_tooltip:
+          "Label for the 'Default' audio track in audio tracks list",
+      },
     ],
   };
 
@@ -678,22 +707,6 @@ function getPlayerConfiguration({ platform, version }) {
   }
 
   if (isMobile(platform)) {
-    localizations.fields.push(
-      {
-        type: "text_input",
-        label: "Restrict playback on mobile networks alert title",
-        key: "mobile_connection_restricted_alert_title",
-        initial_value: "Restricted Connection Type",
-      },
-      {
-        type: "text_input",
-        label: "Restrict playback on mobile networks alert message",
-        key: "mobile_connection_restricted_alert_message",
-        initial_value:
-          "This content can only be viewed over a Wi-Fi or LAN network.",
-      }
-    );
-
     general.fields.push(
       {
         section: "Default Timestamp Type",

package/manifestUtils/platformIsTV.js

@@ -0,0 +1,13 @@
+function platformIsTV(platform) {
+  return [
+    "tvos_for_quickbrick",
+    "android_tv_for_quickbrick",
+    "amazon_fire_tv_for_quickbrick",
+    "lg_tv",
+    "samsung_tv",
+    "web",
+    "vizio",
+  ].includes(platform);
+}
+
+module.exports = { platformIsTV };

package/navigationUtils/index.ts

@@ -5,7 +5,8 @@ import { layoutV2TypeMatcher } from "./layoutV2TypeMatcher";
 import { HOOKS_EVENTS } from "../appUtils/HooksManager/constants";
 import { HooksManager } from "../appUtils/HooksManager";
 import { appStore } from "@applicaster/zapp-react-native-redux/AppStore";
-import { HookModalContextT } from "@applicaster/zapp-react-native-ui-components/Contexts/ZappHookModalContext";
+
+import { zappHookModalStore } from "@applicaster/zapp-react-native-ui-components/Contexts/ZappHookModalContext";
 import { logger } from "@applicaster/zapp-react-native-utils/logger";
 import {
   isGeneralPlugin,
@@ -15,6 +16,8 @@ import {
 } from "./itemTypeMatchers";
 import { RootState } from "@applicaster/zapp-react-native-redux/store";
 
+import { pick } from "@applicaster/zapp-react-native-utils/utils";
+
 type PathAttribute = {
   screenType: string;
   screenId: string;
@@ -403,15 +406,22 @@ export const mapContentTypesToRivers = (
 };
 
 export const runZappHooksForEntry = async (
-  entry: HookPluginProps["payload"],
-  {
+  entry: HookPluginProps["payload"]
+): Promise<{ success: boolean; payload: ZappEntry }> => {
+  const {
     setState,
     resetState,
     setIsHooksExecutionInProgress,
     setIsPresentingFullScreen,
     setIsRunningInBackground,
-  }: Partial<HookModalContextT>
-): Promise<{ success: boolean; payload: ZappEntry }> => {
+  } = pick(zappHookModalStore.getState(), [
+    "setState",
+    "resetState",
+    "setIsHooksExecutionInProgress",
+    "setIsPresentingFullScreen",
+    "setIsRunningInBackground",
+  ]);
+
   resetState?.();
 
   let success;

package/numberUtils/__tests__/toNumber.test.ts

@@ -41,4 +41,29 @@ describe("toNumber", () => {
       expect(output).toBeUndefined();
     });
   });
+
+  describe("BigInt support", () => {
+    // Conditional test based on BigInt availability
+    const isBigIntSupported = typeof BigInt !== "undefined";
+
+    if (isBigIntSupported) {
+      it("converts BigInt to number when BigInt is supported", () => {
+        expect(toNumber(BigInt(5))).toBe(5);
+        expect(toNumber(BigInt(0))).toBe(0);
+        expect(toNumber(BigInt(-10))).toBe(-10);
+        expect(toNumber(BigInt(1000))).toBe(1000);
+      });
+
+      it("handles large BigInt values that may lose precision", () => {
+        const largeBigInt = BigInt(Number.MAX_SAFE_INTEGER) + BigInt(1);
+        const result = toNumber(largeBigInt);
+        expect(result).toBe(Number(largeBigInt));
+      });
+    } else {
+      it("skips BigInt tests when BigInt is not supported", () => {
+        // Placeholder test to indicate BigInt is not available
+        expect(typeof BigInt).toBe("undefined");
+      });
+    }
+  });
 });

package/numberUtils/__tests__/toPositiveNumber.test.ts

@@ -0,0 +1,193 @@
+import { toPositiveNumber } from "..";
+
+describe("toPositiveNumber", () => {
+  describe("valid positive numbers", () => {
+    it("returns the number for positive integers", () => {
+      expect(toPositiveNumber(5)).toBe(5);
+      expect(toPositiveNumber(1000)).toBe(1000);
+    });
+
+    it("returns the number for positive floats", () => {
+      expect(toPositiveNumber(0.1)).toBe(0.1);
+      expect(toPositiveNumber(3.14159)).toBe(3.14159);
+    });
+
+    it("returns the number for very small positive numbers", () => {
+      expect(toPositiveNumber(1e-300)).toBe(1e-300);
+    });
+
+    it("returns the number for very large positive numbers", () => {
+      expect(toPositiveNumber(1e300)).toBe(1e300);
+    });
+
+    it("returns Infinity for positive infinity", () => {
+      expect(toPositiveNumber(Infinity)).toBe(Infinity);
+    });
+
+    it("converts valid positive strings to numbers", () => {
+      expect(toPositiveNumber("5")).toBe(5);
+      expect(toPositiveNumber("3.14")).toBe(3.14);
+      expect(toPositiveNumber("  100  ")).toBe(100);
+    });
+
+    it("converts boolean true to undefined", () => {
+      expect(toPositiveNumber(true)).toBeUndefined();
+    });
+
+    it("converts single-element arrays to undefined", () => {
+      expect(toPositiveNumber([5])).toBeUndefined();
+      expect(toPositiveNumber(["10"])).toBeUndefined();
+    });
+  });
+
+  describe("invalid cases (return undefined)", () => {
+    describe("zero values", () => {
+      it("returns undefined for zero", () => {
+        expect(toPositiveNumber(0)).toBeUndefined();
+        expect(toPositiveNumber(-0)).toBeUndefined();
+      });
+
+      it("returns undefined for string zero", () => {
+        expect(toPositiveNumber("0")).toBeUndefined();
+        expect(toPositiveNumber("  0  ")).toBeUndefined();
+      });
+
+      it("returns undefined for boolean false", () => {
+        expect(toPositiveNumber(false)).toBeUndefined();
+      });
+
+      it("returns undefined for empty arrays", () => {
+        expect(toPositiveNumber([])).toBeUndefined();
+      });
+
+      it("returns undefined for empty strings", () => {
+        expect(toPositiveNumber("")).toBeUndefined();
+        expect(toPositiveNumber("   ")).toBeUndefined();
+      });
+    });
+
+    describe("negative values", () => {
+      it("returns undefined for negative numbers", () => {
+        expect(toPositiveNumber(-5)).toBeUndefined();
+        expect(toPositiveNumber(-0.1)).toBeUndefined();
+      });
+
+      it("returns undefined for negative strings", () => {
+        expect(toPositiveNumber("-5")).toBeUndefined();
+        expect(toPositiveNumber(" -10 ")).toBeUndefined();
+      });
+
+      it("returns undefined for negative infinity", () => {
+        expect(toPositiveNumber(-Infinity)).toBeUndefined();
+      });
+    });
+
+    describe("non-convertible values", () => {
+      it("returns undefined for null", () => {
+        expect(toPositiveNumber(null)).toBeUndefined();
+      });
+
+      it("returns undefined for undefined", () => {
+        expect(toPositiveNumber(undefined)).toBeUndefined();
+      });
+
+      it("returns undefined for objects", () => {
+        expect(toPositiveNumber({})).toBeUndefined();
+        expect(toPositiveNumber({ a: 1 })).toBeUndefined();
+      });
+
+      it("returns undefined for multi-element arrays", () => {
+        expect(toPositiveNumber([1, 2])).toBeUndefined();
+        expect(toPositiveNumber(["a", "b"])).toBeUndefined();
+      });
+
+      it("returns undefined for non-numeric strings", () => {
+        expect(toPositiveNumber("abc")).toBeUndefined();
+        expect(toPositiveNumber("5px")).toBeUndefined();
+        expect(toPositiveNumber("123.45.67")).toBeUndefined();
+      });
+
+      it("returns undefined for NaN", () => {
+        expect(toPositiveNumber(NaN)).toBeUndefined();
+        expect(toPositiveNumber(Number("abc"))).toBeUndefined();
+      });
+    });
+  });
+
+  describe("special cases", () => {
+    it("handles exponential notation correctly", () => {
+      expect(toPositiveNumber("1e5")).toBe(100000);
+      expect(toPositiveNumber("1e-5")).toBe(0.00001);
+      expect(toPositiveNumber("-1e5")).toBeUndefined();
+    });
+
+    it("preserves precision for decimal numbers", () => {
+      expect(toPositiveNumber(0.1 + 0.2)).toBeCloseTo(0.3);
+      expect(toPositiveNumber("0.1")).toBe(0.1);
+    });
+
+    it("handles numeric strings with leading zeros", () => {
+      expect(toPositiveNumber("005")).toBe(5);
+      expect(toPositiveNumber("0.5")).toBe(0.5);
+    });
+
+    it("returns undefined for numeric strings with trailing non-numeric characters", () => {
+      expect(toPositiveNumber("5px")).toBeUndefined();
+      expect(toPositiveNumber("10%")).toBeUndefined();
+    });
+
+    it("handles scientific notation correctly", () => {
+      expect(toPositiveNumber("1.5e2")).toBe(150);
+      expect(toPositiveNumber("-2.5e3")).toBeUndefined();
+    });
+  });
+
+  describe("type conversion behavior", () => {
+    it("converts Date objects correctly", () => {
+      const date = new Date(2026, 1, 17);
+      expect(toPositiveNumber(date)).toBeUndefined();
+    });
+
+    it("converts functions to NaN (returns undefined)", () => {
+      expect(toPositiveNumber(() => {})).toBeUndefined();
+      expect(toPositiveNumber(Math.sqrt)).toBeUndefined();
+    });
+
+    it("handles Symbol values", () => {
+      expect(toPositiveNumber(Symbol("test"))).toBeUndefined();
+    });
+  });
+
+  describe("BigInt support", () => {
+    // Conditional test based on BigInt availability
+    const isBigIntSupported = typeof BigInt !== "undefined";
+
+    if (isBigIntSupported) {
+      it("converts positive BigInt values to numbers when BigInt is supported", () => {
+        expect(toPositiveNumber(BigInt(5))).toBe(5);
+        expect(toPositiveNumber(BigInt(100))).toBe(100);
+        expect(toPositiveNumber(BigInt(1000))).toBe(1000);
+      });
+
+      it("returns undefined for zero BigInt", () => {
+        expect(toPositiveNumber(BigInt(0))).toBeUndefined();
+      });
+
+      it("returns undefined for negative BigInt values", () => {
+        expect(toPositiveNumber(BigInt(-5))).toBeUndefined();
+        expect(toPositiveNumber(BigInt(-100))).toBeUndefined();
+      });
+
+      it("handles large positive BigInt values", () => {
+        const largeBigInt = BigInt(Number.MAX_SAFE_INTEGER);
+        const result = toPositiveNumber(largeBigInt);
+        expect(result).toBe(Number(largeBigInt));
+      });
+    } else {
+      it("skips BigInt tests when BigInt is not supported", () => {
+        // Placeholder test to indicate BigInt is not available
+        expect(typeof BigInt).toBe("undefined");
+      });
+    }
+  });
+});