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

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

package/tests/assets/sdk-r/components/createAll/override-sdk/template/DynamicTabs/DynamicTabs.tsx

@@ -0,0 +1,80 @@
+import React, { Children, useMemo, useState } from 'react';
+import { Tab, Tabs } from '@mui/material';
+import { TabContext, TabPanel } from '@mui/lab';
+import makeStyles from '@mui/styles/makeStyles';
+
+import { buildView } from '@pega/react-sdk-components/lib/components/helpers/field-group-utils';
+import { PConnProps } from '@pega/react-sdk-components/lib/types/PConnProps';
+
+const useStyles = makeStyles(() => ({
+  tab: {
+    minWidth: '72px'
+  }
+}));
+
+interface DynamicTabsProps extends PConnProps {
+  // If any, enter additional props that only exist on this component
+  showLabel: boolean;
+  label: string;
+  referenceList?: any[];
+}
+
+function DynamicTabs(props: DynamicTabsProps) {
+  const classes = useStyles();
+  const { referenceList, showLabel, label, getPConnect } = props;
+  const pConnect = getPConnect();
+  // Get the inherited props from the parent to determine label settings
+  const propsToUse = { label, showLabel, ...pConnect.getInheritedProps() };
+  const defaultTabIndex = 0;
+  // @ts-ignore - Property 'getComponentConfig' is private and only accessible within class 'C11nEnv'.
+  const { tablabel } = pConnect.getComponentConfig();
+  const tablabelProp = PCore.getAnnotationUtils().getPropertyName(tablabel);
+  const referenceListData: any = pConnect.getValue(`${referenceList}.pxResults`, ''); // 2nd arg empty string until typedefs properly allow optional
+  const memoisedTabViews = useMemo(() => {
+    pConnect.setInheritedProp('displayMode', 'DISPLAY_ONLY');
+    pConnect.setInheritedProp('readOnly', true);
+
+    return (
+      referenceListData &&
+      Children.toArray(
+        referenceListData.map((item, index) => {
+          return <React.Fragment key={item[tablabelProp]}>{buildView(pConnect, index, '')}</React.Fragment>;
+        })
+      )
+    );
+  }, [referenceListData]);
+  const [panelShown, changePanel] = useState(defaultTabIndex);
+  const handleTabClick = (e, id) => {
+    changePanel(parseInt(id, 10));
+  };
+  // Loop over the tab contents and and pull out the labels for the navigation
+  const tabItems =
+    referenceListData?.map((item, i) => {
+      const currentTabLabel = item[tablabelProp] || PCore.getLocaleUtils().getLocaleValue('No label specified in config', 'Generic');
+      return {
+        name: currentTabLabel,
+        id: i
+      };
+    }) || [];
+
+  return (
+    <>
+      {propsToUse.label && <h3 id='dynamic-tabs-title'>{propsToUse.label}</h3>}
+      <TabContext value={panelShown.toString()}>
+        <Tabs onChange={handleTabClick} value={panelShown} variant='scrollable' scrollButtons='auto' indicatorColor='primary' id='dynamic-tabs'>
+          {tabItems.map((tab: any) => (
+            <Tab key={tab.id} label={tab.name} value={tab.id} className={classes.tab} />
+          ))}
+        </Tabs>
+
+        {tabItems.map((tab: any) => (
+          <TabPanel key={tab.id} value={tab.id.toString()} tabIndex={+tab.id} id='dynamic-tabpanel'>
+            <div>{memoisedTabViews[parseInt(tab.id, 10)] || 'No content exists'}</div>
+          </TabPanel>
+        ))}
+      </TabContext>
+    </>
+  );
+}
+
+export default DynamicTabs;

package/tests/assets/sdk-r/components/createAll/override-sdk/template/DynamicTabs/config.json

@@ -0,0 +1,36 @@
+{
+  "name": "DynamicTabs",
+  "label": "Dynamic tabs (list)",
+  "description": "Dynamic tabs (list)",
+  "type": "Template",
+  "subtype": "DETAILS",
+  "icon": "DynamicTabs.svg",
+  "hideTemplateEdit": true,
+  "hideFromTemplatePicker": true,
+  "viewHeadingLabel": "Default heading",
+  "properties": [
+    {
+      "name": "referenceList",
+      "label": "Data page",
+      "format": "CONTENTPICKERSOURCE"
+    },
+    {
+      "name": "parameters",
+      "label": "Parameters",
+      "format": "PARAMETERS",
+      "showOverride": false
+    },
+    {
+      "name": "tablabel",
+      "label": "Tab label",
+      "format": "PROPERTY",
+      "ofContextClass": true
+    },
+    {
+      "format": "VIEWPICKER",
+      "name": "Views",
+      "label": "Tab content",
+      "ofContextClass": true
+    }
+  ]
+}

package/tests/assets/sdk-r/components/createAll/override-sdk/template/DynamicTabs/index.tsx

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

package/tests/assets/sdk-r/components/createAll/override-sdk/template/ListView/ListView.tsx

@@ -1034,34 +1034,35 @@ export default function ListView(props: ListViewProps) {
                     </TableRow>
                   </TableHead>
                   <TableBody>
-                    {stableSort(arRows, getComparator(order, orderBy))
-                      .slice(page * rowsPerPage, page * rowsPerPage + rowsPerPage)
-                      .map(row => {
-                        return (
-                          <TableRow key={row.pxRefObjectInsName || row.pyID}>
-                            {arColumns.map(column => {
-                              const value = row[column.id];
-                              return (
-                                <TableCell key={column.id} align={column.align} className={classes.cell}>
-                                  {_showButton(column.id, row) || column.displayAsLink ? (
-                                    <Link
-                                      component='button'
-                                      onClick={() => {
-                                        _listViewClick(row, column);
-                                      }}
-                                      underline='hover'
-                                    >
-                                      {column.format && typeof value === 'number' ? column.format(value) : value}
-                                    </Link>
-                                  ) : (
-                                    <>{column.format && typeof value === 'number' ? column.format(value) : value || '---'}</>
-                                  )}
-                                </TableCell>
-                              );
-                            })}
-                          </TableRow>
-                        );
-                      })}
+                    {arRows &&
+                      stableSort(arRows, getComparator(order, orderBy))
+                        .slice(page * rowsPerPage, page * rowsPerPage + rowsPerPage)
+                        .map(row => {
+                          return (
+                            <TableRow key={row.pxRefObjectInsName || row.pyID}>
+                              {arColumns.map(column => {
+                                const value = row[column.id];
+                                return (
+                                  <TableCell key={column.id} align={column.align} className={classes.cell}>
+                                    {_showButton(column.id, row) || column.displayAsLink ? (
+                                      <Link
+                                        component='button'
+                                        onClick={() => {
+                                          _listViewClick(row, column);
+                                        }}
+                                        underline='hover'
+                                      >
+                                        {column.format && typeof value === 'number' ? column.format(value) : value}
+                                      </Link>
+                                    ) : (
+                                      <>{column.format && typeof value === 'number' ? column.format(value) : value || '---'}</>
+                                    )}
+                                  </TableCell>
+                                );
+                              })}
+                            </TableRow>
+                          );
+                        })}
                   </TableBody>
                 </Table>
               </TableContainer>

package/tests/assets/sdk-r/components/createAll/override-sdk/template/SimpleTableManual/SimpleTableManual.tsx

@@ -258,11 +258,16 @@ export default function SimpleTableManual(props: PropsWithChildren<SimpleTableMa
   function generateRowsData() {
     // if referenceList is empty and dataPageName property value exists then make a datapage fetch call and get the list of data.
     if (!referenceList.length && dataPageName) {
-      getDataPage(dataPageName, parameters, context).then(listData => {
-        const data = formatRowsData(listData);
-        myRows = data;
-        setRowData(data);
-      });
+      getDataPage(dataPageName, parameters, context)
+        .then(listData => {
+          const data = formatRowsData(listData);
+          myRows = data;
+          setRowData(data);
+        })
+        .catch(e => {
+          // eslint-disable-next-line no-console
+          console.log(e);
+        });
     } else {
       // The referenceList prop has the JSON data for each row to be displayed
       //  in the table. So, iterate over referenceList to create the dataRows that
@@ -378,6 +383,9 @@ export default function SimpleTableManual(props: PropsWithChildren<SimpleTableMa
   };
 
   function descendingComparator<T>(a: T, b: T, orderedBy: keyof T) {
+    if (!orderedBy || (!a[orderedBy] && !b[orderedBy])) {
+      return 0;
+    }
     if (!b[orderedBy] || b[orderedBy] < a[orderedBy]) {
       return -1;
     }