@pega/constellationjs 1.0.19 → 1.0.21

package/__DO_NOT_COMMIT/8.8.0-20221209-LPtesting/lib_asset.json

@@ -0,0 +1,7 @@
+{
+  "isSdk": true,
+  "isDevServerMode": false,
+  "externals": [],
+  "entry": [],
+  "prerequisite": [{ "constellation-core.d9eb3b84.js": "" }]
+}

package/__DO_NOT_COMMIT/8.8.0-LP-fix-20221118/bootstrap-shell.js

@@ -0,0 +1,616 @@
+const rootContainerWithHybrid = {
+  type: 'RootContainer',
+  config: {
+    renderingMode: 'hybrid'
+  },
+  children: [
+    {
+      type: 'HybridViewContainer',
+      config: {
+        routingInfo: '@ROUTING_INFO',
+        name: 'primary',
+        contextName: 'app'
+      },
+      children: []
+    }
+  ]
+};
+
+const buildSemanticUrl = (constellationPathInfo, queryParams, noPortal, restServer, viewName) => {
+  const urlSearchParams = new URLSearchParams(queryParams);
+
+  let isNoPortalParam = false;
+  if (noPortal === 'true') {
+    isNoPortalParam = true;
+  }
+
+  let caseOrPageName = null;
+  let caseWork = null;
+  if (constellationPathInfo) {
+    if (constellationPathInfo.startsWith('/')) {
+      constellationPathInfo = constellationPathInfo.substring(1);
+    }
+    const pathTokens = constellationPathInfo.split('/');
+    if (pathTokens.length > 0 && pathTokens[0]) {
+      caseOrPageName = pathTokens[0];
+    }
+    if (pathTokens.length > 1 && pathTokens[1]) {
+      caseWork = pathTokens[1];
+    }
+  } else {
+    isNoPortalParam = false;
+  }
+
+  let constellationUrl = restServer;
+  if (caseOrPageName) {
+    constellationUrl = `${constellationUrl}/${caseOrPageName}`;
+  }
+  if (caseWork) {
+    constellationUrl = `${constellationUrl}/${caseWork}`;
+  }
+
+  if (isNoPortalParam) {
+    !urlSearchParams.has('noPortal') && urlSearchParams.append('noPortal', true);
+    if (caseWork && viewName) {
+      urlSearchParams.append('view', viewName);
+    }
+  }
+  const searchParamsString = urlSearchParams.toString();
+  constellationUrl += searchParamsString ? `?${searchParamsString}` : '';
+
+  return constellationUrl;
+};
+
+let containerCount = 0;
+
+const loadView = (
+  targetDom,
+  viewMetadata,
+  preLoadComponents = [],
+  runtimeParams,
+  portalTarget,
+  styleSheetTarget,
+  containerTargetName
+) => {
+  // eslint-disable-next-line no-plusplus
+  const targetName = containerTargetName === 'hybrid' ? `hybrid_${++containerCount}` : containerTargetName;
+  const containerName = targetName || `mashup${++containerCount}`;
+  const rootContainer = {
+    type: 'RootContainer',
+    config: {
+      renderingMode: 'portal',
+      viewConfig: '@P .viewConfig',
+      name: containerName
+    }
+  };
+  window.PCore.getRuntimeParamsAPI().setRuntimeParams(runtimeParams);
+  constellationCore
+    .loadRootComponent(targetDom, rootContainer, preLoadComponents, portalTarget, styleSheetTarget)
+    .then(() => {
+      return constellationCore.updateStoreWithUiRoot(viewMetadata, containerName);
+    });
+};
+
+const loadPortal = (targetDom, portalName, preLoadComponents = [], containerTargetName) => {
+  const containerName = containerTargetName || `portal${++containerCount}`;
+  const rootContainer = {
+    type: 'RootContainer',
+    config: {
+      viewConfig: '@P .viewConfig',
+      renderingMode: 'portal',
+      skeleton: 'LoadingComponent',
+      name: containerName
+    }
+  };
+  preLoadComponents.push(rootContainer.config.skeleton);
+  PCore.getEnvironmentInfo().isPortalLoaded = true;
+  constellationCore.loadRootComponent(targetDom, rootContainer, preLoadComponents).then(() => {
+    return constellationCore.loadPortalView(portalName, containerName);
+  });
+};
+
+const loadComponent = (targetDom, componentMetadata, preLoadComponents) => {
+  return constellationCore.loadComponent(componentMetadata, targetDom, preLoadComponents);
+};
+
+/**
+ * Loads the view with the viewName under the targetDom
+ * @param {string} targetDom
+ * @param {string} viewName
+ * @param portalName
+ * @param viewClass
+ * @param additionalComponents
+ * @param portalTarget
+ * @param styleSheetTarget
+ * @param containerTargetName
+ */
+const loadViewByName = (
+  targetDom,
+  viewName,
+  portalName,
+  viewClass,
+  additionalComponents,
+  portalTarget,
+  styleSheetTarget,
+  containerTargetName
+) => {
+  const containerName = containerTargetName || `mashup${++containerCount}`;
+  const rootContainer = {
+    type: 'RootContainer',
+    config: {
+      viewConfig: '@P .viewConfig',
+      renderingMode: 'view',
+      name: containerName
+    }
+  };
+  constellationCore
+    .loadRootComponent(targetDom, rootContainer, additionalComponents, portalTarget, styleSheetTarget)
+    .then(() => {
+      return constellationCore.loadViewByName(viewName, portalName, viewClass, containerName);
+    });
+};
+
+const loadMashup = (targetDom, usePegaMashupStyling = true) => {
+  const rootMashUp = {
+    type: 'RootContainer',
+    config: {
+      renderingMode: 'noPortal'
+    },
+    children: [
+      {
+        type: 'ViewContainer',
+        config: {
+          routingInfo: '@ROUTING_INFO',
+          name: 'primary'
+        }
+      }
+    ]
+  };
+
+  // NOTE: We CANNOT force other consumers (ex: Quasar Mashup) to use this styling
+  if (usePegaMashupStyling) {
+    const targetDomElement =
+      document.getElementsByTagName(targetDom)[0] && document.getElementsByTagName(targetDom)[0].parentNode;
+    if (targetDomElement) {
+      const mashupStyle = document.createElement('style');
+      mashupStyle.setAttribute('id', 'portal-less-styles');
+      mashupStyle.innerHTML = `app-root.mashup > .case-view, app-root.mashup > .page-view { min-height: 0px !important; }`;
+      targetDomElement.appendChild(mashupStyle);
+    }
+  }
+
+  constellationCore.loadRootComponent(targetDom, rootMashUp, ['View', 'ViewContainer']);
+
+  /* US-350587 : Support the resize desktop action in mashup */
+  if (window.parent !== window) {
+    import(
+      `${constellationCore.PCoreInstance.getAssetLoader().getStaticServerUrl()}constellation-mashup-bridge.js`
+    ).then((mod) => {
+      mod.mashup.init({
+        resizing: 'stretch'
+      });
+    });
+  }
+};
+
+const loadCase = (targetDom, caseId, preLoadComponents = [], portalTarget, styleSheetTarget) => {
+  preLoadComponents.push('HybridViewContainer', 'View');
+  constellationCore
+    .loadRootComponent(targetDom, rootContainerWithHybrid, preLoadComponents, portalTarget, styleSheetTarget)
+    .then(() => {
+      return constellationCore.getCaseApi().openCase(caseId, 'app', 'primary');
+    });
+};
+
+const createCase = (targetDom, caseId, preLoadComponents = [], portalTarget, styleSheetTarget) => {
+  preLoadComponents.push('HybridViewContainer', 'View');
+  constellationCore
+    .loadRootComponent(targetDom, rootContainerWithHybrid, preLoadComponents, portalTarget, styleSheetTarget)
+    .then(() => {
+      return constellationCore.getCaseApi().createCase(caseId, 'app', 'primary');
+    });
+};
+
+const loadAssignment = (targetDom, assignmentId, preLoadComponents = [], portalTarget, styleSheetTarget) => {
+  preLoadComponents.push('HybridViewContainer', 'View');
+  constellationCore
+    .loadRootComponent(targetDom, rootContainerWithHybrid, preLoadComponents, portalTarget, styleSheetTarget)
+    .then(() => {
+      return constellationCore.getCaseApi().openAssignment(assignmentId, 'app', 'primary');
+    });
+};
+
+const initCoreConfig = (config) => {
+  const {
+    routingInfo,
+    actionModel,
+    serviceConfig,
+    additionalHeaders,
+    tokens,
+    semanticUrl,
+    queryParams,
+    noPortal,
+    timezone,
+    noHistory,
+    viewName,
+    theme,
+    fieldDefaults,
+    restServerConfig,
+    dynamicLoadComponents = true,
+    dynamicSemanticUrl = true,
+    enableRouting = true,
+    locale,
+    environmentInfo,
+    renderingMode = 'FULL_PORTAL',
+    remoteCaseMapping = {}
+  } = config;
+  const {
+    appAlias,
+    googleMapKey,
+    staticContentServer,
+    appStaticContentServer = null,
+    contextPath,
+    messagingService = null
+  } = serviceConfig;
+
+  const envInfo = { ...environmentInfo, renderingMode };
+
+  // eslint-disable-next-line no-restricted-globals
+  let restServer = location.origin;
+  const behaviorOverrides = {}; // Used below to set/check Mashup settings that will change bootstrap behavior
+
+  // config.restServerConfig can be specified to override the default rest server
+  if (undefined !== restServerConfig) {
+    // Mashup (Quasar) usage - use provided override in restServerConfig
+    restServer = restServerConfig;
+  }
+
+  if (contextPath) {
+    restServer = `${restServer}${contextPath}`;
+  }
+  if (appAlias) {
+    restServer = `${restServer}/${appAlias}`;
+  }
+
+  // Set up behaviorOverrides as specified in config for Mashup (Quasar) usage
+  //  Note that, for normal use, dynamicSemanticUrl, dynamicLoadComponents
+  //  and dynamicSetCookie default to true
+  if (dynamicSemanticUrl === true) {
+    // Standard usage - no override
+    const semUrl = buildSemanticUrl(semanticUrl, queryParams, noPortal, restServer, viewName);
+    // Do not push history state for bridge cases in infinity
+    if (!noHistory && semUrl) {
+      // eslint-disable-next-line no-restricted-globals
+      history.pushState({}, 'home', semUrl);
+    }
+  } else if (!(renderingMode === 'HYBRID')) {
+    // Mashup (Quasar) usage
+    let redirectUrl = window.location.href;
+    if (redirectUrl.indexOf('?') > 0) {
+      redirectUrl = redirectUrl.substring(0, redirectUrl.indexOf('?'));
+      // eslint-disable-next-line no-restricted-globals
+      history.pushState({}, 'home', redirectUrl);
+    }
+    // make as override, so npm-core/src/router/app-router.js doesn't create semantic url
+    behaviorOverrides.dynamicSemanticUrl = false;
+  }
+
+  if (dynamicLoadComponents !== true) {
+    // Mashup (Quasar) usage
+    behaviorOverrides.dynamicLoadComponents = false;
+  }
+
+  // remaining use of appAlias is setting up the calls to the c11n service
+  // these calls should not be prepended with any form of additional servlet; app/{app-alias} only. bug-627186
+  let appAliasNarrow = null;
+  if (appAlias) {
+    const idx = appAlias.indexOf('/app/');
+    appAliasNarrow = idx >= 0 ? appAlias.substring(idx + 1) : appAlias;
+  }
+
+  constellationCore.enableAppRouting(enableRouting);
+
+  if (Object.keys(behaviorOverrides).length > 0) {
+    // set it here, since it came in as false
+    PCore.setBehaviorOverrides(behaviorOverrides);
+  }
+
+  constellationCore.initStore();
+
+  /* Set Theme overrides to the instance */
+  if (theme) {
+    let themeObj = typeof theme === 'object' ? theme : null;
+    if (themeObj === null) {
+      try {
+        themeObj = JSON.parse(theme);
+      } catch {
+        themeObj = {};
+      }
+    }
+    PCore.getEnvironmentInfo().setTheme(themeObj);
+  }
+  /* Set default field configs */
+  constellationCore.setFieldsDefaultConfigs(fieldDefaults);
+  /* Set default headers */
+  constellationCore.setFetchDefaultHeaders(additionalHeaders);
+
+  const advRoutingInfo = {
+    ...routingInfo,
+    domain: `${window.location.protocol}//${window.location.host}`,
+    searchParams: window.location.search
+  };
+  /* Initialize server config */
+  constellationCore.initAppShell(advRoutingInfo, actionModel, { server: restServer });
+  constellationCore.setAppAlias(appAliasNarrow);
+  constellationCore.setGoogleMapsAPIKey(googleMapKey);
+  constellationCore.setStaticServerUrl(staticContentServer, appStaticContentServer, tokens.C11NB2S);
+  constellationCore.PCoreInstance.getLocaleUtils().setTimezone(timezone);
+
+  PCore.getEnvironmentInfo().setLocale(locale);
+  PCore.getRemoteCaseUtils().setRemoteCaseMapping(remoteCaseMapping);
+  PCore.getEnvironmentInfo().setEnvironmentInfo(envInfo);
+  PCore.getMessagingServiceManager().setConnectionConfig({ messagingService });
+  PCore.getNavigationUtils().init();
+};
+
+const importConstellationCore = async (staticContentServer, assets) => {
+  const { isDevServerMode, isSdk } = assets;
+  const { prerequisite } = assets;
+  if (prerequisite && prerequisite.length > 0) {
+    const corePrerequisite = prerequisite[0];
+    let serviceUrl;
+    const coreFileName = Object.keys(corePrerequisite)[0];
+    if (isDevServerMode) {
+      const coreDevServerUrl = Object.values(corePrerequisite)[0];
+      serviceUrl = coreDevServerUrl.endsWith('/')
+        ? `${coreDevServerUrl}prerequisite/${coreFileName}`
+        : `${coreDevServerUrl}/prerequisite/${coreFileName}`;
+    } else {
+      serviceUrl = staticContentServer.endsWith('/')
+        ? `${staticContentServer}prerequisite/${coreFileName}`
+        : `${staticContentServer}/prerequisite/${coreFileName}`;
+    }
+
+    if (isSdk) {
+      // SDKs only load the given constellation-core file from their own staticContentServer,
+      //  so we need to override some of the processing here (for normal Constellation service)
+      //  To accomplish this, SDKs will add isSdk: true to lib_asset.json.
+      //  Not specifying isSdk (or setting to false) will leave normal Cosmos React import unaffected.
+      //  Also, staticContentServer already ends with a slash serviceURl seems to start with a slash
+      //    so we need to collapse those to a single slash
+      const staticContentServerNoTrailingSlash = staticContentServer.endsWith('/')
+        ? staticContentServer.slice(0, -1)
+        : staticContentServer;
+      const coreFileNoLeadingSlash = coreFileName.startsWith('/') ? coreFileName.slice(1) : coreFileName;
+      //
+      serviceUrl = `${staticContentServerNoTrailingSlash}/prerequisite/${coreFileNoLeadingSlash}`;
+    }
+
+    return import(serviceUrl).then((mod) => {
+      window.constellationCore = mod;
+      constellationCore.setStaticServerUrl(staticContentServer, 'no-appstatic');
+
+      /* Set up PCore object (public API used by Nebula) - remove if once code merged in constellationUI repo */
+      if (window.constellationCore.PCoreInstance !== undefined) {
+        window.PCore = window.constellationCore.PCoreInstance;
+      }
+      for (let i = 1; i < prerequisite.length; i += 1) {
+        const prerequisiteItem = prerequisite[i];
+        const prerequisiteItemFileName = Object.keys(prerequisiteItem)[0];
+        if (isDevServerMode) {
+          const prerequisiteItemDevServerUrl = Object.values(prerequisiteItem)[0];
+          import(`${prerequisiteItemDevServerUrl}prerequisite/${prerequisiteItemFileName}`).then((module) => {
+            console.log(module);
+          });
+        } else {
+          import(`${staticContentServer}prerequisite/${prerequisiteItemFileName}`).then((module) => {
+            console.log(module);
+          });
+        }
+      }
+    });
+  }
+  return null;
+};
+
+const importExternals = async (assets) => {
+  const { isDevServerMode } = assets;
+  const pCore = constellationCore.PCoreInstance;
+  await pCore.getAssetLoader().loadAssets(assets.externals, {
+    isDevServerMode
+  });
+  await pCore.getAssetLoader().loadAssets(assets.entry, {
+    isDevServerMode
+  });
+  // Get the generic locale bundle
+  const userLocale = pCore.getEnvironmentInfo().getLocale();
+  if (userLocale !== 'en-US') {
+    try {
+      const genericLocaleRule = pCore.getLocaleUtils().GENERIC_BUNDLE_KEY;
+      const genericLocaleRes = await pCore.getAssetLoader().getSvcLocale(userLocale, `${genericLocaleRule}.json`);
+      if (genericLocaleRes.ok) {
+        const genericLocaleJson = await genericLocaleRes.json();
+        pCore.getLocaleUtils().setLocaleForRule(genericLocaleJson, genericLocaleRule);
+      }
+    } catch (e) {
+      console.warn(e);
+    }
+  }
+};
+
+const importAssetsJson = async (staticContentServer) => {
+  const randomHash = new Date().getTime(); /* Math.floor(100 + Math.random() * 900); */
+  return fetch(`${staticContentServer}lib_asset.json?v=${randomHash}`).then((res) => res.json());
+};
+
+const importReactRoot = async () => {
+  const promises = [];
+  PCore.getComponentsRegistry()
+    .getComponent('ReactRoot')
+    .modules.forEach((module) => {
+      promises.push(module());
+    });
+  return Promise.allSettled(promises);
+};
+
+// callback  is optional, recommended way is to handle the promise returned
+const bootstrap = async (config, callback) => {
+  // this to be dynamic eventually; switch between rect and vue and ?, prod and debug builds
+  // config.serviceConfig.staticContentServer = "https://localhost:3002/";
+  // if (config.serviceConfig.appStaticContentServer) config.serviceConfig.staticContentServer += "prod/"
+
+  const bootStrapingFn = async (resolve, reject) => {
+    try {
+      const { staticContentServer } = config.serviceConfig;
+      const assets = await importAssetsJson(staticContentServer);
+      await importConstellationCore(staticContentServer, assets);
+      initCoreConfig(config);
+      const loadReactRoot = async () => {
+        await importReactRoot();
+        if (callback) callback();
+        resolve(true);
+      };
+      PCore.getPubSubUtils().subscribe('component-map-loaded', loadReactRoot);
+      await importExternals(assets);
+      // Resolve promise if "ReactRoot" is loaded (Hybrid  scenario)
+      if ('ReactRoot' in PCore.getComponentsRegistry().getLazyMap()) {
+        resolve(true);
+      }
+    } catch (error) {
+      reject(error);
+    }
+  };
+
+  return new Promise(bootStrapingFn);
+};
+
+const getBootstrapConfig = async (restServerUrl, authorizationHeader) => {
+  return fetch(`${restServerUrl}/api/application/v2/data_views/D_pxBootstrapConfig`, {
+    method: 'GET',
+    headers: new Headers({
+      Authorization: authorizationHeader
+    })
+  }).then((response) => response.json());
+};
+
+const loadRootContainer = (targetDom, preLoadComponents = [], portalTarget, styleSheetTarget) => {
+  preLoadComponents.push('HybridViewContainer', 'View');
+  return constellationCore.loadRootComponent(
+    targetDom,
+    rootContainerWithHybrid,
+    preLoadComponents,
+    portalTarget,
+    styleSheetTarget
+  );
+};
+
+const bootstrapWithAuthHeader = async (config, target, preLoadComponents = [], portalTarget, styleSheetTarget) => {
+  // Adding restServerConfig, dynamicLoadComponents, dynamicSemanticUrl, and dynamicSetCookie needed for Mashup (Quasar) usage
+  const {
+    restServerUrl,
+    customRendering = false,
+    onPCoreReadyCallback,
+    staticContentServerUrl,
+    dynamicSetCookie = false,
+    authInfo = {},
+    theme = {},
+    renderingMode
+  } = config;
+  let { authorizationHeader, appAlias } = config;
+
+  let bootRes;
+  if (authorizationHeader && Object.keys(authInfo).length === 0) {
+    // custom authentication
+    authInfo.authType = 'custom';
+  }
+  if (!authorizationHeader && authInfo.tokenInfo) {
+    const { tokenInfo } = authInfo;
+    authorizationHeader = `${tokenInfo.token_type} ${tokenInfo.access_token}`;
+  }
+  if (appAlias) {
+    appAlias = appAlias.indexOf('/') !== -1 ? appAlias : `app/${appAlias}`;
+    bootRes = await getBootstrapConfig(`${restServerUrl}/${appAlias}`, authorizationHeader);
+  } else {
+    bootRes = await getBootstrapConfig(`${restServerUrl}`, authorizationHeader);
+  }
+  const bootConfig = JSON.parse(bootRes.pyConfigJSON);
+  bootConfig.restServerConfig = restServerUrl;
+  bootConfig.dynamicSemanticUrl = false;
+  bootConfig.dynamicSetCookie = dynamicSetCookie;
+  bootConfig.enableRouting = false;
+  bootConfig.serviceConfig.contextPath = '';
+  bootConfig.serviceConfig.appAlias = appAlias;
+  bootConfig.additionalHeaders = {
+    Authorization: authorizationHeader
+  };
+
+  bootConfig.dynamicLoadComponents = !customRendering;
+  bootConfig.dynamicSemanticUrl = !customRendering;
+  bootConfig.noHistory = true;
+  bootConfig.theme = theme ?? {};
+  bootConfig.renderingMode = renderingMode ?? bootConfig.renderingMode;
+
+  const staticContentServer = staticContentServerUrl || bootConfig.serviceConfig.staticContentServer;
+  /**
+   * updating bootconfig to make sure staticContentServerUrl is not overridden again through bootConfig
+   */
+  bootConfig.serviceConfig.staticContentServer = staticContentServer;
+
+  const assets = await importAssetsJson(staticContentServer);
+  await importConstellationCore(staticContentServer, assets);
+  initCoreConfig(bootConfig);
+  if (onPCoreReadyCallback) {
+    window.PCore.onPCoreReady(onPCoreReadyCallback);
+  }
+  if (authInfo && ['OAuth2.0', 'custom'].includes(authInfo?.authType)) {
+    constellationCore.setFetchAuthInfo(authInfo);
+  }
+
+  if (!customRendering) {
+    const bootstrapingFn = async (resolve, reject) => {
+      try {
+        const loadReactRoot = async () => {
+          await importReactRoot();
+          resolve(true);
+        };
+        PCore.getPubSubUtils().subscribe('component-map-loaded', loadReactRoot);
+        await importExternals(assets);
+        // Resolve promise if "ReactRoot" is loaded (Hybrid  scenario)
+        if ('ReactRoot' in PCore.getComponentsRegistry().getLazyMap()) {
+          resolve(true);
+        }
+      } catch (error) {
+        reject(error);
+      }
+    };
+
+    const tempPromise = new Promise(bootstrapingFn);
+    await tempPromise;
+    await loadRootContainer(target, preLoadComponents, portalTarget, styleSheetTarget);
+  }
+};
+const initConstellationCore = async (staticContentServer) => {
+  // const { staticContentServer } = config.serviceConfig;
+  const assets = await importAssetsJson(staticContentServer);
+  await importConstellationCore(staticContentServer, assets);
+};
+
+const isNewUnifiedBuild = () => {
+  /* TEMP will remove it */
+  return false;
+};
+
+export {
+  bootstrap,
+  loadView,
+  loadPortal,
+  loadComponent,
+  loadMashup,
+  loadViewByName,
+  loadCase,
+  createCase,
+  loadAssignment,
+  bootstrapWithAuthHeader,
+  initConstellationCore,
+  isNewUnifiedBuild
+};