@applicaster/quick-brick-core 13.0.0-alpha.5855333506 → 13.0.0-alpha.5944303214

package/App/DeepLinking/URLSchemeListener/__tests__/URLSchemeListener.test.js

@@ -0,0 +1,40 @@
+import * as React from "react";
+import { View, Text } from "react-native";
+import { renderWithProviders } from "@applicaster/zapp-react-native-utils/testUtils";
+
+import { URLSchemeListener } from "../index";
+
+const TestComponent = (props) => (
+  <View testID="test-comp" {...props}>
+    <Text>I'm a test component</Text>
+  </View>
+);
+
+const navigator = {
+  push: jest.fn(),
+  replace: jest.fn(),
+};
+
+jest.spyOn(console, "warn").mockImplementation(() => jest.fn());
+
+function clearMocks() {
+  navigator.push.mockClear();
+  navigator.replace.mockClear();
+  console.warn.mockClear();
+}
+
+describe("URLSchemeHandler", () => {
+  const renderComponent = (props = {}) =>
+    renderWithProviders(
+      <URLSchemeListener {...props}>
+        <TestComponent />
+      </URLSchemeListener>
+    );
+
+  beforeEach(clearMocks);
+
+  it("renders correctly (default case)", () => {
+    const { getByTestId } = renderComponent();
+    expect(getByTestId("test-comp")).toBeDefined();
+  });
+});

package/App/DeepLinking/URLSchemeListener/index.tsx

@@ -5,7 +5,7 @@ import { URLSchemeContext } from "./URLSchemeContextProvider";
 import { useNavigation } from "@applicaster/zapp-react-native-utils/reactHooks/navigation";
 import { usePickFromState } from "@applicaster/zapp-react-native-redux/hooks";
 
-export function URLSchemeListener({ children }) {
+export function URLSchemeListener({ children }: { children: React.ReactNode }) {
   const { url, done } = useContext(URLSchemeContext);
 
   const navigator = useNavigation();

package/App/ErrorBoundary/__tests__/errorBoundary.test.jsx

@@ -0,0 +1,232 @@
+import React from "react";
+import { View, Text, TouchableOpacity } from "react-native";
+import { render, fireEvent, act } from "@testing-library/react-native";
+import { useErrorStore } from "../store";
+import { ErrorBoundary } from "../index";
+
+jest.mock(
+  "@applicaster/zapp-react-native-ui-components/Components/ErrorScreen",
+  () => ({
+    // eslint-disable-next-line react/prop-types
+    ErrorScreen: ({ dismissError, message, buttons }) => (
+      <View testID="error-screen">
+        <Text testID="error-message">{message || "Default error message"}</Text>
+        {/* eslint-disable-next-line react/prop-types */}
+        {buttons?.map((button, index) => (
+          <TouchableOpacity
+            key={index}
+            onPress={button.onPress}
+            testID={`button-${index}`}
+          >
+            <Text>{button.text}</Text>
+          </TouchableOpacity>
+        ))}
+
+        {dismissError ? (
+          <TouchableOpacity onPress={dismissError} testID="dismiss-button">
+            <Text>Dismiss Error</Text>
+          </TouchableOpacity>
+        ) : null}
+      </View>
+    ),
+  })
+);
+
+jest.mock("@applicaster/zapp-react-native-bridge/QuickBrick", () => ({
+  sendQuickBrickEvent: jest.fn(),
+  QUICK_BRICK_EVENTS: {
+    FORCE_APP_RELOAD: "force_app_reload",
+  },
+}));
+
+jest.mock("@applicaster/zapp-react-native-utils/logger", () => ({
+  coreLogger: {
+    addSubsystem: () => ({
+      error: jest.fn(),
+    }),
+  },
+}));
+
+// eslint-disable-next-line react/prop-types
+const TestComponent = ({ error, errorMessage = "error !!" }) => {
+  if (error) {
+    throw new Error(errorMessage);
+  }
+
+  return (
+    <View>
+      <Text>all is good</Text>
+    </View>
+  );
+};
+
+describe("<ErrorBoundary />", () => {
+  // Clear all error states between tests
+  beforeEach(() => {
+    useErrorStore.getState().dismissError();
+  });
+
+  describe("when there is no error", () => {
+    it("renders children correctly", () => {
+      const { getByText } = render(
+        <ErrorBoundary>
+          <TestComponent />
+        </ErrorBoundary>
+      );
+
+      expect(getByText("all is good")).toBeTruthy();
+    });
+  });
+
+  describe("when an error is caught", () => {
+    const _consoleLogs = {
+      error: console.error,
+      log: console.log,
+    };
+
+    beforeAll(() => {
+      console.error = jest.fn();
+      console.log = jest.fn();
+    });
+
+    afterAll(() => {
+      console.error = _consoleLogs.error;
+      console.log = _consoleLogs.log;
+    });
+
+    it("renders error state with default values (recoverable error)", () => {
+      const { getByTestId } = render(
+        <ErrorBoundary>
+          <TestComponent error />
+        </ErrorBoundary>
+      );
+
+      expect(getByTestId("error-screen")).toBeTruthy();
+      expect(getByTestId("dismiss-button")).toBeTruthy(); // Should be recoverable by default
+    });
+
+    it("handles non-recoverable errors (no dismiss button)", () => {
+      const { getByTestId, queryByTestId } = render(
+        <ErrorBoundary recoverable={false}>
+          <TestComponent error />
+        </ErrorBoundary>
+      );
+
+      expect(getByTestId("error-screen")).toBeTruthy();
+      expect(queryByTestId("dismiss-button")).toBeFalsy(); // Should not be recoverable
+    });
+
+    it("shows custom error message from caught error", () => {
+      const customErrorMessage = "Custom error message for testing";
+
+      const { getByTestId } = render(
+        <ErrorBoundary>
+          <TestComponent error errorMessage={customErrorMessage} />
+        </ErrorBoundary>
+      );
+
+      // The error info should be passed to the ErrorScreen
+      expect(getByTestId("error-message").props.children).toBeTruthy();
+    });
+
+    it("can dismiss the error and restore the UI", () => {
+      // First render with error
+      const { getByTestId, queryByText, rerender } = render(
+        <ErrorBoundary>
+          <TestComponent error />
+        </ErrorBoundary>
+      );
+
+      // Verify error screen is shown
+      expect(getByTestId("error-screen")).toBeTruthy();
+
+      // Dismiss the error
+      fireEvent.press(getByTestId("dismiss-button"));
+
+      // Force rerender to see the change
+      rerender(
+        <ErrorBoundary>
+          <TestComponent />
+        </ErrorBoundary>
+      );
+
+      // Now the regular content should be visible
+      expect(queryByText("all is good")).toBeTruthy();
+    });
+  });
+
+  describe("error store functionality", () => {
+    it("properly sets error state", () => {
+      const error = new Error("Test error");
+      const errorInfo = "Test error info";
+
+      act(() => {
+        useErrorStore.getState().setError(error, errorInfo, true);
+      });
+
+      const state = useErrorStore.getState();
+      expect(state.hasError).toBe(true);
+      expect(state.error).toBe(error);
+      expect(state.info).toBe(errorInfo);
+      expect(state.recoverable).toBe(true);
+    });
+
+    it("properly resets error state", () => {
+      // First set an error
+      act(() => {
+        useErrorStore
+          .getState()
+          .setError(new Error("Test error"), "Info", true);
+      });
+
+      // Then dismiss it
+      act(() => {
+        useErrorStore.getState().dismissError();
+      });
+
+      const state = useErrorStore.getState();
+      expect(state.hasError).toBe(false);
+      expect(state.error).toBeUndefined();
+      expect(state.info).toBeUndefined();
+      expect(state.recoverable).toBe(true); // Default value when reset
+    });
+
+    it("remembers recoverable state", () => {
+      act(() => {
+        useErrorStore
+          .getState()
+          .setError(new Error("Test error"), "Info", false);
+      });
+
+      const state = useErrorStore.getState();
+      expect(state.recoverable).toBe(false);
+    });
+  });
+
+  describe("integration with ErrorScreen", () => {
+    it("renders restart app button for non-recoverable errors", () => {
+      const { getAllByTestId } = render(
+        <ErrorBoundary recoverable={false}>
+          <TestComponent error />
+        </ErrorBoundary>
+      );
+
+      // Should have the restart app button
+      const buttons = getAllByTestId(/button-/);
+      expect(buttons.length).toBeGreaterThan(0);
+    });
+
+    it("passes error info to the ErrorScreen component", () => {
+      const customErrorMessage = "Very specific error message";
+
+      const { getByTestId } = render(
+        <ErrorBoundary>
+          <TestComponent error errorMessage={customErrorMessage} />
+        </ErrorBoundary>
+      );
+
+      // The error info should be visible in the UI
+      expect(getByTestId("error-message")).toBeTruthy();
+    });
+  });
+});

package/App/ErrorBoundary/__tests__/store.test.js

@@ -0,0 +1,143 @@
+import { act, renderHook } from "@testing-library/react-hooks";
+import { useErrorStore } from "../store";
+
+describe("Error Store", () => {
+  beforeEach(() => {
+    act(() => {
+      useErrorStore.getState().dismissError();
+    });
+  });
+
+  describe("Initial state", () => {
+    it("should have correct default values", () => {
+      const { result } = renderHook(() => useErrorStore());
+
+      expect(result.current).toMatchObject({
+        hasError: false,
+        error: undefined,
+        info: undefined,
+        recoverable: true,
+        setError: expect.any(Function),
+        dismissError: expect.any(Function),
+      });
+    });
+  });
+
+  describe("setError action", () => {
+    it("should set error state with provided values", () => {
+      const testError = new Error("Test error");
+      const testInfo = "Test error info";
+      const isRecoverable = true;
+
+      const { result } = renderHook(() => useErrorStore());
+
+      act(() => {
+        result.current.setError(testError, testInfo, isRecoverable);
+      });
+
+      expect(result.current).toMatchObject({
+        hasError: true,
+        error: testError,
+        info: testInfo,
+        recoverable: isRecoverable,
+        setError: expect.any(Function),
+        dismissError: expect.any(Function),
+      });
+    });
+
+    it("should set non-recoverable error when specified", () => {
+      const testError = new Error("Test error");
+      const testInfo = "Test error info";
+      const isRecoverable = false;
+
+      const { result } = renderHook(() => useErrorStore());
+
+      act(() => {
+        result.current.setError(testError, testInfo, isRecoverable);
+      });
+
+      expect(result.current).toMatchObject({
+        recoverable: false,
+      });
+    });
+
+    it("should default to recoverable error when not specified", () => {
+      const testError = new Error("Test error");
+      const testInfo = "Test error info";
+
+      const { result } = renderHook(() => useErrorStore());
+
+      act(() => {
+        result.current.setError(testError, testInfo);
+      });
+
+      expect(result.current).toMatchObject({
+        recoverable: true,
+      });
+    });
+  });
+
+  describe("dismissError action", () => {
+    it("should reset error state to defaults", () => {
+      const testError = new Error("Test error");
+      const { result } = renderHook(() => useErrorStore());
+
+      act(() => {
+        result.current.setError(testError, "info", false);
+      });
+
+      expect(result.current).toMatchObject({
+        hasError: true,
+        recoverable: false,
+      });
+
+      act(() => {
+        result.current.dismissError();
+      });
+
+      expect(result.current).toMatchObject({
+        hasError: false,
+        error: undefined,
+        info: undefined,
+        recoverable: true,
+        setError: expect.any(Function),
+        dismissError: expect.any(Function),
+      });
+    });
+  });
+
+  describe("Direct store access via API", () => {
+    it("should allow direct access to store outside React components", () => {
+      act(() => {
+        useErrorStore
+          .getState()
+          .setError(new Error("API error"), "API info", false);
+      });
+
+      const { result } = renderHook(() => useErrorStore());
+
+      expect(result.current).toMatchObject({
+        hasError: true,
+        error: expect.objectContaining({ message: "API error" }),
+        info: "API info",
+        recoverable: false,
+      });
+    });
+
+    it("should allow clearing errors via API", () => {
+      act(() => {
+        useErrorStore.getState().setError(new Error("API error"), "API info");
+      });
+
+      act(() => {
+        useErrorStore.getState().dismissError();
+      });
+
+      const { result } = renderHook(() => useErrorStore());
+
+      expect(result.current).toMatchObject({
+        hasError: false,
+      });
+    });
+  });
+});

package/App/ErrorBoundary/index.tsx

@@ -1,42 +1,66 @@
 import * as React from "react";
+import pick from "lodash/pick";
 
 import { coreLogger } from "@applicaster/zapp-react-native-utils/logger";
 import { ErrorScreen } from "@applicaster/zapp-react-native-ui-components/Components/ErrorScreen";
 
+import { useErrorStore } from "./store";
+import * as QuickBrickManager from "@applicaster/zapp-react-native-bridge/QuickBrick";
+
 const errorBoundaryLogger = coreLogger.addSubsystem("react_error-boundary");
 
 type Props = {
   children: React.ReactNode;
+  recoverable?: boolean;
 };
 
-type State = {
-  hasError: boolean;
-  error?: Error;
-  info?: string;
+type ErrorBoundaryContentProps = {
+  children: React.ReactNode;
 };
 
-export class ErrorBoundary extends React.Component<Props, State> {
-  state: State = {
-    hasError: false,
-    error: undefined,
-  };
+const restartApp = () => {
+  QuickBrickManager.sendQuickBrickEvent(
+    QuickBrickManager.QUICK_BRICK_EVENTS.FORCE_APP_RELOAD
+  );
+};
 
-  componentDidCatch(error, info) {
-    errorBoundaryLogger.error({ error, data: info, message: error.message });
-    this.setState({ hasError: true, error, info });
+const restartButton = {
+  text: "Restart the app",
+  onPress: restartApp,
+};
+
+const buttons = [restartButton];
+
+const ErrorBoundaryContent: React.FC<ErrorBoundaryContentProps> = ({
+  children,
+}) => {
+  const { hasError, dismissError, info } = pick(
+    useErrorStore((state) => state),
+    ["hasError", "dismissError", "info"]
+  );
+
+  if (hasError) {
+    return (
+      <ErrorScreen
+        dismissError={dismissError}
+        message={info}
+        buttons={buttons}
+      />
+    );
   }
 
-  dismissError = () => {
-    this.setState({ hasError: false });
-  };
+  return <>{children}</>;
+};
 
-  render() {
-    const { hasError } = this.state as State;
+export class ErrorBoundary extends React.Component<Props> {
+  componentDidCatch(error, info) {
+    errorBoundaryLogger.error({ error, data: info, message: error.message });
+    const { recoverable = true } = this.props;
 
-    if (hasError) {
-      return <ErrorScreen dismissError={this.dismissError} />;
-    }
+    useErrorStore.getState().setError(error, info, recoverable);
+  }
 
-    return this.props.children;
+  render() {
+    return <ErrorBoundaryContent>{this.props.children}</ErrorBoundaryContent>;
   }
 }

package/App/ErrorBoundary/store.ts

@@ -0,0 +1,26 @@
+import { create } from "zustand";
+
+type ErrorState = {
+  hasError: boolean;
+  error?: Error;
+  info?: string;
+  recoverable: boolean;
+  setError: (error: Error, info: string, recoverable?: boolean) => void;
+  dismissError: () => void;
+};
+
+export const useErrorStore = create<ErrorState>((set) => ({
+  hasError: false,
+  error: undefined,
+  info: undefined,
+  recoverable: true,
+  setError: (error: Error, info: string, recoverable = true) =>
+    set({ hasError: true, error, info, recoverable }),
+  dismissError: () =>
+    set({
+      hasError: false,
+      error: undefined,
+      info: undefined,
+      recoverable: true,
+    }),
+}));

package/App/LoadingOverlay/LoadingOverlayManager.tsx

@@ -0,0 +1,27 @@
+import { BehaviorSubject } from "rxjs";
+
+class LoadingOverlayManager {
+  visibilitySubject: BehaviorSubject<boolean>;
+
+  constructor() {
+    this.visibilitySubject = new BehaviorSubject(false);
+  }
+
+  show() {
+    this.visibilitySubject.next(true);
+  }
+
+  hide() {
+    this.visibilitySubject.next(false);
+  }
+
+  onVisibilityStateChange(cb: (value: boolean) => void) {
+    return this.visibilitySubject.subscribe(cb);
+  }
+
+  get visibility(): boolean {
+    return this.visibilitySubject.value;
+  }
+}
+
+export const loadingOverlayManager = new LoadingOverlayManager();

package/App/LoadingOverlay/index.tsx

@@ -0,0 +1,49 @@
+import * as React from "react";
+import { View, StyleSheet } from "react-native";
+import { focusManager } from "@applicaster/zapp-react-native-utils/appUtils/focusManager";
+import { isVizioPlatform } from "@applicaster/zapp-react-native-utils/reactUtils";
+import { Spinner } from "@applicaster/zapp-react-native-ui-components/Components/Spinner";
+import { useTheme } from "@applicaster/zapp-react-native-utils/theme";
+
+import { useLoadingOverlayVisibility } from "./useLoadingOverlayVisibility";
+
+export { loadingOverlayManager } from "./LoadingOverlayManager";
+
+const styles = StyleSheet.create({
+  container: {
+    opacity: 0.5,
+    alignItems: "center",
+    justifyContent: "center",
+    zIndex: 100,
+    flex: 1,
+  },
+});
+
+const LoadingOverlayComponent = () => {
+  const visible = useLoadingOverlayVisibility();
+  const theme = useTheme();
+
+  const backgroundColor = React.useMemo(() => {
+    return theme?.app_background_color || "black";
+  }, [theme?.app_background_color]);
+
+  React.useEffect(() => {
+    if (visible) {
+      focusManager.disableFocus();
+    } else {
+      focusManager.enableFocus();
+    }
+  }, [visible]);
+
+  return visible ? (
+    <View
+      style={[StyleSheet.absoluteFill, styles.container, { backgroundColor }]}
+    >
+      <Spinner />
+    </View>
+  ) : null;
+};
+
+export const LoadingOverlay = isVizioPlatform()
+  ? LoadingOverlayComponent
+  : () => null;

package/App/LoadingOverlay/useLoadingOverlayVisibility.tsx

@@ -0,0 +1,18 @@
+import * as React from "react";
+import { loadingOverlayManager } from "./LoadingOverlayManager";
+
+export const useLoadingOverlayVisibility = () => {
+  const [visible, setVisible] = React.useState(
+    loadingOverlayManager.visibility
+  );
+
+  React.useEffect(() => {
+    const listener = loadingOverlayManager.onVisibilityStateChange(setVisible);
+
+    return () => {
+      listener.unsubscribe();
+    };
+  }, []);
+
+  return visible;
+};

package/App/ModalProvider/ModalBottomSheet/index.tsx

@@ -4,7 +4,7 @@ import { platformSelect } from "@applicaster/zapp-react-native-utils/reactUtils"
 import { useSafeAreaInsets } from "react-native-safe-area-context";
 
 import React, { useCallback, useEffect, useMemo, useState } from "react";
-import { View, StyleSheet, Keyboard } from "react-native";
+import { Keyboard, StyleSheet, View } from "react-native";
 
 import { Overlay } from "./Overlay";
 import { ModalBottomSheetFrame } from "./ModalBottomSheetFrame";
@@ -83,6 +83,8 @@ export function ModalBottomSheet(props: Props) {
     [isTablet]
   );
 
+  const modalVisible = visible && sheetHeight > 0;
+
   return (
     <View style={styles.container}>
       <Overlay
@@ -98,7 +100,7 @@ export function ModalBottomSheet(props: Props) {
         paddingBottom={bottomOffset}
         maxWidth={maxWidth}
         dimensions={dimensions}
-        visible={visible && sheetHeight > 0}
+        visible={modalVisible}
         closeToast={dismiss}
         handleProps={{
           enabled: sheetHandleEnabled,

package/App/ModalProvider/index.tsx

@@ -35,13 +35,12 @@ export function ModalProvider() {
 
   const pathname = `${ROUTE_TYPES.MODAL}/${modalScreenProps?.screenId}`;
 
+  const shouldShowModal = modalVisible && modalState?.visible;
+
   return (
     <PathnameContext.Provider value={pathname}>
       <ScreenContextProvider pathname={pathname}>
-        <ModalPresenter
-          visible={modalVisible && modalState?.visible}
-          {...modalState?.options}
-        >
+        <ModalPresenter visible={shouldShowModal} {...modalState?.options}>
           <ModalChildrenWrapper>
             <ModalContent modalScreenProps={modalScreenProps} />
           </ModalChildrenWrapper>