@applicaster/quick-brick-core 13.0.0-alpha.6179233127 → 13.0.0-alpha.6400875052

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/ModalProvider/ModalBottomSheet/Overlay.tsx

@@ -2,7 +2,7 @@ import React from "react";
 import { StyleSheet, TouchableOpacity, Easing, View } from "react-native";
 
 import { AnimatedInOut } from "@applicaster/zapp-react-native-ui-components/Components/AnimatedInOut";
-import { useNavigation } from "@applicaster/zapp-react-native-utils/reactHooks/navigation";
+import { dismissModal } from "@applicaster/zapp-react-native-utils/modalState";
 
 type Props = {
   overlayColor: string;
@@ -35,21 +35,19 @@ const fadeInAnimation = {
   delay,
 };
 
-const animationConfig = (onAnimationEnd) => ({
+const animationConfig = {
   in: fadeInAnimation,
   out: {
     ...fadeInAnimation,
-    onAnimationEnd,
+    onAnimationEnd: dismissModal,
   },
-});
+};
 
 export function Overlay(props: Props) {
-  const navigator = useNavigation();
-
   return (
     <AnimatedInOut
       visible={props.visible}
-      animationConfig={animationConfig(navigator.closeModalBottomSheet)}
+      animationConfig={animationConfig}
       staticStyles={styles.container}
     >
       <TouchableOpacity

package/App/ModalProvider/index.tsx

@@ -6,10 +6,10 @@ import { ModalChildrenWrapper } from "./ModalChildrenWrapper";
 import { PathnameContext } from "@applicaster/zapp-react-native-ui-components/Contexts/PathnameContext";
 import { ScreenContextProvider } from "@applicaster/zapp-react-native-ui-components/Contexts/ScreenContext";
 import { ROUTE_TYPES } from "@applicaster/zapp-react-native-utils/navigationUtils/routeTypes";
-import { useModalStore } from "@applicaster/zapp-react-native-utils/modalState";
+import { useModalStoreState } from "@applicaster/zapp-react-native-utils/modalState";
 
 export function ModalProvider() {
-  const { modalState } = useModalStore();
+  const modalState = useModalStoreState();
 
   const [modalVisible, setModalVisible] = React.useState(false);
   const [modalShown, setModalShown] = React.useState(false);

package/App/NavigationProvider/NavigationProvider.tsx

@@ -64,7 +64,11 @@ import { findParent } from "@applicaster/zapp-react-native-ui-components/Context
 import { ZappPipesEntryContext } from "@applicaster/zapp-react-native-ui-components/Contexts";
 import { PlayNextState } from "@applicaster/zapp-react-native-utils/appUtils/playerManager/OverlayObserver/OverlaysObserver";
 import { inflateUrl } from "@applicaster/zapp-react-native-ui-components/Components/LinkHandler/LinkHandler";
-import { useModalStore } from "@applicaster/zapp-react-native-utils/modalState";
+import {
+  dismissModal,
+  modalStore,
+  openModal,
+} from "@applicaster/zapp-react-native-utils/modalState";
 import { useSubscriberFor } from "@applicaster/zapp-react-native-utils/reactHooks/useSubscriberFor";
 import { QBUIComponentEvents } from "@applicaster/zapp-react-native-ui-components/events";
 import { Hook } from "@applicaster/zapp-react-native-utils/appUtils/HooksManager/Hook";
@@ -120,8 +124,6 @@ export function NavigationProvider({ children }: Props) {
 
   const { context } = React.useContext(ZappPipesEntryContext.Context);
 
-  const { openModal, dismissModal } = useModalStore();
-
   const playNextOverlayState = React.useRef();
 
   const online = useConnectionInfo(true);
@@ -147,7 +149,7 @@ export function NavigationProvider({ children }: Props) {
   );
 
   const getModalState: () => ModalState = () => {
-    const { modalState } = useModalStore.getState();
+    const { modalState } = modalStore.getState();
 
     return modalState;
   };
@@ -391,7 +393,7 @@ export function NavigationProvider({ children }: Props) {
     }
 
     if (hookPlugin.isModalHook()) {
-      navigator.openModal({
+      openModal({
         item: payload,
         props: { screenType: "hooks" },
         options: { ModalContainer: hookPlugin.getModalContainer() },
@@ -411,7 +413,7 @@ export function NavigationProvider({ children }: Props) {
     }
 
     if (hookPlugin.isModalHook()) {
-      navigator.dismissModal();
+      dismissModal();
     } else {
       goBack(true, true);
     }
@@ -423,7 +425,7 @@ export function NavigationProvider({ children }: Props) {
     closeLoadingOverlay();
   };
 
-  const handleHookCancel = ({ hookPlugin, callback }, dispose) => {
+  const handleHookCancel = ({ hookPlugin, callback, abort }, dispose) => {
     dispose();
     setStartUpHooks(false);
 
@@ -431,10 +433,12 @@ export function NavigationProvider({ children }: Props) {
       callback();
     }
 
-    if (hookPlugin.isModalHook()) {
-      navigator.dismissModal();
-    } else {
-      goBack(true, true);
+    if (!abort) {
+      if (hookPlugin.isModalHook()) {
+        dismissModal();
+      } else {
+        goBack(true, true);
+      }
     }
 
     closeLoadingOverlay();
@@ -444,7 +448,7 @@ export function NavigationProvider({ children }: Props) {
     callback?.();
 
     if (hookPlugin.isModalHook()) {
-      navigator.dismissModal();
+      dismissModal();
     }
   };
 
@@ -681,33 +685,6 @@ export function NavigationProvider({ children }: Props) {
     }
   }, [state?.options?.videoModal?.previousMode]);
 
-  const openModalBottomSheet = React.useCallback(
-    ({
-      ModalBottomSheetContent,
-      modalBottomSheetContentProps,
-      props = {},
-      options = {},
-    }) => {
-      openModal({
-        item: {
-          ModalBottomSheetContent,
-          modalBottomSheetContentProps,
-        },
-        props,
-        options: {
-          animationType: "none",
-          animated: false,
-          ...options,
-        },
-      });
-    },
-    [openModal]
-  );
-
-  const closeModalBottomSheet = React.useCallback(() => {
-    dismissModal();
-  }, [dismissModal]);
-
   const getNestedEntry = () => state?.location?.state?.nested?.entry ?? null;
 
   // It will only work for the regular stack and pathname, It won't work for modals
@@ -745,11 +722,9 @@ export function NavigationProvider({ children }: Props) {
       getNestedEntry,
       key: state?.location?.key,
       modalData: state.stack.modal?.state ?? null,
-      openModal,
-      dismissModal,
+      openModal: openModal,
+      dismissModal: dismissModal,
       getModalState,
-      openModalBottomSheet,
-      closeModalBottomSheet,
       videoModalState: state.options.videoModal,
       openVideoModal,
       closeVideoModal,

package/App/index.tsx

@@ -72,11 +72,11 @@ const App = ({
                 </SplashLoader>
                 <ModalProvider />
               </URLSchemeListener>
-              <LogicAggregatorContainer
-                components={[InteractionManager, ApplyScreenHooks]}
-              />
               <LoadingOverlay />
             </ErrorBoundary>
+            <LogicAggregatorContainer
+              components={[InteractionManager, ApplyScreenHooks]}
+            />
           </AppContainer>
         </SafeAreaProvider>
       </ThemeManager>

package/App/remoteContextReloader/getRemoteContextData/getNativeRemoteContextData.ts

@@ -1,4 +1,5 @@
 import * as R from "ramda";
+import isEmpty from "lodash/isEmpty";
 import { Dimensions, NativeModules } from "react-native";
 import { loadAppContextData } from "@applicaster/zapp-react-native-redux";
 import { isTablet } from "@applicaster/zapp-react-native-utils/reactHooks";
@@ -10,6 +11,7 @@ import { logger } from "@applicaster/zapp-react-native-utils/logger";
 import { ACTIVE_LAYOUT_ID_STORAGE_KEY } from "../consts";
 const { AppLoaderBridge } = NativeModules;
 import { localStorage } from "@applicaster/zapp-react-native-bridge/ZappStorage/LocalStorage";
+import { useErrorStore } from "../../ErrorBoundary/store";
 
 export async function getNativeRemoteContextData(
   dispatch,
@@ -58,6 +60,18 @@ export async function getNativeRemoteContextData(
 
   const layout = await getPromiseForType("layout");
 
+  const layoutLoadingErrorMessage = "Failed to load layout data";
+
+  if (isEmpty(layout)) {
+    useErrorStore
+      .getState()
+      .setError(
+        new Error(layoutLoadingErrorMessage),
+        layoutLoadingErrorMessage,
+        false
+      );
+  }
+
   const apiVersion = layout?.layout?.["api_version"]; // Taken from remote configuration
 
   dispatch(appDataActions.merge({ layoutVersion: apiVersion || "v1" }));

package/package.json

@@ -1,11 +1,10 @@
 {
   "name": "@applicaster/quick-brick-core",
-  "version": "13.0.0-alpha.6179233127",
+  "version": "13.0.0-alpha.6400875052",
   "description": "Core package for Applicaster's Quick Brick App",
   "main": "index.js",
   "types": "index.d.ts",
   "scripts": {
-    "test": "jest -w=2",
     "build": "echo 'skipping ts build for core packages'"
   },
   "repository": {
@@ -29,13 +28,13 @@
   },
   "homepage": "https://github.com/applicaster/quickbrick#readme",
   "dependencies": {
-    "@applicaster/applicaster-types": "13.0.0-alpha.6179233127",
-    "@applicaster/quick-brick-core-plugins": "13.0.0-alpha.6179233127",
-    "@applicaster/zapp-pipes-v2-client": "13.0.0-alpha.6179233127",
-    "@applicaster/zapp-react-native-bridge": "13.0.0-alpha.6179233127",
-    "@applicaster/zapp-react-native-redux": "13.0.0-alpha.6179233127",
-    "@applicaster/zapp-react-native-ui-components": "13.0.0-alpha.6179233127",
-    "@applicaster/zapp-react-native-utils": "13.0.0-alpha.6179233127",
+    "@applicaster/applicaster-types": "13.0.0-alpha.6400875052",
+    "@applicaster/quick-brick-core-plugins": "13.0.0-alpha.6400875052",
+    "@applicaster/zapp-pipes-v2-client": "13.0.0-alpha.6400875052",
+    "@applicaster/zapp-react-native-bridge": "13.0.0-alpha.6400875052",
+    "@applicaster/zapp-react-native-redux": "13.0.0-alpha.6400875052",
+    "@applicaster/zapp-react-native-ui-components": "13.0.0-alpha.6400875052",
+    "@applicaster/zapp-react-native-utils": "13.0.0-alpha.6400875052",
     "atob": "^2.1.2",
     "axios": "^0.28.0",
     "btoa": "^1.2.1",

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

@@ -1,55 +0,0 @@
-import React from "react";
-import { View, Text } from "react-native";
-import { render } from "@testing-library/react-native";
-
-import { ErrorBoundary } from "../index";
-
-const TestComponent = ({ error }: { error: any }) => {
-  if (error) {
-    throw new Error("error !!");
-  }
-
-  return (
-    <View>
-      <Text>all is good</Text>
-    </View>
-  );
-};
-
-describe("<ErrorBoundary />", () => {
-  describe("when there is no error", () => {
-    it("renders correctly", () => {
-      const { getByText } = render(
-        <ErrorBoundary>
-          <TestComponent />
-        </ErrorBoundary>
-      );
-
-      expect(getByText("all is good")).toBeTruthy();
-    });
-  });
-
-  describe("When an error is caught", () => {
-    const _consoleLog = console.log;
-
-    beforeAll(() => {
-      console.log = jest.fn();
-    });
-
-    afterAll(() => {
-      console.log = _consoleLog;
-    });
-
-    it("renders error state correctly", () => {
-      const { getByText } = render(
-        <ErrorBoundary>
-          <TestComponent error />
-        </ErrorBoundary>
-      );
-
-      // Note: You'll need to verify what your ErrorBoundary actually renders in error state
-      // This is just an example assertion:
-      expect(getByText(/error/i)).toBeTruthy();
-    });
-  });
-});

package/App/ModalProvider/ModalChildrenWrapper/index.web.ts

@@ -1 +0,0 @@
-export { Fragment as ModalChildrenWrapper } from "react";