@applicaster/zapp-react-native-utils 15.0.0-rc.91 → 15.0.0-rc.93

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/numberUtils/__tests__/toNumber.test.ts

@@ -11,6 +11,16 @@ describe("toNumber", () => {
     });
   });
 
+  it("return number if input is BigInt", () => {
+    const inputs = [5n, -5n];
+    expect.assertions(inputs.length);
+
+    inputs.forEach((input) => {
+      const output = toNumber(input);
+      expect(output).toBe(Number(input));
+    });
+  });
+
   it("return number if input is string as number", () => {
     const inputs = ["-1", "0", "1", "100", "0.2"];
     expect.assertions(inputs.length);
@@ -32,6 +42,8 @@ describe("toNumber", () => {
       { test: 1 },
       [],
       [1],
+      "5n",
+      "-5n",
     ];
 
     expect.assertions(inputs.length);

package/numberUtils/__tests__/toPositiveNumber.test.ts

@@ -0,0 +1,165 @@
+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();
+    });
+
+    it("converts BigInt values", () => {
+      expect(toPositiveNumber(5n)).toBe(5);
+      expect(toPositiveNumber(-5n)).toBeUndefined();
+    });
+  });
+});

package/numberUtils/index.ts

@@ -8,7 +8,7 @@ export const toNumber = (value: unknown): number | undefined => {
     return undefined;
   }
 
-  if (R.is(Number, value) || R.is(String, value)) {
+  if (R.is(Number, value) || R.is(BigInt, value) || R.is(String, value)) {
     const numberOrNan = Number(value);
 
     return Number.isNaN(numberOrNan) ? undefined : numberOrNan;
@@ -69,6 +69,24 @@ export const isMinusZero = (value: number) => {
   return 1 / value === -Infinity;
 };
 
+export const toPositiveNumber = (value: unknown): number | undefined => {
+  const possibleNumber = toNumber(value);
+
+  if (R.isNil(possibleNumber)) {
+    return undefined;
+  }
+
+  if (possibleNumber < 0) {
+    return undefined;
+  }
+
+  if (isZero(possibleNumber)) {
+    return undefined;
+  }
+
+  return possibleNumber;
+};
+
 export const toPositiveNumberWithDefault = (
   defaultValue: number,
   value: unknown

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applicaster/zapp-react-native-utils",
-  "version": "15.0.0-rc.91",
+  "version": "15.0.0-rc.93",
   "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": "15.0.0-rc.91",
+    "@applicaster/applicaster-types": "15.0.0-rc.93",
     "buffer": "^5.2.1",
     "camelize": "^1.0.0",
     "dayjs": "^1.11.10",