@applicaster/zapp-react-native-utils 15.1.0-rc.9 → 16.0.0-alpha.1011304583

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

package/numberUtils/index.ts

@@ -8,7 +8,11 @@ export const toNumber = (value: unknown): number | undefined => {
     return undefined;
   }
 
-  if (R.is(Number, value) || R.is(String, value)) {
+  // Feature-detect BigInt support to avoid ReferenceError on older runtimes
+  const isBigIntSupported = typeof BigInt !== "undefined";
+  const isBigIntValue = isBigIntSupported && R.is(BigInt, value);
+
+  if (R.is(Number, value) || isBigIntValue || R.is(String, value)) {
     const numberOrNan = Number(value);
 
     return Number.isNaN(numberOrNan) ? undefined : numberOrNan;
@@ -69,6 +73,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.1.0-rc.9",
+  "version": "16.0.0-alpha.1011304583",
   "description": "Applicaster Zapp React Native utilities package",
   "main": "index.js",
   "types": "index.d.ts",
@@ -27,13 +27,13 @@
   },
   "homepage": "https://github.com/applicaster/quickbrick#readme",
   "dependencies": {
-    "@applicaster/applicaster-types": "15.1.0-rc.9",
+    "@applicaster/applicaster-types": "16.0.0-alpha.1011304583",
     "buffer": "^5.2.1",
     "camelize": "^1.0.0",
     "dayjs": "^1.11.10",
+    "handlebars": "4.7.9",
     "memoizee": "0.4.15",
-    "prop-types": "^15.0.0",
-    "react-native-handlebars": "^5.0.0-alpha.1"
+    "prop-types": "^15.0.0"
   },
   "peerDependencies": {
     "@applicaster/zapp-pipes-v2-client": "*",

package/pipesUtils/__tests__/buildUrlWithQuery.test.ts

@@ -0,0 +1,33 @@
+import { buildUrlWithQuery } from "../withPipesEndpoint";
+
+describe("buildUrlWithQuery", () => {
+  it("returns the url unchanged when requestParams is null", () => {
+    expect(buildUrlWithQuery("https://foo.com/path", null)).toBe(
+      "https://foo.com/path"
+    );
+  });
+
+  it("returns the url unchanged when requestParams has no params", () => {
+    expect(buildUrlWithQuery("https://foo.com/path", { headers: {} })).toBe(
+      "https://foo.com/path"
+    );
+  });
+
+  it("returns the url unchanged when url is empty", () => {
+    expect(buildUrlWithQuery("", { params: { a: "1" } })).toBe("");
+  });
+
+  it("appends params to a url with no existing query", () => {
+    expect(
+      buildUrlWithQuery("https://foo.com/path", { params: { token: "abc" } })
+    ).toBe("https://foo.com/path?token=abc");
+  });
+
+  it("merges params with an existing query string", () => {
+    expect(
+      buildUrlWithQuery("https://foo.com/path?existing=1", {
+        params: { token: "abc" },
+      })
+    ).toBe("https://foo.com/path?existing=1&token=abc");
+  });
+});

package/pipesUtils/__tests__/withPipesEndpoint.test.tsx

@@ -0,0 +1,56 @@
+import * as React from "react";
+import { render } from "@testing-library/react-native";
+import { Text } from "react-native";
+
+const mockedUseBuildPipesUrl = jest.fn();
+
+jest.mock("@applicaster/zapp-react-native-utils/reactHooks/feed", () => ({
+  useBuildPipesUrl: (args) => mockedUseBuildPipesUrl(args),
+}));
+
+const { withPipesEndpoint } = require("../withPipesEndpoint");
+
+// eslint-disable-next-line react/display-name
+const Wrapped = React.forwardRef((props: any, _ref) => (
+  <Text testID="wrapped">{`${props.uri}|${JSON.stringify(props.headers)}`}</Text>
+));
+
+describe("withPipesEndpoint", () => {
+  afterEach(() => jest.clearAllMocks());
+
+  it("renders nothing while the endpoint context is resolving", () => {
+    mockedUseBuildPipesUrl.mockReturnValue({ requestParams: null });
+
+    const Decorated = withPipesEndpoint(Wrapped);
+    const { queryByTestId } = render(<Decorated uri="https://foo.com" />);
+
+    expect(queryByTestId("wrapped")).toBeNull();
+  });
+
+  it("passes the uri through unchanged when there are no params", () => {
+    mockedUseBuildPipesUrl.mockReturnValue({ requestParams: {} });
+
+    const Decorated = withPipesEndpoint(Wrapped);
+    const { getByTestId } = render(<Decorated uri="https://foo.com/path" />);
+
+    expect(getByTestId("wrapped").props.children).toBe(
+      "https://foo.com/path|{}"
+    );
+  });
+
+  it("merges resolved params into the uri and forwards headers", () => {
+    mockedUseBuildPipesUrl.mockReturnValue({
+      requestParams: {
+        params: { token: "abc" },
+        headers: { Authorization: "Bearer xyz" },
+      },
+    });
+
+    const Decorated = withPipesEndpoint(Wrapped);
+    const { getByTestId } = render(<Decorated uri="https://foo.com/path" />);
+
+    expect(getByTestId("wrapped").props.children).toBe(
+      'https://foo.com/path?token=abc|{"Authorization":"Bearer xyz"}'
+    );
+  });
+});

package/pipesUtils/index.ts

@@ -0,0 +1 @@
+export { withPipesEndpoint, buildUrlWithQuery } from "./withPipesEndpoint";

package/pipesUtils/withPipesEndpoint.tsx

@@ -0,0 +1,54 @@
+import React, { forwardRef, RefObject } from "react";
+import URL from "url";
+
+import { useBuildPipesUrl } from "@applicaster/zapp-react-native-utils/reactHooks/feed";
+
+/**
+ * Merges the query params resolved from a pipes endpoint context into the url.
+ * Returns the url unchanged when there is nothing to merge.
+ */
+export function buildUrlWithQuery(url: string, requestParams): string {
+  if (!url || !requestParams?.params) {
+    return url;
+  }
+
+  const parsedURL = URL.parse(url, true);
+
+  parsedURL.query = { ...parsedURL.query, ...requestParams.params };
+  parsedURL.search = null;
+
+  return URL.format(parsedURL);
+}
+
+type Props = {
+  uri: string;
+} & Record<string, unknown>;
+
+/**
+ * HOC that resolves the wrapped component's `uri` against its matching Zapp
+ * Pipes endpoint. Endpoint context keys are added as query params (merged into
+ * the uri) and as request `headers`. Rendering is deferred until the context
+ * has been resolved so the component never loads without its required headers.
+ */
+export function withPipesEndpoint(Component) {
+  function WithPipesEndpoint(props: Props, ref: RefObject<unknown>) {
+    const { requestParams } = useBuildPipesUrl({ url: props.uri });
+
+    if (requestParams !== null) {
+      const urlWithQuery = buildUrlWithQuery(props.uri, requestParams);
+
+      return (
+        <Component
+          ref={ref}
+          {...props}
+          uri={urlWithQuery}
+          headers={requestParams.headers || {}}
+        />
+      );
+    }
+
+    return null;
+  }
+
+  return forwardRef(WithPipesEndpoint);
+}

package/pluginUtils/index.ts

@@ -6,6 +6,7 @@ import { deprecationMessage } from "../appUtils";
 
 import { pluginUtilsLogger } from "./logger";
 import { platformSelect } from "../reactUtils";
+import { get } from "../utils";
 
 type PluginModule = any;
 type Plugin = {
@@ -253,3 +254,6 @@ const getPluginType = R.pathOr("unknown_plugin_type", [
 
 export const isPlayerPlugin = (routeState): boolean =>
   getPluginType(routeState) === "player";
+
+export const getPluginModuleUrlScheme = (plugin) =>
+  get(plugin, ["module", "urlScheme"]);

package/reactHooks/advertising/index.ts

@@ -3,7 +3,7 @@ import { View } from "react-native";
 import * as R from "ramda";
 
 import { useNavigation } from "../navigation";
-import { usePickFromState } from "@applicaster/zapp-react-native-redux/hooks";
+import { usePlugins } from "@applicaster/zapp-react-native-redux/hooks";
 import { platformSelect } from "@applicaster/zapp-react-native-utils/reactUtils";
 import { dismissModal, openModal } from "../../modalState";
 
@@ -16,7 +16,7 @@ const ModalContainer = platformSelect({
 
 export function useAdvertisingInterstitial() {
   const { screenData, currentRoute } = useNavigation();
-  const { plugins } = usePickFromState();
+  const plugins = usePlugins();
 
   return useEffect(() => {
     // TODD: typing problem: fix any type