@applicaster/zapp-react-native-utils 15.0.0-rc.99 → 16.0.0-alpha.6593152532

package/manifestUtils/mobileAction/groups/index.js

@@ -0,0 +1,80 @@
+const { mobileActionButtonsContainer } = require("../container");
+const { mobileActionButton } = require("../button");
+
+const {
+  DEFAULT_MOBILE_ACTION_BUTTONS_CONTAINER_DEFAULTS,
+  DEFAULT_MOBILE_ACTION_BUTTON_SHARED_DEFAULTS,
+  DEFAULT_MOBILE_ACTION_BUTTON_PRESETS,
+} = require("./defaults");
+
+const CONTAINER_GROUP_LABEL = "Mobile Buttons Container"; // NOTE: used as key – "Mobile Buttons Container" -> "mobile_buttons_container"
+
+const CONTAINER_GROUP_DESCRIPTION =
+  "Configuration for mobile action buttons container";
+
+const BUTTON_GROUPS = [
+  {
+    index: 1,
+    label: "Mobile Button 1",
+    description: "Primary mobile action button",
+  },
+  {
+    index: 2,
+    label: "Mobile Button 2",
+    description: "Secondary mobile action button",
+  },
+  {
+    index: 3,
+    label: "Mobile Button 3",
+    description: "Tertiary mobile action button",
+  },
+];
+
+/**
+ * Builds the shared mobile action button manifest groups while letting each
+ * plugin supply only its supported insertion positions and explicit overrides.
+ *
+ * @param {object} options
+ * @param {object} [options.containerDefaults={}]
+ * @param {object} [options.sharedButtonDefaults={}]
+ * @param {Record<number, object>} [options.buttonOverrides={}]
+ * @returns {object[]}
+ */
+function buildMobileActionButtonGroups({
+  containerDefaults = {},
+  sharedButtonDefaults = {},
+  buttonOverrides = {},
+}) {
+  const groups = [
+    mobileActionButtonsContainer({
+      label: CONTAINER_GROUP_LABEL,
+      description: CONTAINER_GROUP_DESCRIPTION,
+      defaults: {
+        ...DEFAULT_MOBILE_ACTION_BUTTONS_CONTAINER_DEFAULTS,
+        ...containerDefaults,
+      },
+    }),
+  ];
+
+  BUTTON_GROUPS.forEach(({ index, label, description }) => {
+    groups.push(
+      mobileActionButton({
+        isFirstButton: index === 1,
+        label,
+        description,
+        defaults: {
+          ...DEFAULT_MOBILE_ACTION_BUTTON_SHARED_DEFAULTS,
+          ...sharedButtonDefaults,
+          ...DEFAULT_MOBILE_ACTION_BUTTON_PRESETS[index],
+          ...(buttonOverrides[index] || {}),
+        },
+      })
+    );
+  });
+
+  return groups;
+}
+
+module.exports = {
+  buildMobileActionButtonGroups,
+};

package/numberUtils/__tests__/toNumber.test.ts

@@ -11,16 +11,6 @@ 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);
@@ -34,6 +24,8 @@ describe("toNumber", () => {
   it("return undefined if input is not a number", () => {
     const inputs = [
       "vfdvf",
+      "5n",
+      "-5n",
       null,
       undefined,
       NaN,
@@ -42,8 +34,6 @@ describe("toNumber", () => {
       { test: 1 },
       [],
       [1],
-      "5n",
-      "-5n",
     ];
 
     expect.assertions(inputs.length);
@@ -53,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");
+      });
+    }
+  });
 });

package/numberUtils/__tests__/toPositiveNumber.test.ts

@@ -156,10 +156,38 @@ describe("toPositiveNumber", () => {
     it("handles Symbol values", () => {
       expect(toPositiveNumber(Symbol("test"))).toBeUndefined();
     });
+  });
 
-    it("converts BigInt values", () => {
-      expect(toPositiveNumber(5n)).toBe(5);
-      expect(toPositiveNumber(-5n)).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(BigInt, 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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applicaster/zapp-react-native-utils",
-  "version": "15.0.0-rc.99",
+  "version": "16.0.0-alpha.6593152532",
   "description": "Applicaster Zapp React Native utilities package",
   "main": "index.js",
   "types": "index.d.ts",
@@ -27,11 +27,11 @@
   },
   "homepage": "https://github.com/applicaster/quickbrick#readme",
   "dependencies": {
-    "@applicaster/applicaster-types": "15.0.0-rc.99",
+    "@applicaster/applicaster-types": "16.0.0-alpha.6593152532",
     "buffer": "^5.2.1",
     "camelize": "^1.0.0",
     "dayjs": "^1.11.10",
-    "handlebars": "4.7.8",
+    "handlebars": "4.7.9",
     "memoizee": "0.4.15",
     "prop-types": "^15.0.0"
   },

package/pluginUtils/index.ts

@@ -30,10 +30,7 @@ export function getComponentModule({
   components: ComponentsMap;
   plugins: Plugin[] | QuickBrickPlugin[];
 }) {
-  const component = R.compose(
-    R.prop(R.__, components),
-    toPascalCase
-  )(componentType);
+  const component = components[toPascalCase(componentType)];
 
   if (component) {
     return component;
@@ -60,7 +57,9 @@ export function findComponentByType({
     ? R.compose(...R.reverse(decorators))
     : decorators;
 
-  const component = getComponentModule({ componentType, components, plugins });
+  const module = getComponentModule({ componentType, components, plugins });
+
+  const component = module?.Component || module;
 
   return R.unless(R.isNil, applyDecorators)(component);
 }

package/reactHooks/casting/index.ts

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

package/reactHooks/casting/useIsCasting.tsx

@@ -0,0 +1,57 @@
+import React from "react";
+import { useActions } from "@applicaster/zapp-react-native-utils/reactHooks/actions";
+import { useAppState } from "@applicaster/zapp-react-native-utils/reactHooks/app";
+import { isApplePlatform } from "@applicaster/zapp-react-native-utils/reactUtils";
+
+const CHROMECAST_IDENTIFIER = "quick-brick-chromecast-action";
+
+const fakeEntry: any = {
+  title: "Chromecast use is casting fake entry",
+  id: "quick-brick-use-is-casting-fake-entry",
+};
+
+/**
+ * Returns the cast action state connection status, does not update when app is in background on Apple platforms
+ * On other platforms, it continues to check the cast action state even when the app is in background
+ */
+export const useIsCasting = () => {
+  const actionContext = useActions(CHROMECAST_IDENTIFIER);
+  const appState = useAppState();
+  const isAppInForeground = appState === "active";
+  const shouldOnlyUpdateInForeground = isApplePlatform();
+
+  const [castActionState, setCastActionState] = React.useState(
+    !actionContext ? null : actionContext.initialEntryState(fakeEntry)
+  );
+
+  React.useEffect(() => {
+    if (!shouldOnlyUpdateInForeground || isAppInForeground) {
+      if (actionContext && castActionState === null) {
+        setCastActionState(actionContext.initialEntryState(fakeEntry));
+      }
+    }
+  }, [
+    actionContext,
+    setCastActionState,
+    isAppInForeground,
+    shouldOnlyUpdateInForeground,
+  ]);
+
+  React.useEffect(() => {
+    if (typeof actionContext?.addListener === "function") {
+      return actionContext?.addListener(String(fakeEntry.id), (state) => {
+        // Only check foreground state on Apple platforms
+        if (!shouldOnlyUpdateInForeground || isAppInForeground) {
+          setCastActionState(state);
+        }
+      });
+    }
+  }, [
+    setCastActionState,
+    actionContext,
+    isAppInForeground,
+    shouldOnlyUpdateInForeground,
+  ]);
+
+  return !!castActionState?.connected;
+};

package/reactHooks/cell-click/index.ts

@@ -54,7 +54,7 @@ export const useCellClick = ({
     component?.rules?.component_cells_selectable
   );
 
-  const [__, setEntryContext] =
+  const [entryContext, setEntryContext] =
     ZappPipesEntryContext.useZappPipesContext(pathname);
 
   const logTimestamp = useProfilerLogging();
@@ -89,6 +89,7 @@ export const useCellClick = ({
           screenState,
           screenRoute: pathname,
           screenStateStore,
+          entryContext,
         });
       }
 

package/reactHooks/feed/index.ts

@@ -1,5 +1,3 @@
-export { useFeedRefresh, feedRefreshLogger } from "./useFeedRefresh";
-
 export { useFeedLoader } from "./useFeedLoader";
 
 export { getSearchContext, getInflatedDataSourceUrl } from "./useInflatedUrl";

package/reactHooks/feed/useInflatedUrl.ts

@@ -45,7 +45,7 @@ interface GetInflatedDataSourceUrl {
   (properties: {
     source?: string;
     contexts: {
-      entry?: ZappEntry;
+      entry?: ZappEntry & { parent?: ZappEntry };
       screen?: ZappRiver;
       search?: object | string;
     };

package/reactHooks/resolvers/useComponentResolver.ts

@@ -1,11 +1,13 @@
 /// <reference types="@applicaster/applicaster-types" />
 import * as React from "react";
 
+import { coreLogger } from "@applicaster/zapp-react-native-utils/logger";
+
 import { findComponentByType } from "@applicaster/zapp-react-native-utils/pluginUtils";
 import {
-  usePlugins,
-  useAppSelector,
   selectComponents,
+  useAppSelector,
+  usePlugins,
 } from "@applicaster/zapp-react-native-redux";
 
 type Decorator = (component: React.Component<any>) => React.Component<any>;
@@ -23,7 +25,7 @@ export function useComponentResolver(
 
   const components = useAppSelector(selectComponents);
 
-  return React.useMemo(
+  const component = React.useMemo(
     () =>
       findComponentByType({
         components,
@@ -33,4 +35,12 @@ export function useComponentResolver(
       }),
     watchers
   );
+
+  if (!component) {
+    coreLogger.warn({
+      message: `useComponentResolver: Component of type ${componentType} not found`,
+    });
+  }
+
+  return component;
 }

package/reactHooks/screen/__tests__/useCurrentScreenIsHook.test.ts

@@ -0,0 +1,103 @@
+import { renderHook } from "@testing-library/react-native";
+import { useCurrentScreenIsHook } from "../useCurrentScreenIsHook";
+
+import { useNavigation } from "@applicaster/zapp-react-native-utils/reactHooks";
+import { last } from "@applicaster/zapp-react-native-utils/utils";
+import { toBooleanWithDefaultFalse } from "@applicaster/zapp-react-native-utils/booleanUtils";
+
+jest.mock("@applicaster/zapp-react-native-utils/reactHooks");
+jest.mock("@applicaster/zapp-react-native-utils/utils");
+jest.mock("@applicaster/zapp-react-native-utils/booleanUtils");
+
+const mockUseNavigation = useNavigation as jest.Mock;
+const mockLast = last as jest.Mock;
+const mockToBoolean = toBooleanWithDefaultFalse as jest.Mock;
+
+describe("useCurrentScreenIsHook", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    // sensible defaults
+    mockUseNavigation.mockReturnValue({ mainStack: [] });
+    mockLast.mockReturnValue(undefined);
+    mockToBoolean.mockReturnValue(false);
+  });
+
+  it("returns true when last route includes 'hook'", () => {
+    const stack = [{ route: "some-hook-screen" }];
+
+    mockUseNavigation.mockReturnValue({ mainStack: stack });
+    mockLast.mockReturnValue(stack[0]);
+    mockToBoolean.mockReturnValue(true);
+
+    const { result } = renderHook(() => useCurrentScreenIsHook());
+
+    expect(mockLast).toHaveBeenCalledWith(stack);
+    expect(mockToBoolean).toHaveBeenCalledWith(true);
+    expect(result.current).toBe(true);
+  });
+
+  it("returns false when last route does not include 'hook'", () => {
+    const stack = [{ route: "home-screen" }];
+
+    mockUseNavigation.mockReturnValue({ mainStack: stack });
+    mockLast.mockReturnValue(stack[0]);
+    mockToBoolean.mockReturnValue(false);
+
+    const { result } = renderHook(() => useCurrentScreenIsHook());
+
+    expect(mockToBoolean).toHaveBeenCalledWith(false);
+    expect(result.current).toBe(false);
+  });
+
+  it("returns false when route is undefined", () => {
+    const stack = [{}];
+
+    mockUseNavigation.mockReturnValue({ mainStack: stack });
+    mockLast.mockReturnValue(stack[0]);
+    mockToBoolean.mockReturnValue(false);
+
+    const { result } = renderHook(() => useCurrentScreenIsHook());
+
+    expect(mockToBoolean).toHaveBeenCalledWith(undefined);
+    expect(result.current).toBe(false);
+  });
+
+  it("returns false when last(mainStack) is undefined (empty stack)", () => {
+    mockUseNavigation.mockReturnValue({ mainStack: [] });
+    mockLast.mockReturnValue(undefined);
+    mockToBoolean.mockReturnValue(false);
+
+    const { result } = renderHook(() => useCurrentScreenIsHook());
+
+    expect(mockLast).toHaveBeenCalledWith([]);
+    expect(mockToBoolean).toHaveBeenCalledWith(undefined);
+    expect(result.current).toBe(false);
+  });
+
+  it("uses default empty array when mainStack is undefined", () => {
+    mockUseNavigation.mockReturnValue({});
+    mockLast.mockReturnValue(undefined);
+    mockToBoolean.mockReturnValue(false);
+
+    const { result } = renderHook(() => useCurrentScreenIsHook());
+
+    expect(mockLast).toHaveBeenCalledWith([]);
+    expect(result.current).toBe(false);
+  });
+
+  it("passes correct boolean result from includes('hook')", () => {
+    const stack = [{ route: "hook" }];
+
+    mockUseNavigation.mockReturnValue({ mainStack: stack });
+    mockLast.mockReturnValue(stack[0]);
+
+    // simulate actual includes result flowing through
+    mockToBoolean.mockImplementation((val) => Boolean(val));
+
+    const { result } = renderHook(() => useCurrentScreenIsHook());
+
+    expect(mockToBoolean).toHaveBeenCalledWith(true);
+    expect(result.current).toBe(true);
+  });
+});

package/reactHooks/screen/__tests__/useCurrentScreenIsStartupHook.test.ts

@@ -0,0 +1,94 @@
+import { renderHook } from "@testing-library/react-native";
+import { useCurrentScreenIsStartupHook } from "../useCurrentScreenIsStartupHook";
+
+import { useNavigation } from "@applicaster/zapp-react-native-utils/reactHooks";
+import { isFilledArray } from "@applicaster/zapp-react-native-utils/arrayUtils";
+
+jest.mock("@applicaster/zapp-react-native-utils/reactHooks");
+jest.mock("@applicaster/zapp-react-native-utils/arrayUtils");
+
+const mockUseNavigation = useNavigation as jest.Mock;
+const mockIsFilledArray = isFilledArray as jest.Mock;
+
+describe("useCurrentScreenIsStartupHook", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("returns true when startUpHooks is a filled array", () => {
+    mockUseNavigation.mockReturnValue({
+      startUpHooks: ["hook1"],
+    });
+
+    mockIsFilledArray.mockReturnValue(true);
+
+    const { result } = renderHook(() => useCurrentScreenIsStartupHook());
+
+    expect(result.current).toBe(true);
+    expect(mockIsFilledArray).toHaveBeenCalledWith(["hook1"]);
+  });
+
+  it('returns true when startUpHooks is "in_process"', () => {
+    mockUseNavigation.mockReturnValue({
+      startUpHooks: "in_process",
+    });
+
+    mockIsFilledArray.mockReturnValue(false);
+
+    const { result } = renderHook(() => useCurrentScreenIsStartupHook());
+
+    expect(result.current).toBe(true);
+    expect(mockIsFilledArray).toHaveBeenCalledWith("in_process");
+  });
+
+  it("returns false when startUpHooks is empty array", () => {
+    mockUseNavigation.mockReturnValue({
+      startUpHooks: [],
+    });
+
+    mockIsFilledArray.mockReturnValue(false);
+
+    const { result } = renderHook(() => useCurrentScreenIsStartupHook());
+
+    expect(result.current).toBe(false);
+    expect(mockIsFilledArray).toHaveBeenCalledWith([]);
+  });
+
+  it("returns false when startUpHooks is undefined", () => {
+    mockUseNavigation.mockReturnValue({
+      startUpHooks: undefined,
+    });
+
+    mockIsFilledArray.mockReturnValue(false);
+
+    const { result } = renderHook(() => useCurrentScreenIsStartupHook());
+
+    expect(result.current).toBe(false);
+    expect(mockIsFilledArray).toHaveBeenCalledWith(undefined);
+  });
+
+  it("returns false when startUpHooks is null", () => {
+    mockUseNavigation.mockReturnValue({
+      startUpHooks: null,
+    });
+
+    mockIsFilledArray.mockReturnValue(false);
+
+    const { result } = renderHook(() => useCurrentScreenIsStartupHook());
+
+    expect(result.current).toBe(false);
+    expect(mockIsFilledArray).toHaveBeenCalledWith(null);
+  });
+
+  it("prioritizes filled array over string comparison", () => {
+    mockUseNavigation.mockReturnValue({
+      startUpHooks: ["hook1"],
+    });
+
+    mockIsFilledArray.mockReturnValue(true);
+
+    const { result } = renderHook(() => useCurrentScreenIsStartupHook());
+
+    expect(result.current).toBe(true);
+  });
+});

package/reactHooks/screen/index.ts

@@ -12,3 +12,7 @@ export {
 } from "./useScreenContext";
 
 export { useScreenBackgroundColor } from "./useScreenBackgroundColor";
+
+export { useCurrentScreenIsHook } from "./useCurrentScreenIsHook";
+
+export { useCurrentScreenIsStartupHook } from "./useCurrentScreenIsStartupHook";

package/reactHooks/screen/useCurrentScreenIsHook.ts

@@ -0,0 +1,9 @@
+import { useNavigation } from "@applicaster/zapp-react-native-utils/reactHooks";
+import { last } from "@applicaster/zapp-react-native-utils/utils";
+import { toBooleanWithDefaultFalse } from "@applicaster/zapp-react-native-utils/booleanUtils";
+
+export const useCurrentScreenIsHook = (): boolean => {
+  const { mainStack = [] } = useNavigation();
+
+  return toBooleanWithDefaultFalse(last(mainStack)?.route?.includes("hook"));
+};

package/reactHooks/screen/useCurrentScreenIsStartupHook.ts

@@ -0,0 +1,8 @@
+import { useNavigation } from "@applicaster/zapp-react-native-utils/reactHooks";
+import { isFilledArray } from "@applicaster/zapp-react-native-utils/arrayUtils";
+
+export const useCurrentScreenIsStartupHook = (): boolean => {
+  const { startUpHooks } = useNavigation();
+
+  return isFilledArray(startUpHooks) || startUpHooks === "in_process";
+};