@applicaster/zapp-react-native-utils 15.0.0-alpha.8680244503 → 15.0.0-alpha.9102777840

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/focusManager/aux/index.ts

@@ -49,7 +49,7 @@ export const findSelectedMenuId = (
 ) => {
   const sectionName = QUICK_BRICK_NAVBAR_SECTIONS[sectionKey];
 
-  return pathOr(
+  return pathOr<string | undefined>(
     undefined,
     ["children", index, "id"],
     focusableTree.find(sectionName)

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

@@ -123,6 +123,12 @@ function getPlayerConfiguration({ platform, version }) {
         key: "skip_button_localization_text_skip_intro",
         initial_value: "Skip Intro",
       },
+      {
+        type: "text_input",
+        label: "Stream error message",
+        key: "stream_error_message",
+        initial_value: "Cannot play stream",
+      },
       {
         type: "text_input",
         label: "Locked message",
@@ -331,6 +337,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",
+      },
     ],
   };
 
@@ -1200,40 +1235,35 @@ function getPlayerConfiguration({ platform, version }) {
             label: "Playback Speed 0.8x",
             type: "uploader",
             label_tooltip: "Playback Speed 0.8x",
-            initial_value:
-              "data:image/png;base64,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",
+            initial_value: null,
           },
           {
             key: "speed_1",
             label: "Playback Speed 1x",
             type: "uploader",
             label_tooltip: "Playback Speed 1x",
-            initial_value:
-              "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAHgAAAB4CAYAAAA5ZDbSAAAACXBIWXMAACE4AAAhOAFFljFgAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAI4SURBVHgB7dzhcRJBGIDhT8cCkg6SDmIHsQNLiBUYKwAqUCtIC5ZACVqBdIAdxN3JMSLecXcE8Tt5npkdJlxyf97ZcLcLRAAAAAAAAAAAAAAAAAAAAAAAAADAMb2IiViv17fl4aGMq45fub68vFwFv3kVyZWwF+VhVsZ9MFrqwANmLT1SBm5mbQ37NniWl5FMifu+PHwPcY8izQwuYa/iadbeBkeTaQbfxf64P8r4GoyS7l90h89lXJfxLRgl+23Sqox35f52WX8o/8aDcTLP4EUZrzdxOUzGGbws40MJ6/X2CDIFrhdRNeyn4GjSBBb275jKVTQHEvg/d/aB69Lo+sljGR/jADvnmEUiZx242a2qr/0XzVP35bmHkeeY7Zxj3pw3hXOfwTctz90NjdzEnbccuo0kzj1w1712b+Q9cfed9+TOOnCzSrboONwZuSfuopz3SyRx9hdZJcY8RkQeELfr2D/hNimGR55a3Cr9m+5OpcZpdqvabnNq5HpBdtPx5ynjVmbwlp6ZPLm4lcA7eiLvSh23ErjFwMjp41YCd3t85vEUBG7Rc7W8Mc+27txG4B0D426kjyzwlp64y47nU0cWuDFgEeNNdF94pY0scAxfoeq5uk4Z2Yb/yOXHqUW24X/A2vKAyGk+OGfDv13vIsaBy5onZ8P/T4NXqPZEtuGfwdaG/yp+vfF+HiNsRV5tnSPNhv9kvoSlaj75f9F2zBewAAAAAAAAAAAAAAAAAAAAAAAAwHT8BNhH51wNSx95AAAAAElFTkSuQmCC",
+            initial_value: null,
           },
           {
             key: "speed_1_2",
             label: "Playback Speed 1.2x",
             type: "uploader",
             label_tooltip: "Playback Speed 1.2x",
-            initial_value:
-              "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAHgAAAB4CAYAAAA5ZDbSAAAACXBIWXMAACE4AAAhOAFFljFgAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAUjSURBVHgB7d3bUeNIFAbgA7Xv2EUCmgiWjWBNBAwRYCKYdQQrIliIYEUEw0awymDIYDQBUFC8g+eccWsulPomteTu1v9VdZlSGyP0W1KrWxciAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgPgc0Mw8Pj4u+KUt4mm5XDaUqVED5oX5gV/ea6o3vGDvaQI8Hyt+ueAir4XmbTIvNZebnAIfJWBeoCf88g/tFqjOKS/ImkbE8/FezUdBfu5o9wVsKHGHFJBs/rjIAv1E5nBHpebjX/7xI/mHK+SL8Zk/429K3G8UiNoMykItaI/UPvZ/Lic0XMmfR7wmX1GiBq/BP621slAL2j9Z60KE25KQ/6JEDdoHD9jHieD7YJ6fNe22IjpPXG5p16Bq1DT5MpyReZciv/eO5/eJEtN7E63C/Wh5myyQBU1Hu888ODi42263lx0h1Vyu1ZdDvqxd8yvTZC0uKTFDNtGm4GQhbrjc0ERUy73QVNeLxeLctAZyXcUv56R3QQkK2or+9oGHhxXtNmfXNK2Voe6SHKhdxq2muuAvUUGJCRlww+X06Ojock/7qj810+89j2fvDHUFJSZUwLIp/mPsjgsL3S7jC/mZpHdtKkOPg2VhbPYcbEuOVbs2rw35mbJROLohAdeqYRKFgF+ywlCX3GFS7010xiMwZ5rpzVSDIyEFb0WnTLWS1111fHRQU4IQ8K+0vWCvr69J9kcjYEWNHK001c5jxNIvz2XLpfdolIyEtZ/x/Pw8qIMFAdP3ExNKTXVDjl2UqruzHZgoaDdQ4RWyGuZct5/x8vJSqRGyXmYfMC88WUNMvW6nHh03q45pziG/Cdf2uU5mHbAKtzK8xfesjloz3RqyIVzRu/U+24Adwr3y7U+XfgFujOn6srUhW8K9GnJIOsuAHcMtqYfj4+O1T8gO4ZY0wOwCdgj3duhCdQ157HDFrAJ2DHdNATiELCcmrjX1QcIVswl4ynBblpB1540FC1fMImB1nFsZ3hI83JYl5LeChiuyD1jt70yt4dHCbTmGHDxckXXAKtzS8JbRw23xYMXW8hZbfb+/S5mKKVxLa7nl3a3pItiVDaGpoTs5NVf6YeW8qjuP300t3FbwKymiDLgrIJ4m3XXWfuGEwpX/p6slHTTk6AJWIzJlR5UsDDnR/tTwu7ZwGy6Vuo6qF9dTg1w6MR4eHireN3cNBwYLOcY1+MxQt5Khs661WF0/VJJZQbtrqPpquLyzvcm1h0pa1xwyjRlyjI0s29jnief0Sfl2P/r2XfuKMWDbeczRnvimdi9rTbX2ONch5N5f3hgDrgx1N8u4r/BbaaZbOzEsIRfUU3QBq0aMXEvUvKmS1m/s1+nWHdOce6gMIffeao3dyJJj10ZTp5v+beCcN0s17farsk9uHFqvFenPqAjFuPVQ813wjx/UJO+TBiRk/gz5Oxfq7w0a8AcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANif7B8Q/dOlJHI7iEJNvlcl+8tCsg5Y3R/Ldm1QuUz46aI2ud9lx+XCr1HubhOLLNdgh6eQdjn3uZNPKnIN+DP5XzQtl6ha77+Rmuw20eoOOgX5K4bcfSdWOe6Dh9yMJYobuYSUY8BDnj2Y1XMLRY4BD7lJS3LPJrTJMeAht1lK7tmENmhF/4BWdEI25C/L3qwsA1YdFj6BXcX0LOSQcu+LLvnF1g258b2XVUrmMppUcvmdfhznNlz+43Kd+2jSV0z9PFgMpokeAAAAAElFTkSuQmCC",
+            initial_value: null,
           },
           {
             key: "speed_1_5",
             label: "Playback Speed 1.5x",
             type: "uploader",
             label_tooltip: "Playback Speed 1.5x",
-            initial_value:
-              "data:image/png;base64,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",
+            initial_value: null,
           },
           {
             key: "speed_2",
             label: "Playback Speed 2x",
             type: "uploader",
             label_tooltip: "Playback Speed 2x",
-            initial_value:
-              "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAHgAAAB4CAYAAAA5ZDbSAAAACXBIWXMAACE4AAAhOAFFljFgAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAQnSURBVHgB7d2PUdRAFMfxh2MBUIGxArECjwqECjwqUCowV4FYgdABVCAdSAekg7ME35pFgnOb3ZDAvmy+n5lMGJLL3dzvkuyfZCMCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2LMnM7Hdbvd11p2ag4ODRtDLdMAa6kpnH3U61qkKrHbrp0sN/EbwiMmAfbBfdVrJMI1OZxr0leAvcwFruC7YWsY515DPBLYC1nC/6eyLTONCQz6VhXslRvg9d6pwnbX/wSyaiT1Yg6h0dhdZzZ1Xr6U9zzqHOn2QtgDW52jJhS8rAf/Q2Tqw2JWQT0JVIv/j+CnhUvaNvvZIFip7wL5+uw0sbqTdA5vINiqd/ZK2fryLbuLgtyyQhXPwYc+yTUpjhl/ne88qK1koCwGvQgs0uAtJ17duJQtlIeDQYfVWBojs6fuyUK8lP1c63hXmlOfMRZ5/newBT1WF0YJW37m8kYUy09Axgb6ABx3uSzKb7sI+vqrlqknVjsXJ9WC/HRlTpZpiG1MqZQ92zZxVYNmlJPBNpdv2z6c1cfrXjdrG1Ga/B+sX+Vln54HFV7onnUh8GytpW8O6BnVWBFrjTnJ3Xc56D/YFq1C47hCZ2mW46/y99qGlfI5QU+uhZDbbgDtt0CFJrWBeqBAWDTnSjn4jmc0y4E64oQYMF+65JPJVtU1gcTDkSLgbC71YszsHJ/QeuWuz1vK0bdfSFth2eXROTgi3FgNmFXBCuLf6xb6Xce9RSyTkuYTrzOmyWVdg6Tssu/Po0RT1z0jIjYR/YKbCdWYR8EuG23nPWsIh72IuXMd8wDnC7bx3LWkhmwzXsX7he7ZwO5+hlv6QzYbrmK0mWQjXezNyeVZW72wwEW6ktNxl9hpsc3uwfqmfZF7hOsnNmi/NVMA+3AsJh9tI24CfM9ybwP9Nhmzpzob7cEMaSbiEdoLPEWvEcH3Lg5s1c7Fy4Xss3PueoUaeKKVdeEgL1ZBmzZwsXPi+kv5eoUnoF74X+Rx9N77trArNIWQLh+hKMtOgjmVguI7/f9/h+lgyK+miuzGqwP+jjRiRkOnwN2JXh39yC1VPyFeSGQHLvwKYu3bLBd1IOwxELQP49U//28atZGahkFXJC9wcNvA+JwAAAAAAAAAAAAAAAAAAAAAAAIxWxIjvffytMW5M6e4ziO+fOTxkRNpZKjrgyGDh92oNeSOFKvbuQj9Ef8qQwrVft0hF7sEa2FpnQwdDyT78/nMoNeA7GT40RKMBv5XCFHeI9oO6VDJc5V9blBLPwWPGxcg+psbUSgx4X55uzGtNKjHgMcMcPvfItS+uxIDHDHySfdCUqVGKfkApekZSn3jWVWRrVpEB+waLIYFtSh1mqfS26FriD9U4G/KUtLlZSm9SrdM7eajnNjpd63Reem/SH2FDq35f8ateAAAAAElFTkSuQmCC",
+            initial_value: null,
           },
           {
             key: "sleep_timer",

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

@@ -24,6 +24,8 @@ describe("toNumber", () => {
   it("return undefined if input is not a number", () => {
     const inputs = [
       "vfdvf",
+      "5n",
+      "-5n",
       null,
       undefined,
       NaN,
@@ -41,4 +43,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");
+      });
+    }
+  });
 });