@pega/dx-component-builder-sdk 24.2.11 → 24.2.12

package/tests/assets/sdk-r/components/createAll/override-sdk/infra/ModalViewContainer/ModalViewContainer.tsx

@@ -0,0 +1,345 @@
+import { createElement, useEffect, useRef, useState } from 'react';
+import Dialog from '@mui/material/Dialog';
+import DialogContent from '@mui/material/DialogContent';
+import DialogTitle from '@mui/material/DialogTitle';
+import makeStyles from '@mui/styles/makeStyles';
+import { LocalizationProvider } from '@mui/x-date-pickers';
+import { AdapterDayjs } from '@mui/x-date-pickers/AdapterDayjs';
+import difference from 'lodash.difference';
+
+import createPConnectComponent from '@pega/react-sdk-components/lib/bridge/react_pconnect';
+// Need to get correct implementation from component map for Assignment and CancelAlert
+import { getComponentFromMap } from '@pega/react-sdk-components/lib/bridge/helpers/sdk_component_map';
+import { getBanners } from '@pega/react-sdk-components/lib/components/helpers/case-utils';
+import { PConnProps } from '@pega/react-sdk-components/lib/types/PConnProps';
+
+interface ModalViewContainerProps extends PConnProps {
+  // If any, enter additional props that only exist on this component
+  loadingInfo?: string;
+  routingInfo?: any;
+  pageMessages?: string[];
+}
+
+function isOpenModalAction(prevModalCollection, currentModalList) {
+  return prevModalCollection && currentModalList ? Object.keys(prevModalCollection).length < currentModalList.length : false;
+}
+
+function isUpdateModalAction(prevModalCollection, currentModalList) {
+  return prevModalCollection && currentModalList ? Object.keys(prevModalCollection).length === currentModalList.length : false;
+}
+
+function isCloseModalAction(prevModalCollection, currentModalList) {
+  return prevModalCollection && currentModalList ? Object.keys(prevModalCollection).length > currentModalList.length : false;
+}
+
+function buildName(pConnect, name = '') {
+  const context = pConnect.getContextName();
+  return `${context}/${name}`;
+}
+
+function getKeyAndLatestItem(routinginfo, pConn, options) {
+  const containerName = pConn.getContainerName();
+  const { acTertiary = false } = options || {};
+  if (PCore.getContainerUtils().hasContainerItems(buildName(pConn, containerName))) {
+    const { accessedOrder, items } = routinginfo;
+    let key;
+    // eslint-disable-next-line no-plusplus
+    for (let i = accessedOrder.length - 1; i >= 0; i--) {
+      const tempkey = accessedOrder[i];
+      if ((acTertiary && items[tempkey].acTertiary) || (!acTertiary && !items[tempkey].acTertiary)) {
+        key = tempkey;
+        break;
+      }
+    }
+    const latestItem = items[key];
+    return { key, latestItem };
+  }
+  return {};
+}
+
+function getConfigObject(item, pConnect, isReverseCoexistence = false) {
+  let config;
+  if (isReverseCoexistence) {
+    config = {
+      options: {
+        pageReference: pConnect?.getPageReference(),
+        hasForm: true,
+        containerName: pConnect?.getContainerName() || PCore.getConstants().MODAL
+      }
+    };
+    return PCore.createPConnect(config);
+  }
+  if (item) {
+    const { context, view, isBulkAction } = item;
+    const target = PCore.getContainerUtils().getTargetFromContainerItemID(context);
+    config = {
+      meta: view,
+      options: {
+        context,
+        pageReference: view.config.context || pConnect.getPageReference(),
+        hasForm: true,
+        ...(isBulkAction && { isBulkAction }),
+        containerName: pConnect?.getContainerName() || PCore.getConstants().MODAL,
+        target
+      }
+    };
+    return PCore.createPConnect(config);
+  }
+  return null;
+}
+
+const useStyles = makeStyles(theme => ({
+  dlgTitle: {
+    marginLeft: theme.spacing(2),
+    marginRight: theme.spacing(2),
+    marginTop: theme.spacing(2),
+    marginBottom: theme.spacing(0)
+  },
+  dlgContent: {
+    marginLeft: theme.spacing(2),
+    marginRight: theme.spacing(2),
+    marginTop: theme.spacing(0),
+    marginBottom: theme.spacing(2)
+  }
+}));
+
+export default function ModalViewContainer(props: ModalViewContainerProps) {
+  // Get the proper implementation (local or Pega-provided) for these components that are emitted below
+  const Assignment = getComponentFromMap('Assignment');
+  const CancelAlert = getComponentFromMap('CancelAlert');
+  const ListViewActionButtons = getComponentFromMap('ListViewActionButtons');
+
+  const classes = useStyles();
+
+  const modalCollection = useRef({});
+  const routingInfoRef = useRef({});
+  const { getPConnect, routingInfo = null, pageMessages = [] } = props;
+  const pConn = getPConnect();
+  const { acTertiary } = pConn.getConfigProps() as any;
+  const {
+    CONTAINER_TYPE: { MULTIPLE },
+    PUB_SUB_EVENTS: { EVENT_SHOW_CANCEL_ALERT }
+  } = PCore.getConstants();
+  const { subscribe, unsubscribe } = PCore.getPubSubUtils();
+  const [bShowModal, setShowModal] = useState(false);
+  const [bShowCancelAlert, setShowCancelAlert] = useState(false);
+  const [createdView, setCreatedView] = useState<any>(null);
+  const [title, setTitle] = useState('');
+  const [arNewChildrenAsReact, setArNewChildrenAsReact] = useState<any[]>([]);
+  const [itemKey, setItemKey] = useState('');
+  const [cancelAlertProps, setCancelAlertProps] = useState({});
+  const [isMultiRecordData, setMultiRecordData] = useState(false);
+  const localizedVal = PCore.getLocaleUtils().getLocaleValue;
+  const localeCategory = 'Data Object';
+
+  const ERROR_WHILE_RENDERING = 'ERROR_WHILE_RENDERING';
+
+  function showAlert(payload) {
+    const { latestItem } = getKeyAndLatestItem(routingInfoRef.current, pConn, { acTertiary });
+    const isReverseCoexistence = (PCore.getCoexistenceManager().getBroadcastUtils() as any).isReverseCoexistenceCaseLoaded();
+    const { isModalAction, hideDelete, isDataObject, skipReleaseLockRequest } = payload;
+
+    /*
+      If we are in create stage full page mode, created a new case and trying to click on cancel button
+      it will show two alert dialogs which is not expected. Hence isModalAction flag to avoid that.
+    */
+    if (latestItem && isModalAction) {
+      const configObject = getConfigObject(latestItem, pConn, isReverseCoexistence);
+      const contextName = configObject?.getPConnect().getContextName();
+      setCancelAlertProps({
+        heading: 'Discard unsaved changes?',
+        content: 'You have unsaved changes. You can discard them or go back to keep working.',
+        getPConnect: configObject?.getPConnect,
+        itemKey: contextName,
+        hideDelete,
+        isDataObject,
+        skipReleaseLockRequest
+      });
+      setShowCancelAlert(true);
+    }
+  }
+
+  function handleModalOpen(key) {
+    modalCollection.current = {
+      ...modalCollection.current,
+      [key]: {}
+    };
+  }
+
+  function handleModalClose(accessedOrder) {
+    const tempModalCollection = modalCollection.current;
+    const [closedModalKey] = difference(Object.keys(tempModalCollection), accessedOrder);
+
+    if (closedModalKey && tempModalCollection[closedModalKey]) {
+      const modifiedModalCollection = { ...tempModalCollection };
+      delete modifiedModalCollection[closedModalKey];
+      modalCollection.current = modifiedModalCollection;
+      setShowModal(false);
+    }
+  }
+
+  const dismissCancelAlert = dismissAllModals => {
+    setShowCancelAlert(false);
+
+    if (dismissAllModals) {
+      setShowModal(false);
+    }
+  };
+
+  function getModalHeading(dataObjectAction) {
+    return dataObjectAction === PCore.getConstants().RESOURCE_STATUS.CREATE
+      ? localizedVal('Add Record', localeCategory)
+      : localizedVal('Edit Record', localeCategory);
+  }
+
+  function determineModalHeaderByAction(actionName, caseTypeName, ID, caseLocaleRef) {
+    if (actionName) {
+      return localizedVal(actionName, localeCategory);
+    }
+    return `${localizedVal('Create', localeCategory)} ${localizedVal(caseTypeName, undefined, caseLocaleRef)} (${ID})`;
+  }
+
+  useEffect(() => {
+    // Establish the necessary containers
+    const containerMgr = pConn.getContainerManager();
+    containerMgr.initializeContainers({ type: MULTIPLE });
+  }, [MULTIPLE, pConn]);
+
+  useEffect(() => {
+    // Persisting routing information between the renders in showAlert
+    routingInfoRef.current = routingInfo;
+  });
+
+  useEffect(() => {
+    subscribe(EVENT_SHOW_CANCEL_ALERT, showAlert, EVENT_SHOW_CANCEL_ALERT /* Unique string for subscription */);
+    subscribe(
+      ERROR_WHILE_RENDERING,
+      error => {
+        // setError(true);
+        // eslint-disable-next-line no-console
+        console.error(error);
+      },
+      `${ERROR_WHILE_RENDERING}-mc-${getPConnect().getContextName()}`,
+      false,
+      getPConnect().getContextName()
+    );
+
+    // Unsubscribe on component unmount
+    return () => {
+      unsubscribe(EVENT_SHOW_CANCEL_ALERT, EVENT_SHOW_CANCEL_ALERT /* Should be same unique string passed during subscription */);
+    };
+  });
+
+  useEffect(() => {
+    if (routingInfo) {
+      const { accessedOrder, type } = routingInfo;
+      const { key, latestItem } = getKeyAndLatestItem(routingInfo, pConn, { acTertiary });
+
+      if (
+        latestItem &&
+        type === MULTIPLE &&
+        (isOpenModalAction(modalCollection.current, accessedOrder) || isUpdateModalAction(modalCollection.current, accessedOrder))
+      ) {
+        const { actionName } = latestItem;
+        // const { isDockable = false } = latestItem?.modalOptions || {};
+        const configObject: any = getConfigObject(latestItem, null, false);
+        const pConnect = configObject.getPConnect();
+        const caseInfo: any = pConnect.getCaseInfo();
+        const caseName = caseInfo.getName();
+        const caseTypeName = caseInfo.getCaseTypeName();
+        const ID = caseInfo.getBusinessID() || caseInfo.getID();
+        const isDataObject = routingInfo.items[latestItem.context].resourceType === PCore.getConstants().RESOURCE_TYPES.DATA;
+        const dataObjectAction = routingInfo.items[latestItem.context].resourceStatus;
+        const isMultiRecord = routingInfo.items[latestItem.context].isMultiRecordData;
+        const headingValue =
+          isDataObject || isMultiRecord
+            ? getModalHeading(dataObjectAction)
+            : determineModalHeaderByAction(actionName, caseTypeName, ID, `${caseInfo?.getClassName()}!CASE!${caseInfo.getName()}`.toUpperCase());
+
+        let arChildrenAsReact: any[] = [];
+
+        if (pConnect.getComponentName() === 'reference') {
+          // Reference component doesn't have children. It can build the View we want.
+          // The Reference component getPConnect is in configObject
+
+          arChildrenAsReact.push(
+            createElement(createPConnectComponent(), {
+              ...configObject,
+              key: `${caseName}-${ID}`
+            })
+          );
+        } else {
+          // This is the 8.6 implementation. Leaving it in for reference for now.
+          // And create a similar array of the children as React components
+          // passed to Assignment component when rendered
+          arChildrenAsReact = (pConnect.getChildren() as []).map((child: any) => {
+            // Use Case Summary ID as the React element's key
+            const caseSummaryID = child.getPConnect().getCaseSummary().ID;
+            return createElement(createPConnectComponent(), {
+              ...child,
+              key: caseSummaryID
+            });
+          });
+        }
+
+        if (arChildrenAsReact.length > 0) setArNewChildrenAsReact(arChildrenAsReact);
+        setMultiRecordData(isMultiRecord);
+        setTitle(headingValue);
+        setCreatedView({ configObject, latestItem });
+        setItemKey(key);
+        setShowModal(true);
+
+        // Update modal use case which happens when assignment in submitted in modal.
+        if (isUpdateModalAction(modalCollection.current, accessedOrder)) {
+          // handleModalUpdate(key);
+        } else if (isOpenModalAction(modalCollection.current, accessedOrder)) {
+          // New modal open scenario
+          handleModalOpen(key);
+        }
+      } else if (isCloseModalAction(modalCollection.current, accessedOrder)) {
+        handleModalClose(accessedOrder);
+      }
+    }
+  }, [routingInfo]);
+
+  function closeActionsDialog() {
+    // actionsDialog.current = true;
+    setShowModal(false);
+  }
+
+  return (
+    <>
+      <Dialog open={bShowModal} aria-labelledby='form-dialog-title'>
+        <DialogTitle id='form-dialog-title' className={`${classes.dlgTitle} psdk-dialog-title`}>
+          {title}
+        </DialogTitle>
+        <DialogContent className={`${classes.dlgContent} psdk-dialog-content`}>
+          {bShowModal ? (
+            <LocalizationProvider dateAdapter={AdapterDayjs}>
+              <Assignment
+                getPConnect={createdView.configObject.getPConnect}
+                itemKey={itemKey}
+                isInModal
+                banners={getBanners({
+                  target: itemKey,
+                  pageMessages
+                })}
+              >
+                {arNewChildrenAsReact}
+              </Assignment>
+            </LocalizationProvider>
+          ) : null}
+        </DialogContent>
+
+        {isMultiRecordData && (
+          <ListViewActionButtons
+            getPConnect={createdView.configObject.getPConnect}
+            context={createdView.latestItem.context}
+            closeActionsDialog={closeActionsDialog}
+          />
+        )}
+      </Dialog>
+      {bShowCancelAlert && <CancelAlert {...cancelAlertProps} dismiss={dismissCancelAlert} />}
+    </>
+  );
+}

package/tests/assets/sdk-r/components/createAll/override-sdk/infra/ModalViewContainer/index.tsx

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

package/tests/assets/sdk-r/components/createAll/override-sdk/infra/NavBar/NavBar.css

@@ -165,4 +165,5 @@
 
 .scrollable {
   overflow-y: scroll !important;
+  min-height: 200px !important;
 }

package/tests/assets/sdk-r/components/createAll/override-sdk/infra/Reference/Reference.tsx

@@ -0,0 +1,52 @@
+import { PConnProps } from '@pega/react-sdk-components/lib/types/PConnProps';
+
+interface ReferenceProps extends PConnProps {
+  // If any, enter additional props that only exist on this component
+  visibility?: boolean;
+  context?: string;
+  readOnly?: boolean;
+  displayMode?: string;
+}
+
+export default function Reference(props: ReferenceProps) {
+  const { visibility = true, context = '', getPConnect, readOnly = false, displayMode = '' } = props;
+
+  const pConnect = getPConnect();
+  // @ts-ignore - Property 'getComponentConfig' is private and only accessible within class 'C11nEnv'.
+  const referenceConfig = { ...pConnect.getComponentConfig() } || {};
+
+  delete referenceConfig?.name;
+  delete referenceConfig?.type;
+  delete referenceConfig?.visibility;
+
+  const viewMetadata: any = pConnect.getReferencedView();
+
+  if (!viewMetadata) {
+    // console.log("View not found ", pConnect.getComponentConfig());
+    return null;
+  }
+
+  const viewObject = {
+    ...viewMetadata,
+    config: {
+      ...viewMetadata.config,
+      ...referenceConfig
+    }
+  };
+
+  // @ts-ignore - Argument of type 'null' is not assignable to parameter of type 'string'.
+  const viewComponent: any = pConnect.createComponent(viewObject, null, null, {
+    pageReference: context && context.startsWith('@CLASS') ? '' : context
+  });
+
+  viewComponent.props.getPConnect().setInheritedConfig({
+    ...referenceConfig,
+    readOnly,
+    displayMode
+  });
+
+  if (visibility !== false) {
+    return <>{viewComponent}</>;
+  }
+  return null;
+}

package/tests/assets/sdk-r/components/createAll/override-sdk/infra/Reference/index.tsx

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

package/tests/assets/sdk-r/components/createAll/override-sdk/infra/Region/Region.tsx

@@ -0,0 +1,17 @@
+import { PropsWithChildren } from 'react';
+
+// Region does NOT have getPConnect. So, no need to extend from PConnProps
+interface RegionProps {
+  // If any, enter additional props that only exist on this component
+}
+
+export default function Region(props: PropsWithChildren<RegionProps>) {
+  const { children } = props;
+
+  return (
+    <>
+      {/* <div>Region</div> */}
+      {children}
+    </>
+  );
+}

package/tests/assets/sdk-r/components/createAll/override-sdk/infra/Region/index.tsx

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

package/tests/assets/sdk-r/components/createAll/override-sdk/infra/RootContainer/RootContainer.tsx

@@ -0,0 +1,240 @@
+import { Children, createElement, PropsWithChildren, useContext, useEffect, useMemo, useRef, useState } from 'react';
+import { Box, CircularProgress } from '@mui/material';
+
+import createPConnectComponent from '@pega/react-sdk-components/lib/bridge/react_pconnect';
+import StoreContext from '@pega/react-sdk-components/lib/bridge/Context/StoreContext';
+import { LazyMap as LazyComponentMap } from '@pega/react-sdk-components/lib/components_map';
+import { isEmptyObject } from '@pega/react-sdk-components/lib/components/helpers/common-utils';
+import { PConnProps } from '@pega/react-sdk-components/lib/types/PConnProps';
+
+interface RootContainerProps extends PConnProps {
+  // If any, enter additional props that only exist on this component
+  renderingMode?: string;
+  routingInfo: { type: string; accessedOrder: any[]; items: any };
+  skeleton: any;
+  httpMessages: any[];
+}
+
+//
+// WARNING:  It is not expected that this file should be modified.  It is part of infrastructure code that works with
+// Redux and creation/update of Redux containers and PConnect.  Modifying this code could have undesireable results and
+// is totally at your own risk.
+//
+
+const renderingModes = ['portal', 'view'];
+
+function usePrevious(value) {
+  const ref = useRef(null);
+  useEffect(() => {
+    ref.current = value;
+  });
+  return ref.current;
+}
+
+function getItemView(routingInfo, renderingMode) {
+  const viewConfigs: any = [];
+  if (routingInfo && renderingModes.includes(renderingMode)) {
+    const { accessedOrder, items }: { accessedOrder: any; items: any } = routingInfo;
+    if (accessedOrder && items) {
+      const key = accessedOrder[accessedOrder.length - 1];
+      if (items[key] && items[key].view && !isEmptyObject(items[key].view)) {
+        viewConfigs.push(items[key]);
+      }
+    }
+  }
+  return viewConfigs;
+}
+
+export default function RootContainer(props: PropsWithChildren<RootContainerProps>) {
+  const { getPConnect, renderingMode = '', children, skeleton, httpMessages = [], routingInfo } = props;
+
+  const { displayOnlyFA } = useContext<any>(StoreContext);
+
+  const pConn = getPConnect();
+
+  const options = { context: 'app' };
+  const rootView = useRef(null);
+
+  const [componentName, setComponentName] = useState('');
+
+  useEffect(() => {
+    // debugging/investigation help
+    // console.log(`componentName change: ${componentName} triggering a re-render`);
+  }, [componentName]);
+
+  // debugging/investigation help
+  // console.log(`RootContainer props.routingInfo: ${JSON.stringify(routingInfo)}`);
+
+  let hasBanner = false;
+  let banners: any = null;
+  const localizedVal = PCore.getLocaleUtils().getLocaleValue;
+  const localeCategory = 'Messages';
+
+  const messages = httpMessages ? httpMessages.map(msg => localizedVal(msg.message, localeCategory)) : httpMessages;
+
+  hasBanner = messages && messages.length > 0;
+  banners = hasBanner && <div>{localizedVal(`RootContainer: trying to emit Banner with ${messages}`, localeCategory)}</div>;
+
+  const MemoizedModalViewContainer = useMemo(() => {
+    return createElement(
+      createPConnectComponent(),
+      PCore.createPConnect({
+        meta: {
+          type: 'ModalViewContainer',
+          config: {
+            name: 'modal'
+          }
+        },
+        options
+      })
+    );
+  }, []);
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  const MemoizedPreviewViewContainer = useMemo(() => {
+    return createElement(
+      createPConnectComponent(),
+      PCore.createPConnect({
+        meta: {
+          type: 'PreviewViewContainer',
+          config: {
+            name: 'preview'
+          }
+        },
+        options
+      })
+    );
+  }, []);
+
+  //
+  function getNoPortalContent() {
+    let noPortalContent: any;
+
+    switch (componentName) {
+      case 'View':
+        noPortalContent = <div>{localizedVal('getNoPortalContent: RootContainer wants to render View in noPortal mode', localeCategory)}</div>;
+        break;
+
+      case 'ViewContainer': {
+        const configProps = pConn.getConfigProps();
+        const viewContConfig = {
+          meta: {
+            type: 'ViewContainer',
+            config: configProps
+          },
+          options
+        };
+        const theViewCont: any = PCore.createPConnect(viewContConfig);
+        // Add in displayOnlyFA if prop is on RootContainer
+        if (displayOnlyFA) {
+          theViewCont.displayOnlyFA = true;
+        }
+
+        const theViewContainerAsReact = createElement(createPConnectComponent(), theViewCont);
+
+        noPortalContent = theViewContainerAsReact;
+        break;
+      }
+
+      default:
+        noPortalContent = (
+          <div>{localizedVal('getNoPortalContent: RootContainer wants to render NO componentName in noPortal mode', localeCategory)}</div>
+        );
+        break;
+    }
+
+    return noPortalContent;
+  }
+
+  let rootViewConfig: any = null;
+
+  useEffect(() => {
+    const { containers } = PCore.getStore().getState();
+    const items = Object.keys(containers).filter(item => item.includes('root'));
+    (PCore.getContainerUtils().getContainerAPI() as any).addContainerItems(items);
+  }, [routingInfo]);
+
+  const items: any = getItemView(routingInfo, renderingMode);
+
+  if (items.length > 0) {
+    rootViewConfig = {
+      meta: items[0].view,
+      options: {
+        context: items[0].context
+      }
+    };
+  }
+  const prevRootConfig = usePrevious(rootViewConfig);
+
+  if (renderingModes.includes(renderingMode) && messages && routingInfo && routingInfo?.accessedOrder.length === 0) {
+    return <div id='root-container'>{banners}</div>;
+  }
+
+  if (items.length > 0) {
+    const itemView = items[0].view;
+    const currentRootConfig = {
+      meta: itemView,
+      options: {
+        context: items[0].context
+      }
+    };
+
+    if (!PCore.isDeepEqual(currentRootConfig, prevRootConfig)) {
+      rootView.current = createElement(createPConnectComponent(), PCore.createPConnect(currentRootConfig)) as any;
+    }
+
+    // debugging/investigation help
+    // console.log(`rootView.props.getPConnect().getComponentName(): ${rootView.props.getPConnect().getComponentName()}`);
+
+    return (
+      <div id='ModalManager'>
+        {rootView.current}
+        {MemoizedModalViewContainer}
+        <div id='MemoizedPreviewViewContainer' />
+        <div id='ReAuthMessageModal' />
+      </div>
+    );
+  }
+  if (renderingMode === 'noPortal') {
+    // eslint-disable-next-line no-console
+    console.log(`${localizedVal('RootContainer rendering in noPortal mode', localeCategory)}`);
+
+    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 getNoPortalContent();
+  }
+  if (children && Children.count(children) > 0) {
+    return (
+      <>
+        <div>{localizedVal('RootContainer: Has children. Trying to show ModalManager with children, etc.', localeCategory)}</div>
+        {children}
+        {MemoizedModalViewContainer}
+      </>
+    );
+  }
+  if (skeleton) {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const LoadingComponent = LazyComponentMap[skeleton];
+
+    return (
+      <div id='root-container'>
+        {/* <div>RootContainer: Trying to show skeleton</div> */}
+        <Box textAlign='center'>
+          <CircularProgress />
+        </Box>
+      </div>
+    );
+  }
+  return (
+    <div id='root-container'>
+      <div>{localizedVal('RootContainer: Should be ModalManager, etc.', localeCategory)}</div>
+    </div>
+  );
+}

package/tests/assets/sdk-r/components/createAll/override-sdk/infra/RootContainer/index.tsx

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