@pega/sdk 0.0.4 → 0.0.6

package/templates/react-native-sdk-reference/src/components/infra/Assignment/Assignment.tsx

@@ -0,0 +1,348 @@
+import { PropsWithChildren, useEffect, useState } from 'react';
+import { View } from 'react-native';
+import { Snackbar } from 'react-native-paper';
+import AssignmentCard from '../AssignmentCard';
+import MultiStep from '../MultiStep';
+import { PConnProps } from '../../../types/PConnProps';
+
+interface AssignmentProps extends PConnProps {
+  // If any, enter additional props that only exist on this component
+  itemKey: string;
+  isInModal?: boolean;
+  banners?: any[];
+  actionButtons?: any[];
+}
+
+export default function Assignment(props: PropsWithChildren<AssignmentProps>) {
+  const { getPConnect, children, itemKey = '', isInModal = false, banners = [] } = props;
+  const thePConn = getPConnect();
+
+  const [bHasNavigation, setHasNavigation] = useState(false);
+  const [actionButtons, setActionButtons] = useState([]);
+  const [bIsVertical, setIsVertical] = useState(false);
+  const [arCurrentStepIndicies, setArCurrentStepIndicies] = useState<any[]>([]);
+  const [arNavigationSteps, setArNavigationSteps] = useState<any[]>([]);
+
+  const actionsAPI = thePConn.getActionsApi();
+  const localizedVal = PCore.getLocaleUtils().getLocaleValue;
+  const localeCategory = 'Assignment';
+  const localeReference = `${getPConnect().getCaseInfo().getClassName()}!CASE!${getPConnect()
+    .getCaseInfo()
+    .getName()}`.toUpperCase();
+
+  // store off bound functions to above pointers
+  const finishAssignment = actionsAPI.finishAssignment.bind(actionsAPI);
+  const navigateToStep = actionsAPI.navigateToStep.bind(actionsAPI);
+  const cancelAssignment = actionsAPI.cancelAssignment.bind(actionsAPI);
+  const saveAssignment = actionsAPI.saveAssignment?.bind(actionsAPI);
+  const cancelCreateStageAssignment = actionsAPI.cancelCreateStageAssignment.bind(actionsAPI);
+  const approveCase = actionsAPI.approveCase?.bind(actionsAPI);
+  const rejectCase = actionsAPI.rejectCase?.bind(actionsAPI);
+  // const showPage = actionsAPI.showPage.bind(actionsAPI);
+
+  const [showSnackbar, setShowSnackbar] = useState(false);
+  const [snackbarMessage, setSnackbarMessage] = useState('');
+
+  function findCurrentIndicies(arStepperSteps: any[], arIndicies: number[], depth: number): number[] {
+    let count = 0;
+    arStepperSteps.forEach((step) => {
+      if (step.visited_status === 'current') {
+        arIndicies[depth] = count;
+
+        // add in
+        step.step_status = '';
+      } else if (step.visited_status === 'success') {
+        count += 1;
+        step.step_status = 'completed';
+      } else {
+        count += 1;
+        step.step_status = '';
+      }
+
+      if (step.steps) {
+        arIndicies = findCurrentIndicies(step.steps, arIndicies, depth + 1);
+      }
+    });
+
+    return arIndicies;
+  }
+
+  function getStepsInfo(steps: any, formedSteps: any = []) {
+    steps.forEach((step) => {
+      if (step.name) {
+        step.name = PCore.getLocaleUtils().getLocaleValue(step.name, undefined, localeReference);
+      }
+      if (step.steps) {
+        formedSteps = getStepsInfo(step.steps, formedSteps);
+      } else {
+        formedSteps.push(step);
+      }
+    });
+    return formedSteps;
+  }
+
+  useEffect(() => {
+    if (children) {
+      const firstChild = Array.isArray(children) ? children[0] : children;
+      const oWorkItem = firstChild.props.getPConnect();
+      const oWorkData = oWorkItem.getDataObject();
+      const oData: any = thePConn.getDataObject(''); // 1st arg empty string until typedefs allow it to be optional
+
+      if (oWorkData?.caseInfo && oWorkData.caseInfo.assignments !== null) {
+        const oCaseInfo = oData?.caseInfo;
+
+        if (oCaseInfo && oCaseInfo.actionButtons) {
+          setActionButtons(oCaseInfo.actionButtons);
+        }
+
+        if (oCaseInfo?.navigation /* was oCaseInfo.navigation != null */) {
+          setHasNavigation(true);
+
+          if (
+            (oCaseInfo.navigation.template && oCaseInfo.navigation.template.toLowerCase() === 'standard') ||
+            oCaseInfo?.navigation?.steps?.length === 1
+          ) {
+            setHasNavigation(false);
+          } else if (oCaseInfo.navigation.template && oCaseInfo.navigation.template.toLowerCase() === 'vertical') {
+            setIsVertical(true);
+          } else {
+            setIsVertical(false);
+          }
+
+          if (oCaseInfo?.navigation?.steps) {
+            const steps = JSON.parse(JSON.stringify(oCaseInfo?.navigation?.steps));
+            const formedSteps = getStepsInfo(steps);
+            setArNavigationSteps(formedSteps);
+          }
+
+          setArCurrentStepIndicies(findCurrentIndicies(arNavigationSteps, arCurrentStepIndicies, 0));
+        }
+      }
+    }
+  }, [children]);
+
+  function showToast(message: string) {
+    const theMessage = `Assignment: ${message}`;
+
+    console.error(theMessage);
+    setSnackbarMessage(message);
+    setShowSnackbar(true);
+  }
+
+  function handleSnackbarClose() {
+    setShowSnackbar(false);
+  }
+
+  function onSaveActionSuccess(data) {
+    actionsAPI.cancelAssignment(itemKey, false).then(() => {
+      PCore.getPubSubUtils().publish(PCore.getConstants().PUB_SUB_EVENTS.CASE_EVENTS.CREATE_STAGE_SAVED, data);
+    });
+  }
+
+  function buttonPress(sAction: string, sButtonType: string) {
+    if (sButtonType === 'secondary') {
+      switch (sAction) {
+        case 'navigateToStep': {
+          const navigatePromise = navigateToStep('previous', itemKey);
+
+          navigatePromise
+            .then(() => {})
+            .catch(() => {
+              showToast(`${localizedVal('Navigation failed!', localeCategory)}`);
+            });
+
+          break;
+        }
+
+        case 'saveAssignment': {
+          const caseID = thePConn.getCaseInfo().getKey();
+          const assignmentID = thePConn.getCaseInfo().getAssignmentID();
+          const savePromise = saveAssignment(itemKey);
+
+          savePromise
+            .then(() => {
+              // @ts-ignore - Property 'c11nEnv' is private and only accessible within class 'CaseInfo'.
+              const caseType = thePConn.getCaseInfo().c11nEnv.getValue(PCore.getConstants().CASE_INFO.CASE_TYPE_ID);
+              onSaveActionSuccess({ caseType, caseID, assignmentID });
+            })
+            .catch(() => {
+              showToast(`${localizedVal('Save failed', localeCategory)}`);
+            });
+
+          break;
+        }
+
+        case 'cancelAssignment': {
+          // check if create stage (modal)
+          const { PUB_SUB_EVENTS } = PCore.getConstants();
+          const { publish } = PCore.getPubSubUtils();
+          // @ts-ignore - Property 'isAssignmentInCreateStage' is private and only accessible within class 'CaseInfo'
+          const isAssignmentInCreateStage = thePConn.getCaseInfo().isAssignmentInCreateStage();
+          const isLocalAction =
+            // @ts-ignore - Property 'isLocalAction' is private and only accessible within class 'CaseInfo'.
+            thePConn.getCaseInfo().isLocalAction() ||
+            (PCore.getConstants().CASE_INFO.IS_LOCAL_ACTION &&
+              getPConnect().getValue(PCore.getConstants().CASE_INFO.IS_LOCAL_ACTION));
+          if (isAssignmentInCreateStage && isInModal && !isLocalAction) {
+            const cancelPromise = cancelCreateStageAssignment(itemKey);
+
+            cancelPromise
+              .then((data) => {
+                publish(PUB_SUB_EVENTS.EVENT_CANCEL, data);
+              })
+              .catch(() => {
+                showToast(`${localizedVal('Cancel failed!', localeCategory)}`);
+              });
+          } else {
+            const cancelPromise = cancelAssignment(itemKey, false);
+
+            cancelPromise
+              .then((data) => {
+                publish(PUB_SUB_EVENTS.EVENT_CANCEL, data);
+              })
+              .catch(() => {
+                showToast(`${localizedVal('Cancel failed!', localeCategory)}`);
+              });
+          }
+          break;
+        }
+
+        case 'rejectCase': {
+          const rejectPromise = rejectCase(itemKey);
+
+          rejectPromise
+            .then(() => {})
+            .catch(() => {
+              showToast(`${localizedVal('Rejection failed!', localeCategory)}`);
+            });
+
+          break;
+        }
+
+        default:
+          break;
+      }
+    } else if (sButtonType === 'primary') {
+      switch (sAction) {
+        case 'finishAssignment': {
+          const finishPromise = finishAssignment(itemKey);
+
+          finishPromise
+            .then(() => {})
+            .catch(() => {
+              showToast(`${localizedVal('Submit failed!', localeCategory)}`);
+            });
+
+          break;
+        }
+
+        case 'approveCase': {
+          const approvePromise = approveCase(itemKey);
+
+          approvePromise
+            .then(() => {})
+            .catch(() => {
+              showToast(`${localizedVal('Approve failed!', localeCategory)}`);
+            });
+
+          break;
+        }
+
+        default:
+          break;
+      }
+    }
+  }
+
+  function getRefreshProps(refreshConditions) {
+    // refreshConditions cuurently supports only "Changes" event
+    if (!refreshConditions) {
+      return [];
+    }
+    return (
+      refreshConditions
+        .filter((item) => item.event && item.event === 'Changes')
+        .map((item) => [item.field, item.field?.substring(1)]) || []
+    );
+  }
+
+  // expected format of refreshConditions : [{field: ".Name", event: "Changes"}]
+  // @ts-ignore - Property 'getActionRefreshConditions' is private and only accessible within class 'CaseInfo'
+  const refreshConditions = thePConn.getCaseInfo()?.getActionRefreshConditions();
+  const context = thePConn.getContextName();
+  const pageReference = thePConn.getPageReference();
+
+  // refresh api de-registration
+  PCore.getRefreshManager().deRegisterForRefresh(context);
+
+  // refresh api registration
+  const refreshProps = getRefreshProps(refreshConditions);
+  const caseKey = thePConn.getCaseInfo().getKey();
+  const refreshOptions = {
+    autoDetectRefresh: true,
+    preserveClientChanges: false,
+  };
+  if (refreshProps.length > 0) {
+    refreshProps.forEach((prop) => {
+      PCore.getRefreshManager().registerForRefresh(
+        'PROP_CHANGE',
+        thePConn.getActionsApi().refreshCaseView.bind(thePConn.getActionsApi(), caseKey, '', pageReference, {
+          ...refreshOptions,
+          refreshFor: prop[0],
+        }),
+        `${pageReference}.${prop[1]}`,
+        `${context}/${pageReference}`,
+        context,
+      );
+    });
+  }
+
+  return (
+    <View>
+      {banners}
+      {bHasNavigation ? (
+        <>
+          <MultiStep
+            getPConnect={getPConnect}
+            itemKey={itemKey}
+            actionButtons={actionButtons}
+            onButtonPress={buttonPress}
+            bIsVertical={bIsVertical}
+            arCurrentStepIndicies={arCurrentStepIndicies}
+            arNavigationSteps={arNavigationSteps}
+          >
+            {children}
+          </MultiStep>
+          <Snackbar
+            visible={showSnackbar}
+            duration={3000}
+            onDismiss={handleSnackbarClose}
+            action={{
+              label: 'Close',
+              onPress: handleSnackbarClose,
+            }}
+          >
+            {snackbarMessage}
+          </Snackbar>
+        </>
+      ) : (
+        <>
+          <AssignmentCard getPConnect={getPConnect} actionButtons={actionButtons} onButtonPress={buttonPress}>
+            {children}
+          </AssignmentCard>
+          <Snackbar
+            visible={showSnackbar}
+            duration={3000}
+            onDismiss={handleSnackbarClose}
+            action={{
+              label: 'Close',
+              onPress: handleSnackbarClose,
+            }}
+          >
+            {snackbarMessage}
+          </Snackbar>
+        </>
+      )}
+    </View>
+  );
+}

package/templates/react-native-sdk-reference/src/components/infra/Assignment/index.tsx

@@ -0,0 +1 @@
+export { default } from './Assignment';

package/templates/react-native-sdk-reference/src/components/infra/AssignmentCard/AssignmentCard.tsx

@@ -0,0 +1,56 @@
+import { PropsWithChildren, useEffect, useState } from 'react';
+import { View } from 'react-native';
+import { KeyboardAwareScrollView } from 'react-native-keyboard-aware-scroll-view';
+
+import { PConnProps } from '../../../types/PConnProps';
+import ActionButtons from '../ActionButtons';
+
+interface AssignmentCardProps extends PConnProps {
+  // If any, enter additional props that only exist on this component
+  actionButtons: any;
+  onButtonPress: any;
+  showSteps?: boolean;
+  steps?: any[];
+}
+
+export default function AssignmentCard(props: PropsWithChildren<AssignmentCardProps>) {
+  const { children, actionButtons, onButtonPress } = props;
+
+  const [arMainButtons, setArMainButtons] = useState([]);
+  const [arSecondaryButtons, setArSecondaryButtons] = useState([]);
+
+  useEffect(() => {
+    if (actionButtons) {
+      setArMainButtons(actionButtons.main);
+      setArSecondaryButtons(actionButtons.secondary);
+    }
+  }, [actionButtons]);
+
+  function buttonPress(sAction, sType) {
+    onButtonPress(sAction, sType);
+  }
+
+  return (
+    <View
+      style={{
+        display: 'flex',
+        flexDirection: 'column',
+        justifyContent: 'space-between',
+        height: '100%',
+        paddingHorizontal: 16,
+        paddingTop: 10,
+      }}
+    >
+      <KeyboardAwareScrollView showsVerticalScrollIndicator={false} style={{ flex: 1, height: '100%', paddingTop: 10 }}>
+        {children}
+      </KeyboardAwareScrollView>
+      {arMainButtons && arSecondaryButtons && (
+        <ActionButtons
+          arMainButtons={arMainButtons}
+          arSecondaryButtons={arSecondaryButtons}
+          onButtonPress={buttonPress}
+        />
+      )}
+    </View>
+  );
+}

package/templates/react-native-sdk-reference/src/components/infra/AssignmentCard/index.tsx

@@ -0,0 +1 @@
+export { default } from './AssignmentCard';

package/templates/react-native-sdk-reference/src/components/infra/Containers/FlowContainer/FlowContainer.tsx

@@ -0,0 +1,57 @@
+import { useEffect, useMemo, useState } from 'react';
+import { View } from 'react-native';
+import Assignment from '../../Assignment';
+import { withSimpleViewContainerRenderer } from '../../Containers/SimpleView';
+import { addContainerItem } from '../../Containers/ViewContainer/helper';
+import { isContainerInitialized } from '../../Containers/helper';
+import { hasContainerItems } from './helpers';
+
+const ERROR_WHILE_RENDERING = 'ERROR_WHILE_RENDERING';
+
+function FlowContainer(props: any) {
+  const { subscribe } = PCore.getPubSubUtils();
+  const [hasError, setHasError] = useState(false);
+
+  const {
+    getPConnect: getPConnectOfFlowContainer,
+    rootViewElement,
+    getPConnectOfActiveContainerItem,
+    activeContainerItemID: itemKey,
+  } = props;
+
+  const pConnectOfFlowContainer = getPConnectOfFlowContainer();
+  const isInitialized = isContainerInitialized(pConnectOfFlowContainer);
+  const hasItems = isInitialized && hasContainerItems(pConnectOfFlowContainer);
+  const getPConnect = getPConnectOfActiveContainerItem || getPConnectOfFlowContainer;
+
+  useEffect(() => {
+    // @ts-ignore - Property 'getMetadata' is private and only accessible within class 'C11nEnv'
+    if (isInitialized && pConnectOfFlowContainer.getMetadata().children && !hasItems) {
+      // ensuring not to add container items, if container already has items
+      // because during multi doc mode, we will have container items already in store
+      addContainerItem(pConnectOfFlowContainer);
+    }
+  }, [isInitialized, hasItems]);
+
+  subscribe(
+    ERROR_WHILE_RENDERING,
+    () => {
+      setHasError(true);
+    },
+    `${ERROR_WHILE_RENDERING}-fc-${getPConnect().getContextName()}`,
+    false,
+    getPConnect().getContextName(),
+  );
+
+  const assignmentForm = useMemo(() => {
+    return (
+      <Assignment getPConnect={getPConnect} itemKey={itemKey}>
+        {rootViewElement}
+      </Assignment>
+    );
+  }, [getPConnect, props, hasError]);
+
+  return <View>{assignmentForm}</View>;
+}
+
+export default withSimpleViewContainerRenderer(FlowContainer);

package/templates/react-native-sdk-reference/src/components/infra/Containers/FlowContainer/helpers.ts

@@ -0,0 +1,137 @@
+//  Moved PCore.getConstants() into each function in which it's used until we can
+//  make sure that this code isn't run until PCore is defined (after onPCoreReady)
+// const { CASE_INFO } = PCore.getConstants();
+
+export const addContainerItem = (pConnect) => {
+  const containerManager = pConnect.getContainerManager();
+  const contextName = pConnect.getContextName(); // here we will get parent context name, as flow container is child of view container
+  const caseViewMode = pConnect.getValue('context_data.caseViewMode');
+
+  let key;
+  let flowName;
+
+  if (caseViewMode !== 'review') {
+    const target = contextName.substring(0, contextName.lastIndexOf('_'));
+    const activeContainerItemID = PCore.getContainerUtils().getActiveContainerItemName(target);
+    const containerItemData = PCore.getContainerUtils().getContainerItemData(target, activeContainerItemID);
+
+    if (containerItemData) {
+      ({ key, flowName } = containerItemData);
+    }
+  }
+
+  containerManager.addContainerItem({
+    semanticURL: '',
+    key,
+    flowName,
+    caseViewMode: 'perform',
+    resourceType: 'ASSIGNMENT',
+    data: pConnect.getDataObject(contextName),
+  });
+};
+
+export const hasContainerItems = (pConnect) => {
+  const contextName = pConnect.getContextName();
+  const containerName = pConnect.getContainerName();
+  return PCore.getContainerUtils().hasContainerItems(`${contextName}/${containerName}`);
+};
+
+export const getActiveCaseActionName = (pConnect) => {
+  const { CASE_INFO } = PCore.getConstants();
+  const caseActions = pConnect.getValue(CASE_INFO.CASE_INFO_ACTIONS);
+  const activeActionID = pConnect.getValue(CASE_INFO.ACTIVE_ACTION_ID);
+  const activeAction = caseActions.find((action) => action.ID === activeActionID);
+  return activeAction?.name || '';
+};
+
+export const getFirstCaseActionName = (pConnect) => {
+  const { CASE_INFO } = PCore.getConstants();
+  const caseActions = pConnect.getValue(CASE_INFO.CASE_INFO_ACTIONS);
+  return caseActions[0]?.name || '';
+};
+
+export const hasNotificationMessages = (pConnect) => {
+  return !!pConnect.getValue('caseMessages');
+};
+
+export const isCaseWideLocalAction = (pConnect) => {
+  const { CASE_INFO } = PCore.getConstants();
+  const actionID = pConnect.getValue(CASE_INFO.ACTIVE_ACTION_ID);
+  const caseActions = pConnect.getValue(CASE_INFO.CASE_INFO_ACTIONS);
+  if (caseActions && actionID) {
+    const activeAction = caseActions.find((caseAction) => caseAction.ID === actionID);
+    return activeAction?.type === 'Case';
+  }
+  return false;
+};
+
+export const getChildCaseAssignments = (pConnect) => {
+  const { CASE_INFO } = PCore.getConstants();
+  const childCases = pConnect.getValue(CASE_INFO.CHILD_ASSIGNMENTS);
+  let allAssignments = [];
+  if (childCases && childCases.length > 0) {
+    childCases.forEach(({ assignments, Name }) => {
+      if (assignments) {
+        const childCaseAssignments = assignments.map((assignment) => ({
+          ...assignment,
+          caseName: Name,
+        }));
+        allAssignments = allAssignments.concat(childCaseAssignments);
+      }
+    });
+  }
+  return allAssignments;
+};
+
+export const hasAssignments = (pConnect) => {
+  const { CASE_INFO } = PCore.getConstants();
+  const assignments = pConnect.getValue(CASE_INFO.D_CASE_ASSIGNMENTS_RESULTS);
+  const childCasesAssignments = getChildCaseAssignments(pConnect);
+
+  if (assignments || childCasesAssignments || isCaseWideLocalAction(pConnect)) {
+    return true;
+  }
+  return false;
+};
+
+export const showBanner = (getPConnect) => {
+  const pConnect = getPConnect();
+  return hasNotificationMessages(pConnect) || !hasAssignments(pConnect);
+};
+
+export const showTodo = (pConnect) => {
+  const caseViewMode = pConnect.getValue('context_data.caseViewMode');
+  return caseViewMode !== 'perform';
+};
+
+export const isRenderWithToDoWrapper = (getPConnect, options) => {
+  const pConnect = getPConnect();
+  const { showWithToDo } = options;
+  return showWithToDo && (!isCaseWideLocalAction(pConnect) || showTodo(pConnect));
+};
+
+export const getToDoAssignments = (pConnect) => {
+  const { CASE_INFO } = PCore.getConstants();
+  const caseActions = pConnect.getValue(CASE_INFO.CASE_INFO_ACTIONS);
+  const assignmentLabel = pConnect.getValue(CASE_INFO.ASSIGNMENT_LABEL);
+  const assignments = pConnect.getValue(CASE_INFO.D_CASE_ASSIGNMENTS_RESULTS) || [];
+  const childCasesAssignments = getChildCaseAssignments(pConnect) || [];
+  let childCasesAssignmentsCopy = JSON.parse(JSON.stringify(childCasesAssignments));
+
+  childCasesAssignmentsCopy = childCasesAssignmentsCopy.map((assignment) => {
+    assignment.isChild = true;
+    return assignment;
+  });
+
+  const todoAssignments = [...assignments, ...childCasesAssignmentsCopy];
+  let todoAssignmentsCopy = JSON.parse(JSON.stringify(todoAssignments));
+
+  if (caseActions && !showTodo(pConnect)) {
+    todoAssignmentsCopy = todoAssignmentsCopy.map((assignment) => {
+      assignment.name = getActiveCaseActionName(pConnect) || assignmentLabel;
+      return assignment;
+    });
+  }
+
+  return todoAssignmentsCopy;
+};

package/templates/react-native-sdk-reference/src/components/infra/Containers/FlowContainer/index.tsx

@@ -0,0 +1 @@
+export { default } from './FlowContainer';

package/templates/react-native-sdk-reference/src/components/infra/Containers/RootContainer/RootContainer.tsx

@@ -0,0 +1,52 @@
+import { createElement, useEffect, useState } from 'react';
+import { Text, View } from 'react-native';
+import { PConnectComponent } from '@pega/sdk-react';
+
+const getNoPortalContent = (pConn: any) => {
+  const configProps = pConn.getConfigProps();
+  const options = { context: 'app', target: pConn.getTarget() };
+
+  const viewContainerConfig = {
+    meta: {
+      type: 'ViewContainer',
+      config: configProps,
+    },
+    options,
+  };
+  const theViewContainer: any = PCore.createPConnect(viewContainerConfig);
+
+  return createElement(PConnectComponent, theViewContainer);
+};
+
+export default function RootContainer(props: any) {
+  const [componentName, setComponentName] = useState('');
+
+  const { getPConnect, renderingMode, routingInfo } = props;
+
+  const pConn = getPConnect();
+
+  useEffect(() => {
+    const { containers } = PCore.getStore().getState();
+    const items = Object.keys(containers).filter((item) => item.includes('root'));
+    (PCore.getContainerUtils().getContainerAPI() as any).addContainerItems(items);
+  }, [routingInfo]);
+
+  if (renderingMode === 'noPortal') {
+    const theChildren = pConn.getChildren() as any[];
+    if (theChildren && theChildren.length === 1) {
+      const localPConn = theChildren[0].getPConnect();
+      const localCompName = localPConn.getComponentName();
+      if (componentName !== localCompName) {
+        setComponentName(localCompName);
+      }
+    }
+
+    return <View>{getNoPortalContent(pConn)}</View>;
+  }
+
+  return (
+    <View>
+      <Text>Root Container</Text>
+    </View>
+  );
+}

package/templates/react-native-sdk-reference/src/components/infra/Containers/RootContainer/index.tsx

@@ -0,0 +1 @@
+export { default } from './RootContainer';