@pega/dx-component-builder-sdk 0.242.15 → 0.242.16

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';

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

@@ -0,0 +1,48 @@
+import { useMemo } from 'react';
+
+import { getActiveContainerItemID, getActiveContainerRootViewElement, getPConnectOfActiveContainerItem, useContainerInitializer } from './helper';
+
+const SimpleViewContainer = props => {
+  const { CONTAINER_TYPE } = PCore.getConstants();
+
+  const { getPConnect, mode = CONTAINER_TYPE.SINGLE, routingInfo: containerInfo, isAssignmentView, options = {} } = props;
+
+  const rootViewElement = useMemo(() => {
+    return getActiveContainerRootViewElement(containerInfo, {
+      isAssignmentView,
+      parentGetPConnect: getPConnect
+    });
+  }, [containerInfo, isAssignmentView, getPConnect]);
+
+  useContainerInitializer(getPConnect, options.mode || mode);
+
+  return rootViewElement;
+};
+
+export const withSimpleViewContainerRenderer =
+  (Component, options: any = {}) =>
+  props => {
+    const { CONTAINER_TYPE } = PCore.getConstants();
+
+    const { getPConnect, mode = CONTAINER_TYPE.SINGLE, routingInfo: containerInfo, isAssignmentView } = props;
+
+    const rootViewElement = <SimpleViewContainer {...props} options={options} />;
+    const activeContainerItemID = getActiveContainerItemID(containerInfo);
+    const getPConnectOfActiveItem = getPConnectOfActiveContainerItem(containerInfo, {
+      isAssignmentView,
+      parentGetPConnect: getPConnect
+    });
+
+    useContainerInitializer(getPConnect, options.mode || mode);
+
+    return (
+      <Component
+        {...props}
+        rootViewElement={rootViewElement}
+        activeContainerItemID={activeContainerItemID}
+        getPConnectOfActiveContainerItem={getPConnectOfActiveItem}
+      />
+    );
+  };
+
+export default SimpleViewContainer;

package/tests/assets/sdk-r/components/createAll/override-sdk/infra/SimpleView/helper.ts

@@ -0,0 +1,125 @@
+import { useEffect, createElement } from 'react';
+
+import createPConnectComponent from '@pega/react-sdk-components/lib/bridge/react_pconnect';
+import { isContainerInitialized } from '@pega/react-sdk-components/lib/components/helpers';
+
+const processRootViewDetails = (rootView, containerItem, options) => {
+  const {
+    config: { context: viewContext, name: viewName }
+  } = rootView;
+  const { context: containerContext } = containerItem;
+  const { parentGetPConnect } = options;
+  let resolvedViewName = viewName;
+  let resolvedViewContext = viewContext;
+
+  const isAnnotedViewName = PCore.getAnnotationUtils().isProperty(viewName);
+  const isAnnotedViewContext = PCore.getAnnotationUtils().isProperty(viewContext);
+
+  // resolving annoted view context
+  if (isAnnotedViewContext) {
+    const viewContextProperty = PCore.getAnnotationUtils().getPropertyName(viewContext);
+    resolvedViewContext = PCore.getStoreValue(
+      `.${viewContextProperty}`,
+      viewContextProperty.startsWith('.') ? parentGetPConnect().getPageReference() : '',
+      containerContext
+    );
+  }
+
+  if (!resolvedViewContext) {
+    resolvedViewContext = parentGetPConnect().getPageReference();
+  }
+
+  // resolving annoted view name
+  if (isAnnotedViewName) {
+    const viewNameProperty = PCore.getAnnotationUtils().getPropertyName(viewName);
+    resolvedViewName = PCore.getStoreValue(`.${viewNameProperty}`, resolvedViewContext, containerContext);
+  }
+
+  /* Special case where context and viewname are dynamic values
+    Use case - split for each shape
+
+    Ex - (caseInfo.content.SCRequestWorkQueues[1]):context --> .pyViewName:viewName
+  */
+  if (isAnnotedViewName && isAnnotedViewContext && resolvedViewName !== '') {
+    /* Allow context processor to resolve view and context when both are dynamic */
+    resolvedViewName = viewName;
+    resolvedViewContext = viewContext;
+  }
+
+  return {
+    viewName: resolvedViewName,
+    viewContext: resolvedViewContext
+  };
+};
+
+export const getPConnectOfActiveContainerItem = (containerInfo, options) => {
+  const { accessedOrder, items } = containerInfo;
+  const { isAssignmentView = false, parentGetPConnect } = options;
+  const containerName = parentGetPConnect().getContainerName();
+  const { CONTAINER_NAMES } = PCore.getContainerUtils();
+  const { CREATE_DETAILS_VIEW_NAME } = PCore.getConstants();
+
+  if (accessedOrder && items) {
+    const activeContainerItemKey = accessedOrder[accessedOrder.length - 1];
+
+    if (items[activeContainerItemKey] && items[activeContainerItemKey].view && Object.keys(items[activeContainerItemKey].view).length > 0) {
+      const activeContainerItem = items[activeContainerItemKey];
+      const target = activeContainerItemKey.substring(0, activeContainerItemKey.lastIndexOf('_'));
+
+      const { view: rootView, context } = activeContainerItem;
+      const { viewName, viewContext } = processRootViewDetails(rootView, activeContainerItem, { parentGetPConnect });
+
+      if (!viewName) return null;
+
+      const config = {
+        meta: rootView,
+        options: {
+          context,
+          pageReference: viewContext || parentGetPConnect().getPageReference(),
+          containerName,
+          containerItemID: activeContainerItemKey,
+          parentPageReference: parentGetPConnect().getPageReference(),
+          hasForm:
+            isAssignmentView ||
+            containerName === CONTAINER_NAMES.WORKAREA ||
+            containerName === CONTAINER_NAMES.MODAL ||
+            viewName === CREATE_DETAILS_VIEW_NAME,
+          target
+        }
+      };
+
+      return PCore.createPConnect(config).getPConnect;
+    }
+  }
+  return null;
+};
+
+export const getActiveContainerRootViewElement = (containerInfo, options) => {
+  const getPConnect = getPConnectOfActiveContainerItem(containerInfo, options);
+  if (getPConnect) {
+    return createElement(createPConnectComponent(), { getPConnect });
+  }
+  return null;
+};
+
+export const getActiveContainerItemID = containerInfo => {
+  const { accessedOrder } = containerInfo;
+  if (accessedOrder && accessedOrder.length > 0) {
+    return accessedOrder[accessedOrder.length - 1];
+  }
+  return '';
+};
+
+export const useContainerInitializer = (getPConnect, mode) => {
+  const pConnect = getPConnect();
+  const containerName = pConnect.getContainerName();
+  const containerManager = pConnect.getContainerManager();
+  useEffect(() => {
+    if (!isContainerInitialized(pConnect)) {
+      containerManager.initializeContainers({
+        type: mode,
+        name: containerName
+      });
+    }
+  });
+};

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

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

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

@@ -0,0 +1,201 @@
+import React, { createElement, useContext, useEffect, 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 { isEmptyObject } from '@pega/react-sdk-components/lib/components/helpers/common-utils';
+import { PConnProps } from '@pega/react-sdk-components/lib/types/PConnProps';
+
+interface ViewContainerProps extends PConnProps {
+  // If any, enter additional props that only exist on this component
+  name?: string;
+  loadingInfo?: any; // can't be boolean until setDispatchObjState expects loadingInfo to be type null
+  routingInfo?: any;
+  mode?: string;
+  limit?: number;
+}
+
+// ViewContainer can emit View
+// import View from '../View';
+
+//
+// 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.
+//
+
+export default function ViewContainer(props: ViewContainerProps) {
+  // const { getPConnect, children, routingInfo, name } = props;
+  const { getPConnect, name = '', mode = 'single', limit = 16, loadingInfo = false, routingInfo = null } = props;
+
+  const { displayOnlyFA } = useContext<any>(StoreContext);
+
+  const { CONTAINER_TYPE, APP } = PCore.getConstants();
+  const pConn = getPConnect();
+  const containerMgr: any = pConn.getContainerManager();
+
+  const [dispatchObjState, setDispatchObjState] = useState({
+    dispatchObject: { semanticURL: '', context: '', acName: '' },
+    visible: false,
+    loadingInfo: null,
+    isLoadingInfoChange: false
+  }); // was this.state in class-based ViewContainer avoiding use of just "state" as the name
+
+  let root;
+
+  const thePConn = typeof getPConnect === 'function' ? getPConnect() : null;
+
+  // beginning of functions for use by ViewContainer
+
+  function buildName() {
+    const context = thePConn?.getContextName();
+    let viewContainerName = name;
+    if (!viewContainerName) viewContainerName = '';
+    return `${context?.toUpperCase()}/${viewContainerName.toUpperCase()}`;
+  }
+
+  function prepareDispatchObject() {
+    const baseContext = pConn.getContextName();
+    // const { acName = "primary" } = pConn.getContainerName(); // doesn't work with 8.23 typings
+    let acName = pConn.getContainerName();
+    if (!acName) {
+      acName = 'primary';
+    }
+
+    return {
+      semanticURL: '',
+      context: baseContext,
+      acName
+    };
+  }
+
+  // determine if or not loadingInfo prop changed on next re-render
+  // function getDerivedStateFromProps(nextProps, prevState) {
+  //   const { loadingInfo: prevLoadingInfo } = prevState;
+  //   const { loadingInfo: nextLoadingIndfo } = nextProps;
+  //   return {
+  //     loadingInfo: nextLoadingIndfo,
+  //     isLoadingInfoChange: prevLoadingInfo !== nextLoadingIndfo
+  //   };
+  // }
+
+  // set the root component that is retrieved by PConnectHOC
+  function setRootComponent(configObject) {
+    const { isLoadingInfoChange } = dispatchObjState;
+    if (!isLoadingInfoChange) {
+      root = createElement(createPConnectComponent(), configObject);
+    }
+  }
+
+  // end of functions for use by ViewContainer
+
+  // useEffect on [] -> code that should be run once (as in old constructor and in componentDidMount)
+  useEffect(() => {
+    // This is adapted from the class-based ViewContainer constructor
+    containerMgr.initializeContainers({
+      type: mode === CONTAINER_TYPE.MULTIPLE ? CONTAINER_TYPE.MULTIPLE : CONTAINER_TYPE.SINGLE
+    });
+
+    if (mode === CONTAINER_TYPE.MULTIPLE && limit) {
+      /* NOTE: setContainerLimit use is temporary. It is a non-public, unsupported API. */
+      PCore.getContainerUtils().setContainerLimit(`${APP.APP}/${name}`, limit);
+    }
+
+    const dispatchObject = prepareDispatchObject();
+    setDispatchObjState({
+      dispatchObject,
+      // PCore is defined in pxBootstrapShell - eventually will be exported in place of constellationCore
+      visible: !PCore.checkIfSemanticURL(),
+      loadingInfo,
+      isLoadingInfoChange: false
+    });
+
+    const { visible } = dispatchObjState;
+    if (visible) containerMgr.addContainerItem(dispatchObject);
+
+    // This is adapted from the class-based ViewContainer componentDidMount
+    let objectForAddContainer;
+    if (PCore.checkIfSemanticURL()) {
+      objectForAddContainer = prepareDispatchObject();
+    } else {
+      const { dispatchObject: theDispatchObject } = dispatchObjState;
+      objectForAddContainer = theDispatchObject;
+    }
+
+    // Getting default view label
+    const navPages = pConn.getValue('pyPortal.pyPrimaryNavPages', ''); // 2nd arg empty string until typedefs allow optional
+    const defaultViewLabel = Array.isArray(navPages) && navPages[0] ? navPages[0].pyLabel : '';
+    // TODO: Plan is to rename window.constellationCore to window.pega (or similar)
+    //    And expose less via ui-bootstrap.js
+    // PCore is defined in pxBootstrapShell - eventually will be exported in place of constellationCore
+
+    if (!displayOnlyFA) {
+      // configureForBrowserBookmark not applicable in Embedded mode
+      PCore.configureForBrowserBookmark({
+        ...objectForAddContainer,
+        defaultViewLabel
+      });
+    }
+  }, []);
+
+  // This code (that's run every time the ViewContainer is called) is adapted from the class-based ViewContainer's render
+
+  // Looking for routingInfo
+
+  // debugging/investigation help
+  // console.log(`ViewContainer props: ${JSON.stringify(props)}`);
+
+  const theBuildName = buildName();
+  const { CREATE_DETAILS_VIEW_NAME } = PCore.getConstants();
+  if (routingInfo) {
+    const { accessedOrder, items } = routingInfo;
+    if (accessedOrder && items) {
+      const key = accessedOrder[accessedOrder.length - 1];
+      let componentVisible = accessedOrder.length > 0;
+      const { visible } = dispatchObjState;
+      componentVisible = visible || componentVisible;
+      if (items[key] && items[key].view && !isEmptyObject(items[key].view)) {
+        const latestItem = items[key];
+        const rootView = latestItem.view;
+        const { context, name: viewName } = rootView.config;
+        const config: any = { meta: rootView };
+        config.options = {
+          context: latestItem.context,
+          pageReference: context || getPConnect().getPageReference(),
+          containerName: getPConnect().getContainerName(),
+          containerItemName: key,
+          hasForm: viewName === CREATE_DETAILS_VIEW_NAME
+        };
+        const configObject: any = PCore.createPConnect(config);
+
+        // Add in displayOnlyFA if prop is on ViewContainer
+        if (displayOnlyFA) {
+          configObject.displayOnlyFA = true;
+        }
+
+        setRootComponent(configObject);
+        return (
+          <React.Fragment key={theBuildName}>
+            {componentVisible && root}
+            {loadingInfo && (
+              <Box textAlign='center'>
+                <CircularProgress />
+              </Box>
+            )}
+          </React.Fragment>
+        );
+      }
+    }
+  }
+
+  // fall through return if insufficient routingInfo
+  return (
+    <React.Fragment key={theBuildName}>
+      {loadingInfo && (
+        <Box textAlign='center'>
+          <CircularProgress />
+        </Box>
+      )}
+    </React.Fragment>
+  );
+}

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

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