@applicaster/zapp-react-native-utils 15.1.4 → 16.0.0-alpha.1042942411

package/numberUtils/__tests__/toNumberWithDefault.test.ts

@@ -0,0 +1,64 @@
+import { toNumberWithDefault } from "..";
+
+describe("toNumberWithDefault", () => {
+  const DEFAULT = 5;
+
+  it("return number if input is number", () => {
+    const inputs = [-1, 0, 1, 100, 0.2];
+    expect.assertions(inputs.length);
+
+    inputs.forEach((input) => {
+      const output = toNumberWithDefault(DEFAULT, input);
+      expect(output).toBe(input);
+    });
+  });
+
+  it("return number if input is string as number", () => {
+    const inputs = ["-1", "0", "1", "100", "0.2"];
+    expect.assertions(inputs.length);
+
+    inputs.forEach((input) => {
+      const output = toNumberWithDefault(DEFAULT, input);
+      expect(output).toBe(Number(input));
+    });
+  });
+
+  it("return default if input is not a number", () => {
+    const inputs = [
+      "vfdvf",
+      "5n",
+      "-5n",
+      null,
+      undefined,
+      NaN,
+      "",
+      {},
+      { test: 1 },
+      [],
+      [1],
+    ];
+
+    expect.assertions(inputs.length);
+
+    inputs.forEach((input) => {
+      const output = toNumberWithDefault(DEFAULT, input);
+      expect(output).toBe(DEFAULT);
+    });
+  });
+
+  describe("BigInt support", () => {
+    const isBigIntSupported = typeof BigInt !== "undefined";
+
+    if (isBigIntSupported) {
+      it("converts BigInt to number when BigInt is supported", () => {
+        expect(toNumberWithDefault(DEFAULT, BigInt(5))).toBe(5);
+        expect(toNumberWithDefault(DEFAULT, BigInt(0))).toBe(0);
+        expect(toNumberWithDefault(DEFAULT, BigInt(-10))).toBe(-10);
+      });
+    } else {
+      it("skips BigInt tests when BigInt is not supported", () => {
+        expect(typeof BigInt).toBe("undefined");
+      });
+    }
+  });
+});

package/numberUtils/__tests__/toNumberWithDefaultZero.test.ts

@@ -0,0 +1,48 @@
+import { toNumberWithDefaultZero } from "..";
+
+const DEFAULT = 0;
+
+describe("toNumberWithDefaultZero", () => {
+  it("return number if input is number", () => {
+    const inputs = [-1, 0, 1, 100, 0.2];
+    expect.assertions(inputs.length);
+
+    inputs.forEach((input) => {
+      const output = toNumberWithDefaultZero(input);
+      expect(output).toBe(input);
+    });
+  });
+
+  it("return number if input is string as number", () => {
+    const inputs = ["-1", "0", "1", "100", "0.2"];
+    expect.assertions(inputs.length);
+
+    inputs.forEach((input) => {
+      const output = toNumberWithDefaultZero(input);
+      expect(output).toBe(Number(input));
+    });
+  });
+
+  it("return zero if input is not a number", () => {
+    const inputs = [
+      "vfdvf",
+      "5n",
+      "-5n",
+      null,
+      undefined,
+      NaN,
+      "",
+      {},
+      { test: 1 },
+      [],
+      [1],
+    ];
+
+    expect.assertions(inputs.length);
+
+    inputs.forEach((input) => {
+      const output = toNumberWithDefaultZero(input);
+      expect(output).toBe(DEFAULT);
+    });
+  });
+});

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

@@ -1,14 +1,37 @@
-import * as R from "ramda";
+import { isNil } from "@applicaster/zapp-react-native-utils/utils";
+
 import { logger } from "@applicaster/zapp-react-native-utils/logger";
 
 const numberUtilsLogger = logger?.addSubsystem("NumberUtils");
 
+/** Matches Ramda isEmpty: "" / [] / {} are empty; numbers and bigints are not. */
+const isEmpty = (value: unknown): boolean => {
+  if (typeof value === "string" || Array.isArray(value)) {
+    return value.length === 0;
+  }
+
+  if (typeof value === "object" && value !== null) {
+    return Object.keys(value).length === 0;
+  }
+
+  return false;
+};
+
 export const toNumber = (value: unknown): number | undefined => {
-  if (R.isNil(value) || R.isEmpty(value)) {
+  if (isNil(value) || isEmpty(value)) {
     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 && typeof value === "bigint";
+
+  if (
+    typeof value === "number" ||
+    isBigIntValue ||
+    typeof value === "string" ||
+    value instanceof String
+  ) {
     const numberOrNan = Number(value);
 
     return Number.isNaN(numberOrNan) ? undefined : numberOrNan;
@@ -55,7 +78,7 @@ export const toFiniteNumberWithDefault = (
 export const isLikeNumber = (value: unknown): boolean => {
   const possibleNumber = toNumber(value);
 
-  if (R.isNil(possibleNumber)) {
+  if (isNil(possibleNumber)) {
     return false;
   }
 
@@ -69,13 +92,31 @@ export const isMinusZero = (value: number) => {
   return 1 / value === -Infinity;
 };
 
+export const toPositiveNumber = (value: unknown): number | undefined => {
+  const possibleNumber = toNumber(value);
+
+  if (isNil(possibleNumber)) {
+    return undefined;
+  }
+
+  if (possibleNumber < 0) {
+    return undefined;
+  }
+
+  if (isZero(possibleNumber)) {
+    return undefined;
+  }
+
+  return possibleNumber;
+};
+
 export const toPositiveNumberWithDefault = (
   defaultValue: number,
   value: unknown
 ): number => {
   const possibleNumber = toNumber(value);
 
-  if (R.isNil(possibleNumber)) {
+  if (isNil(possibleNumber)) {
     return defaultValue;
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applicaster/zapp-react-native-utils",
-  "version": "15.1.4",
+  "version": "16.0.0-alpha.1042942411",
   "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.4",
+    "@applicaster/applicaster-types": "16.0.0-alpha.1042942411",
     "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/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/actions/index.ts

@@ -1,8 +1,12 @@
 /// <reference types="@applicaster/applicaster-types" />
 /* eslint-disable @typescript-eslint/no-unused-vars */
-import { Context, useContext, useState } from "react";
+import { Context, useCallback, useContext, useEffect, useState } from "react";
 import { ActionsContext } from "@applicaster/zapp-react-native-ui-components/Contexts/ActionsContext";
 
+import {
+  observeEntryState,
+  RegisteredActionValue,
+} from "../../uiActionsRegistrator";
 import { reactHooksLogger } from "../logger";
 
 const logger = reactHooksLogger.addSubsystem("actions");
@@ -46,3 +50,49 @@ export function useActions<T = unknown>(plugId: string): any {
 
   return context;
 }
+
+export type UseEntryActionState = {
+  state: CellActionEntryState | undefined;
+  invokeAction: (options?: InvokeArgsOptions) => void;
+};
+
+/**
+ * Subscribes a component to a single action's state for a given `entry`.
+ *
+ * It observes state changes reactively via `observeEntryState` (which is backed
+ * by the action's `addListener`), seeds the initial value synchronously from
+ * `initialEntryState`, and returns a memoized `invokeAction` that forwards
+ * optimistic `updateState` updates back into local state.
+ *
+ * This is the single, unified way to drive an action button - it works the same
+ * for registry actions, legacy context-provider actions and entry actions.
+ */
+export function useEntryActionState(
+  action: RegisteredActionValue | undefined,
+  entry: ZappEntry | ZappFeed
+): UseEntryActionState {
+  const [state, setState] = useState<CellActionEntryState | undefined>(() =>
+    action?.initialEntryState?.(entry)
+  );
+
+  const entryId = (entry as ZappEntry)?.id;
+
+  useEffect(() => {
+    if (!action) return undefined;
+
+    const subscription = observeEntryState(action, entry).subscribe(setState);
+
+    return () => subscription.unsubscribe();
+    // eslint-disable-next-line @wogns3623/better-exhaustive-deps/exhaustive-deps
+  }, [action, entryId]);
+
+  const invokeAction = useCallback(
+    (options: InvokeArgsOptions = {}) => {
+      action?.invokeAction?.(entry, { updateState: setState, ...options });
+    },
+    // eslint-disable-next-line @wogns3623/better-exhaustive-deps/exhaustive-deps
+    [action, entryId]
+  );
+
+  return { state, invokeAction };
+}

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