@applicaster/zapp-react-native-utils 16.0.0-alpha.5222020837 → 16.0.0-alpha.5803191443

package/actionUtils/__tests__/index.test.ts

@@ -0,0 +1,65 @@
+import {
+  resolveAssets,
+  resolveConfiguredAsset,
+} from "@applicaster/zapp-react-native-utils/actionUtils";
+
+describe("actionUtils", () => {
+  describe("resolveConfiguredAsset", () => {
+    it("returns configured asset when value is a non-empty string", () => {
+      expect(resolveConfiguredAsset("configured", "fallback")).toBe(
+        "configured"
+      );
+
+      expect(
+        resolveConfiguredAsset("https://example.com/icon.png", "fallback")
+      ).toBe("https://example.com/icon.png");
+    });
+
+    it("returns fallback when configured asset is empty or undefined", () => {
+      expect(resolveConfiguredAsset("", "fallback")).toBe("fallback");
+      expect(resolveConfiguredAsset(" ", "fallback")).toBe("fallback");
+      expect(resolveConfiguredAsset("   ", "fallback")).toBe("fallback");
+      expect(resolveConfiguredAsset(undefined, "fallback")).toBe("fallback");
+    });
+
+    it("returns fallback for non-string configured asset values", () => {
+      expect(resolveConfiguredAsset(null as any, "fallback")).toBe("fallback");
+      expect(resolveConfiguredAsset(123 as any, "fallback")).toBe("fallback");
+      expect(resolveConfiguredAsset({} as any, "fallback")).toBe("fallback");
+    });
+  });
+
+  describe("resolveAssets", () => {
+    it("returns configured assets when both flavour values are configured", () => {
+      expect(
+        resolveAssets("asset-1", "asset-2", ["default-1", "default-2"])
+      ).toEqual(["asset-1", "asset-2"]);
+    });
+
+    it("falls back to code defaults when configured flavour values are empty", () => {
+      expect(resolveAssets("", undefined, ["default-1", "default-2"])).toEqual([
+        "default-1",
+        "default-2",
+      ]);
+    });
+
+    it("falls back per flavour independently", () => {
+      expect(resolveAssets("", "asset-2", ["default-1", "default-2"])).toEqual([
+        "default-1",
+        "asset-2",
+      ]);
+    });
+
+    it("uses the cell fallback before code defaults", () => {
+      expect(
+        resolveAssets("", undefined, ["default-1", "default-2"], "cell")
+      ).toEqual(["cell", "cell"]);
+    });
+
+    it("preserves configured assets before using the cell fallback", () => {
+      expect(
+        resolveAssets("asset-1", "", ["default-1", "default-2"], "cell")
+      ).toEqual(["asset-1", "cell"]);
+    });
+  });
+});

package/actionUtils/index.ts

@@ -1,7 +1,30 @@
 import { Image } from "react-native";
 import { isTV } from "../reactUtils";
 
+export type Asset = [string, string] | [string];
+
 export const resolveDefaultAssetUri = (source: string | number): string =>
   isTV()
     ? (source as string)
     : Image.resolveAssetSource(source as number)?.uri || "";
+
+const isConfiguredAsset = (asset?: string | null): asset is string =>
+  typeof asset === "string" && asset.trim().length > 0;
+
+export const resolveConfiguredAsset = (
+  configuredAsset: string | undefined,
+  fallbackAsset: string
+): string =>
+  isConfiguredAsset(configuredAsset) ? configuredAsset : fallbackAsset;
+
+/** Resolves assets in the following order: configured asset(can be empty), fallback asset(cell asset, can be empty), default asset */
+export const resolveAssets = <T extends Asset>(
+  flavour1Asset: string | undefined,
+  flavour2Asset: string | undefined,
+  defaultAssets: T,
+  fallbackAssetSrc?: string
+): T =>
+  [
+    resolveConfiguredAsset(flavour1Asset, fallbackAssetSrc || defaultAssets[0]),
+    resolveConfiguredAsset(flavour2Asset, fallbackAssetSrc || defaultAssets[1]),
+  ] as T;

package/package.json

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

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

@@ -0,0 +1,114 @@
+import { renderHook } from "@testing-library/react-native";
+import { useIsStandaloneFullscreen } from "../useIsStandaloneFullscreen";
+
+import { useNavigation } from "@applicaster/zapp-react-native-utils/reactHooks";
+import { toBooleanWithDefaultFalse } from "@applicaster/zapp-react-native-utils/booleanUtils";
+
+jest.mock("@applicaster/zapp-react-native-utils/reactHooks");
+jest.mock("@applicaster/zapp-react-native-utils/booleanUtils");
+
+const mockUseNavigation = useNavigation as jest.Mock;
+const mockToBoolean = toBooleanWithDefaultFalse as jest.Mock;
+
+describe("useIsStandaloneFullscreen", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    mockUseNavigation.mockReturnValue({
+      canGoBack: jest.fn().mockReturnValue(false),
+      screenData: {
+        general: { allow_screen_plugin_presentation: true },
+      },
+    });
+
+    mockToBoolean.mockReturnValue(false);
+  });
+
+  it("returns true when cannot go back and screen plugin presentation is allowed", () => {
+    mockToBoolean.mockReturnValue(true);
+
+    const { result } = renderHook(() => useIsStandaloneFullscreen());
+
+    expect(mockToBoolean).toHaveBeenCalledWith(true);
+    expect(result.current).toBe(true);
+  });
+
+  it("returns false when can go back even if screen plugin presentation is allowed", () => {
+    mockUseNavigation.mockReturnValue({
+      canGoBack: jest.fn().mockReturnValue(true),
+      screenData: {
+        general: { allow_screen_plugin_presentation: true },
+      },
+    });
+
+    mockToBoolean.mockReturnValue(false);
+
+    const { result } = renderHook(() => useIsStandaloneFullscreen());
+
+    expect(mockToBoolean).toHaveBeenCalledWith(false);
+    expect(result.current).toBe(false);
+  });
+
+  it("returns false when cannot go back but screen plugin presentation is not allowed", () => {
+    mockUseNavigation.mockReturnValue({
+      canGoBack: jest.fn().mockReturnValue(false),
+      screenData: {
+        general: { allow_screen_plugin_presentation: false },
+      },
+    });
+
+    mockToBoolean.mockReturnValue(false);
+
+    const { result } = renderHook(() => useIsStandaloneFullscreen());
+
+    expect(mockToBoolean).toHaveBeenCalledWith(false);
+    expect(result.current).toBe(false);
+  });
+
+  it("returns false when screen plugin presentation flag is undefined", () => {
+    mockUseNavigation.mockReturnValue({
+      canGoBack: jest.fn().mockReturnValue(false),
+      screenData: { general: {} },
+    });
+
+    mockToBoolean.mockReturnValue(false);
+
+    const { result } = renderHook(() => useIsStandaloneFullscreen());
+
+    expect(mockToBoolean).toHaveBeenCalledWith(undefined);
+    expect(result.current).toBe(false);
+  });
+
+  it("returns false when navigator is undefined", () => {
+    mockUseNavigation.mockReturnValue(undefined);
+    mockToBoolean.mockReturnValue(false);
+
+    const { result } = renderHook(() => useIsStandaloneFullscreen());
+
+    expect(mockToBoolean).toHaveBeenCalledWith(undefined);
+    expect(result.current).toBe(false);
+  });
+
+  it("returns false when screenData is undefined", () => {
+    mockUseNavigation.mockReturnValue({
+      canGoBack: jest.fn().mockReturnValue(false),
+      screenData: undefined,
+    });
+
+    mockToBoolean.mockReturnValue(false);
+
+    const { result } = renderHook(() => useIsStandaloneFullscreen());
+
+    expect(mockToBoolean).toHaveBeenCalledWith(undefined);
+    expect(result.current).toBe(false);
+  });
+
+  it("passes the combined condition through toBooleanWithDefaultFalse", () => {
+    mockToBoolean.mockImplementation((val) => Boolean(val));
+
+    const { result } = renderHook(() => useIsStandaloneFullscreen());
+
+    expect(mockToBoolean).toHaveBeenCalledWith(true);
+    expect(result.current).toBe(true);
+  });
+});

package/reactHooks/screen/index.ts

@@ -16,3 +16,5 @@ export { useScreenBackgroundColor } from "./useScreenBackgroundColor";
 export { useCurrentScreenIsHook } from "./useCurrentScreenIsHook";
 
 export { useCurrentScreenIsStartupHook } from "./useCurrentScreenIsStartupHook";
+
+export { useIsStandaloneFullscreen } from "./useIsStandaloneFullscreen";

package/reactHooks/screen/useIsStandaloneFullscreen.ts

@@ -0,0 +1,12 @@
+import { useNavigation } from "@applicaster/zapp-react-native-utils/reactHooks";
+import { toBooleanWithDefaultFalse } from "@applicaster/zapp-react-native-utils/booleanUtils";
+
+export const useIsStandaloneFullscreen = (): boolean => {
+  const navigator = useNavigation();
+
+  return toBooleanWithDefaultFalse(
+    !navigator?.canGoBack() &&
+      // @ts-ignore
+      navigator?.screenData?.general?.allow_screen_plugin_presentation
+  );
+};

package/zappFrameworkUtils/HookCallback/callbackNavigationAction.ts

@@ -197,7 +197,7 @@ export const useCallbackNavigationAction = (
         }
       }
 
-      hookCallback?.({ ...args, success: false, cancelled: true });
+      hookCallback?.({ ...args, success: false, abort: true });
       const currentNavigation = navigationRef.current;
 
       switch (data.action) {