@applicaster/zapp-react-native-utils 16.0.0-alpha.2899709395 → 16.0.0-alpha.3524654973

package/package.json

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

package/pipesUtils/__tests__/buildUrlWithQuery.test.ts

@@ -0,0 +1,55 @@
+import { buildUrlWithQuery } from "../withPipesEndpoint";
+
+describe("buildUrlWithQuery", () => {
+  it("returns the url unchanged when requestParams is null", () => {
+    const url = "https://example.com/path";
+
+    expect(buildUrlWithQuery(url, null)).toBe(url);
+  });
+
+  it("returns the url unchanged when requestParams is undefined", () => {
+    const url = "https://example.com/path";
+
+    expect(buildUrlWithQuery(url, undefined)).toBe(url);
+  });
+
+  it("returns the url unchanged when requestParams has no params", () => {
+    const url = "https://example.com/path";
+
+    expect(buildUrlWithQuery(url, {})).toBe(url);
+    expect(buildUrlWithQuery(url, { params: undefined })).toBe(url);
+    expect(buildUrlWithQuery(url, { params: null })).toBe(url);
+  });
+
+  it("appends query params to a url without an existing query string", () => {
+    expect(
+      buildUrlWithQuery("https://example.com/path", {
+        params: { foo: "bar", baz: "qux" },
+      })
+    ).toBe("https://example.com/path?foo=bar&baz=qux");
+  });
+
+  it("merges query params with existing query string params", () => {
+    expect(
+      buildUrlWithQuery("https://example.com/path?existing=1", {
+        params: { added: "2" },
+      })
+    ).toBe("https://example.com/path?existing=1&added=2");
+  });
+
+  it("overrides existing query params when keys collide", () => {
+    expect(
+      buildUrlWithQuery("https://example.com/path?foo=old", {
+        params: { foo: "new" },
+      })
+    ).toBe("https://example.com/path?foo=new");
+  });
+
+  it("preserves url path, host, and hash when adding params", () => {
+    expect(
+      buildUrlWithQuery("https://example.com:8080/my/path#section", {
+        params: { token: "abc" },
+      })
+    ).toBe("https://example.com:8080/my/path?token=abc#section");
+  });
+});

package/pipesUtils/__tests__/withPipesEndpoint.test.tsx

@@ -0,0 +1,95 @@
+import React from "react";
+import { render } from "@testing-library/react-native";
+import { useBuildPipesUrl } from "@applicaster/zapp-react-native-utils/reactHooks/feed";
+import { withPipesEndpoint } from "../withPipesEndpoint";
+
+jest.mock("@applicaster/zapp-react-native-utils/reactHooks/feed", () => ({
+  useBuildPipesUrl: jest.fn(),
+}));
+
+describe("withPipesEndpoint", () => {
+  let receivedProps: Record<string, unknown> | undefined;
+  let receivedRef: React.Ref<unknown> | undefined;
+
+  const BaseComponent = React.forwardRef((props, ref) => {
+    receivedProps = props;
+    receivedRef = ref;
+
+    return null;
+  });
+
+  const Wrapped = withPipesEndpoint(BaseComponent);
+
+  const defaultUri = "https://example.com/path";
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    receivedProps = undefined;
+    receivedRef = undefined;
+  });
+
+  it("returns null when requestParams is null", () => {
+    (useBuildPipesUrl as jest.Mock).mockReturnValue({ requestParams: null });
+
+    const { toJSON } = render(<Wrapped uri={defaultUri} />);
+
+    expect(toJSON()).toBeNull();
+  });
+
+  it("calls useBuildPipesUrl with the uri from props", () => {
+    (useBuildPipesUrl as jest.Mock).mockReturnValue({ requestParams: null });
+
+    render(<Wrapped uri={defaultUri} />);
+
+    expect(useBuildPipesUrl).toHaveBeenCalledWith({ url: defaultUri });
+  });
+
+  it("renders the wrapped component with merged uri and headers when requestParams are available", () => {
+    const onLoad = jest.fn();
+
+    (useBuildPipesUrl as jest.Mock).mockReturnValue({
+      requestParams: {
+        params: { token: "abc" },
+        headers: { Authorization: "Bearer x" },
+      },
+    });
+
+    render(<Wrapped uri={defaultUri} onLoad={onLoad} />);
+
+    expect(receivedProps?.uri).toBe(`${defaultUri}?token=abc`);
+    expect(receivedProps?.headers).toEqual({ Authorization: "Bearer x" });
+    expect(receivedProps?.onLoad).toBe(onLoad);
+  });
+
+  it("passes empty headers when requestParams has no headers", () => {
+    (useBuildPipesUrl as jest.Mock).mockReturnValue({
+      requestParams: { params: { token: "abc" } },
+    });
+
+    render(<Wrapped uri={defaultUri} />);
+
+    expect(receivedProps?.headers).toEqual({});
+  });
+
+  it("keeps uri unchanged when requestParams has no params", () => {
+    (useBuildPipesUrl as jest.Mock).mockReturnValue({
+      requestParams: {},
+    });
+
+    render(<Wrapped uri={defaultUri} />);
+
+    expect(receivedProps?.uri).toBe(defaultUri);
+  });
+
+  it("forwards ref to the wrapped component", () => {
+    const ref = React.createRef<unknown>();
+
+    (useBuildPipesUrl as jest.Mock).mockReturnValue({
+      requestParams: { params: { token: "abc" } },
+    });
+
+    render(<Wrapped ref={ref} uri={defaultUri} />);
+
+    expect(receivedRef).toBe(ref);
+  });
+});

package/pipesUtils/index.ts

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

package/pipesUtils/withPipesEndpoint.tsx

@@ -0,0 +1,42 @@
+import React, { forwardRef, RefObject } from "react";
+import URL from "url";
+
+import { useBuildPipesUrl } from "@applicaster/zapp-react-native-utils/reactHooks/feed";
+
+export function buildUrlWithQuery(url: string, requestParams) {
+  if (!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>;
+
+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/reactHooks/feed/useInflatedUrl.ts

@@ -80,9 +80,9 @@ export const getInflatedDataSourceUrl: GetInflatedDataSourceUrl = ({
     if (!source) {
       if (__DEV__) {
         // eslint-disable-next-line no-console
-        throw new Error(
-          "getInflatedDataSourceUrl: source is empty while mapping is provided"
-        );
+        // throw new Error(
+        //   "getInflatedDataSourceUrl: source is empty while mapping is provided"
+        // );
       }
 
       return null;

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) {