@pega/custom-dx-components 0.24.15 → 0.242.1

package/src/tasks/init/template/tasks.config.json

@@ -4,7 +4,7 @@
     "rulesetName": "CustomDXComponents",
     "rulesetVersion": "01-01-01",
     "sourceOfComponents": "Server",
-    "devBuild": false,
+    "devBuild": true,
     "serverType": "infinity",
     "server": "https://localhost:1080/prweb",
     "clientId": "10095186356008396159",
@@ -35,5 +35,6 @@
     "description": "",
     "icon": ""
   },
-  "usePromotedWebPack": false
+  "usePromotedWebPack": false,
+  "libraryBased": false
 }

package/src/tasks/list/index.js

@@ -2,7 +2,7 @@ import inquirer from 'inquirer';
 import ora from 'ora';
 import chalk from 'chalk';
 
-import { showVersion, getPegaServerConfig } from '../../util.js';
+import { showVersion, getPegaServerConfig, getLibraryBased } from '../../util.js';
 
 import {
   listLocalComponents,
@@ -13,6 +13,9 @@ import {
   getListComponentsQuestions
 } from './helper.js';
 
+const isLibraryBased = await getLibraryBased();
+
+
 const getList = async (sourceOfComponents, answers) => {
   const defaultPegaServerConfig = await getPegaServerConfig();
   const isLaunchpad = defaultPegaServerConfig.serverType === 'launchpad';
@@ -69,8 +72,11 @@ export default async (options) => {
   showVersion();
 
   let sourceOfComponentsOption = SOURCE_OF_COMPONENT_TYPES.LOCAL;
-
-  if (options.params[3] === SOURCE_OF_COMPONENT_TYPES.LOCAL) {
+  if (isLibraryBased) {
+    sourceOfComponentsOption = SOURCE_OF_COMPONENT_TYPES.LOCAL;
+    await getList(sourceOfComponentsOption);
+  }
+  else if (options.params[3] === SOURCE_OF_COMPONENT_TYPES.LOCAL) {
     sourceOfComponentsOption = options.params[3];
     await getList(sourceOfComponentsOption);
   } else if (options.params[3] === SOURCE_OF_COMPONENT_TYPES.SERVER) {

package/src/tasks/list-lib/helper.js

@@ -0,0 +1,72 @@
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+
+import {
+  getPegaServerConfig,
+  checkPathAccess,
+  getComponentDefaults
+} from '../../util.js';
+import { TASKS_CONFIG_JSON_FILENAME, COMPONENTS_DIRECTORY_PATH, COMPONENTS_PATH } from '../../constants.js';
+
+export const SOURCE_OF_COMPONENT_TYPES = {
+  SERVER: 'Server',
+  LOCAL: 'Local'
+};
+
+const pegaConfigJsonPath = path.join(path.resolve(), TASKS_CONFIG_JSON_FILENAME);
+
+export const getOrgLib = async () => {
+  const defaultPegaConfig = await getPegaServerConfig();
+
+  await checkPathAccess(pegaConfigJsonPath);
+
+  let data = fs.readFileSync(pegaConfigJsonPath, { encoding: 'utf8' });
+  data = data && JSON.parse(data);
+
+  if (!data[COMPONENTS_DIRECTORY_PATH]) {
+    console.error(`${chalk.red.bold('ERROR')} Could not able find components directory path in config.json`);
+    process.exit(1);
+  }
+
+  const componentData = data[COMPONENTS_PATH];
+
+  let library;
+  ({ library } = componentData);
+  let { organization } = JSON.parse(fs.readFileSync(path.resolve('package.json'), 'utf8'));
+
+  const componentDefaults = await getComponentDefaults();
+  componentDefaults.library = library;
+  componentDefaults.organization = organization;
+
+  return componentDefaults;
+}
+
+export const getListLibraryQuestions = async (libraryName)  => {
+  const defaultPegaConfig = await getPegaServerConfig();
+
+
+  return [
+    {
+      name: 'sourceOfLibrary',
+      type: 'rawlist',
+      message: `List library ${chalk.bold.green(`${libraryName}`)} from Server or Local ?`,
+      choices: Object.values(SOURCE_OF_COMPONENT_TYPES),
+      default: defaultPegaConfig.sourceOfComponents,
+    }
+  ];
+};
+
+
+export const getLibraryVersionQuestion = async(libraryName, libVersions) => {
+
+    return [
+      {
+        name: 'version',
+        type: 'rawlist',
+        message: `Select ${chalk.green.bold(`${libraryName}`)} library version (or ALL) to delete`,
+        choices: libVersions
+      }
+    ];
+
+}

package/src/tasks/list-lib/index.js

@@ -0,0 +1,75 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+
+import {showVersion, getC11NB2STokenAndStaticServer, getLibraryVersions, getLibraryBased } from '../../util.js';
+
+import { listLib } from '@pega/constellation-dx-components-build-utils/index.js';
+
+import { getListLibraryQuestions, getLibraryVersionQuestion, getOrgLib, SOURCE_OF_COMPONENT_TYPES } from './helper.js';
+
+const isLibraryBased = await getLibraryBased();
+
+export default async (options) => {
+  if (!isLibraryBased) {
+    console.log(`Command only supported for ${chalk.bold.green('library based')} components.`)
+    process.exit();
+  }
+
+  showVersion();
+
+  let sourceOfLibrary;
+  let organization;
+  let library;
+
+  const compDef = await getOrgLib();
+  organization = compDef.organization;
+  library = compDef.library;
+  const libraryName = organization.concat("_").concat(library);
+
+  if (options.params.length >= 4) {
+    sourceOfLibrary = options.param[3];
+
+  }
+  else {
+
+    const questions = await getListLibraryQuestions(libraryName);
+    const answers = await inquirer.prompt(questions);
+    ({ sourceOfLibrary } = answers);
+
+  }
+
+  if (sourceOfLibrary === SOURCE_OF_COMPONENT_TYPES.LOCAL ) {
+    // local
+
+    let libVersions = await getLibraryVersions(libraryName);
+
+    if (libVersions.length > 0) {
+      libVersions = libVersions.map((name) => ({ 'Version': name}));
+        console.log(chalk.bold.blueBright(`\nList of ${libraryName} library versions`));
+        console.table(libVersions, ['Version']);
+
+    }
+    else {
+      // No library with that name
+      console.log(chalk.redBright(`No local library named: ${libraryName} exists.`));
+      process.exit(1);
+
+    }
+
+  }
+  else {
+    // server
+    const tokenAndStaticServer = await getC11NB2STokenAndStaticServer();
+
+    if (tokenAndStaticServer.C11NB2S === undefined) {
+      console.log(chalk.redBright("Need to authenticate, missing services token.\nDeleting a library requires authentication to acquire a token to delete."));
+      process.e
+      exit(1);
+    }
+
+    await listLib(tokenAndStaticServer.C11NB2S, tokenAndStaticServer.appStaticContentServer);
+
+  }
+
+  return true;
+};

package/src/tasks/promote-webpack/index.js

@@ -10,7 +10,8 @@ import {
   convertIntoPascalCase,
   checkPathAccess,
   showVersion,
-  updateUseWebPackPromotion
+  updateUseWebPackPromotion,
+  getLibraryBased
 } from '../../util.js';
 
 import {
@@ -21,6 +22,7 @@ import {
   BUILDER_DIR_FILE_PATH
 } from '../../constants.js';
 
+const isLibraryBased = await getLibraryBased();
 
 
 export const copyWebPack = async () => {
@@ -92,6 +94,11 @@ export const copyWebPack = async () => {
 
 
 export default async options => {
+  if (isLibraryBased) {
+    console.log(`Command only supported for ${chalk.bold.green('non library based')} components.`)
+    process.exit();
+  }
+
   showVersion();
 
   await copyWebPack();

package/src/tasks/promote-webpack/webpack.config.js

@@ -345,6 +345,7 @@ module.exports = (
         resourceRegExp: /^\.\/locale$/,
         contextRegExp: /moment$/
       }),
+      /* cosmos 4.x and below */
       /* Ignore cosmos icons */
       new webpack.IgnorePlugin({
         resourceRegExp: /^\.\/icons$/,
@@ -357,6 +358,31 @@ module.exports = (
         contextRegExp: /@pega\\cosmos-react-core\\lib\\components\\Icon$/
       }),
 
+      /* Ignore cosmos streamline-icons */
+      new webpack.IgnorePlugin({
+        resourceRegExp: /^\.\/streamline-icons$/,
+        contextRegExp: /@pega\/cosmos-react-core\/lib\/components\/Icon$/
+      }),
+
+      /* Ignore cosmos streamline-icons - windows */
+      new webpack.IgnorePlugin({
+        resourceRegExp: /^\.\/streamline-icons$/,
+        contextRegExp: /@pega\\cosmos-react-core\\lib\\components\\Icon$/
+      }),
+
+      /* cosmos 6.x and above */
+      /* Ignore cosmos icons */
+      new webpack.IgnorePlugin({
+        resourceRegExp: /^\.\/.*\/.*\.icon$/,
+        contextRegExp: /@pega\/cosmos-react-core\/lib\/components\/Icon$/
+      }),
+
+      /* Ignore cosmos icons - windows */
+      new webpack.IgnorePlugin({
+        resourceRegExp: /^\.\/.*\/.*\.icon$/,
+        contextRegExp: /@pega\\cosmos-react-core\\lib\\components\\Icon$/
+      }),
+
       new webpack.optimize.LimitChunkCountPlugin({
         maxChunks: 1
       }),

package/src/tasks/publish/index.js

@@ -5,11 +5,18 @@ import chalk from 'chalk';
 import validate from '../validator/index.js';
 import bundleComponent from '../bundle/index.js';
 import { lintComponent } from '../linter/index.js';
-import { getComponentDirectoryPath, showVersion } from '../../util.js';
+import { getComponentDirectoryPath, showVersion, getLibraryBased } from '../../util.js';
 
 import { getPublishComponentQuestions, publishComponentToServer, zipComponent } from './helper.js';
 
+const isLibraryBased = await getLibraryBased();
+
 export default async options => {
+  if (isLibraryBased) {
+    console.log(`Command only supported for ${chalk.bold.green('non library based')} components.`)
+    process.exit();
+  }
+
   showVersion();
 
   let componentKey;

package/src/tasks/publish-all/index.js

@@ -5,7 +5,7 @@ import chalk from 'chalk';
 import validate from '../validator/index.js';
 import bundleComponent from '../bundle/index.js';
 import { lintComponent } from '../linter/index.js';
-import { getComponents, getComponentDirectoryPath, showVersion } from '../../util.js';
+import { getComponents, getComponentDirectoryPath, showVersion, getLibraryBased } from '../../util.js';
 
 import {
   getPublishComponentQuestions,
@@ -14,6 +14,8 @@ import {
   cleanUp
 } from './helper.js';
 
+const isLibraryBased = await getLibraryBased();
+
 export function getCustomTasks(componentKey, sourceMap, devBuild, content, options) {
   const sDevBuild = devBuild ? '(dev build)' : '';
   // eslint-disable no-unneeded-ternary,no-nested-ternary
@@ -60,6 +62,11 @@ export function getCustomTasks(componentKey, sourceMap, devBuild, content, optio
 }
 
 export default async options => {
+  if (isLibraryBased) {
+    console.log(`Command only supported for ${chalk.bold.green('non library based')} components.`)
+    process.exit();
+  }
+
   showVersion();
 
   const components = await getComponents();

package/src/tasks/publish-lib/helper.js

@@ -0,0 +1,53 @@
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+
+import {
+  getPegaServerConfig,
+  checkPathAccess,
+  getComponentDefaults
+} from '../../util.js';
+import { TASKS_CONFIG_JSON_FILENAME, COMPONENTS_DIRECTORY_PATH, COMPONENTS_PATH } from '../../constants.js';
+
+const pegaConfigJsonPath = path.join(path.resolve(), TASKS_CONFIG_JSON_FILENAME);
+
+export const getOrgLib = async () => {
+  const defaultPegaConfig = await getPegaServerConfig();
+
+  await checkPathAccess(pegaConfigJsonPath);
+
+  let data = fs.readFileSync(pegaConfigJsonPath, { encoding: 'utf8' });
+  data = data && JSON.parse(data);
+
+  if (!data[COMPONENTS_DIRECTORY_PATH]) {
+    console.error(`${chalk.red.bold('ERROR')} Could not able find components directory path in config.json`);
+    process.exit(1);
+  }
+
+  const componentData = data[COMPONENTS_PATH];
+
+  let library;
+  ({ library } = componentData);
+  let { organization } = JSON.parse(fs.readFileSync(path.resolve('package.json'), 'utf8'));
+
+  const componentDefaults = await getComponentDefaults();
+  componentDefaults.library = library;
+  componentDefaults.organization = organization;
+
+  return componentDefaults;
+}
+
+
+
+export const getLibraryVersionQuestion = async(libVersions) => {
+
+    return [
+      {
+        name: 'version',
+        type: 'rawlist',
+        message: 'Select library version to publish',
+        choices: libVersions
+      }
+    ];
+
+}

package/src/tasks/publish-lib/index.js

@@ -0,0 +1,212 @@
+import inquirer from 'inquirer';
+import { Listr } from 'listr2';
+import chalk from 'chalk';
+
+import validate from '../validator/index.js';
+import { lintComponent } from '../linter/index.js';
+import { getComponentDirectoryPath, showVersion, getC11NB2STokenAndStaticServer, getLibraryVersions, getLibraryBased } from '../../util.js';
+
+import { publishLib, listLibJSONResponse, deleteLibVersion } from '@pega/constellation-dx-components-build-utils/index.js';
+
+import { getLibraryVersionQuestion, getOrgLib } from './helper.js';
+;
+
+const isLibraryBased = await getLibraryBased();
+
+export function getCustomTasks(componentKey, sourceMap, devBuild, options) {
+
+  const sDevBuild = devBuild ? '(dev build)' : '';
+  return new Listr(
+    [
+      {
+        title: 'Validate config schema',
+        task: async () => {
+          await validate(componentKey);
+        }
+      },
+      {
+        title: 'Lint component',
+        task: async () => {
+          const targetDirectory = await getComponentDirectoryPath(componentKey);
+          // console.log(`in buildComponent Lint component task: componentKey: ${componentKey} targetDirectory: ${targetDirectory}`);
+          await lintComponent(targetDirectory);
+        }
+      }
+
+    ],
+    { concurrent: false, exitOnError: true }
+  );
+
+
+}
+
+export const doesLibraryExist = async (libraryName, libraryVersion) => {
+
+  const tokenAndStaticServer = await getC11NB2STokenAndStaticServer();
+  const libList = await listLibJSONResponse(tokenAndStaticServer.C11NB2S, tokenAndStaticServer.appStaticContentServer);
+  const oList = JSON.parse(libList);
+
+  let libVersionExists = false;
+  let overrideExisting = false;
+  if (oList && Object.keys(oList).length !== 0 ) {
+    // need to parse data to find versions
+    let versionList = oList[libraryName];
+
+    if (versionList && versionList.includes(libraryVersion)) {
+      libVersionExists = true;
+    }
+  }
+
+  return libVersionExists;
+}
+
+
+export const publishNewLibraryAsync = async (libraryName, version, checkDeleted = false) => {
+
+  const tokenAndStaticServer = await getC11NB2STokenAndStaticServer();
+
+  if (checkDeleted ) {
+    console.log(chalk.yellow(`Verifying library has been deleted..`));
+    let libExists = await doesLibraryExist(libraryName, version);
+    let count = 0;
+    while (libExists) {
+      // keep checking until no longer exists
+      libExists = await doesLibraryExist(libraryName, version);
+      count ++;
+
+      if (count > 100) {
+        console.log(chalk.red.bold(`Library hasn't been deleted, can't proceed.`));
+        process.exit(1);
+      }
+    }
+
+    console.log(chalk.green(`Deleted..`));
+  }
+
+
+
+  console.log(chalk.green.bold(`Publishing Library ${libraryName}:${version} ... `));
+  publishLib(libraryName, version, tokenAndStaticServer.C11NB2S, tokenAndStaticServer.appStaticContentServer);
+
+}
+
+
+export default async (options) => {
+  if (!isLibraryBased) {
+    console.log(`Command only supported for ${chalk.bold.green('library based')} components.`)
+    process.exit();
+  }
+
+  showVersion();
+
+  let organization;
+  let library;
+  let version;
+  let devBuild;
+
+  let libraryName;
+
+
+  if (options.params.length >= 6) {
+    organization = options.params[3];
+    library = options.params[4];
+    version = options.params[5];
+    libraryName = organization.concat("_").concat(library);
+  }
+  else {
+
+    const tokenAndStaticServer = await getC11NB2STokenAndStaticServer();
+
+    if (tokenAndStaticServer.C11NB2S === undefined) {
+      console.log(chalk.redBright("Need to authenticate, missing services token.\nPublishing a library requires authentication to acquire a token to publish."));
+      process.exit(1);
+    }
+
+    const compDef = await getOrgLib();
+    organization = compDef.organization;
+    library = compDef.library;
+
+    libraryName = organization.concat("_").concat(library);
+
+    console.log(`\nLibrary ${chalk.bold.green(libraryName)} `)
+
+    const libVersions = await getLibraryVersions(libraryName);
+
+    if (libVersions.length > 0) {
+      const versionQuestions = await getLibraryVersionQuestion(libVersions);
+      const versionAnswers = await inquirer.prompt(versionQuestions);
+
+      ({version} = versionAnswers);
+
+      let okToPublish = true;
+      if (!version.includes("-dev")) {
+        okToPublish = false;
+        const publishAnswers = await inquirer.prompt([
+
+          {
+            name: 'confirmPublish',
+            type: 'confirm',
+            message: 'You are about to publish a PRODUCTION version which can NOT be deleted, proceed ?',
+            default: false
+          }
+        ]);
+        if (publishAnswers.confirmPublish) {
+          okToPublish = true;
+        }
+      }
+
+      if (okToPublish) {
+
+        let libVersionExists = await doesLibraryExist(libraryName, version);
+        let overrideExisting = false;
+        let checkDeleted = false;
+
+        if (libVersionExists) {
+            console.log("\nLibrary " + chalk.bold.yellow(`${libraryName}:${version}`) + " already exists.");
+            const questions = [
+              {
+                name: 'override',
+                type: 'confirm',
+                message: `Do you wish to overrite it`,
+                default: false
+              }
+            ];
+
+            await inquirer.prompt(questions).then(async answers => {
+              overrideExisting = answers.override;
+              });
+        }
+
+
+
+        if (libVersionExists) {
+          if (overrideExisting) {
+            console.log("\nDeleting existing library " + chalk.bold.yellow(`${libraryName}:${version}`) + " ...");
+            await deleteLibVersion(libraryName, version, tokenAndStaticServer.C11NB2S, tokenAndStaticServer.appStaticContentServer);
+
+            checkDeleted = true;
+          }
+          else {
+            // don't override, so end
+            console.log(chalk.yellow(`You will need to increment your library version to publish`));
+            return;
+          }
+        }
+
+        // need a timeout to give services time to delete the library
+        setTimeout( function(){ publishNewLibraryAsync(libraryName, version, checkDeleted)}, 700 );
+
+
+      }
+
+
+
+    }
+    else {
+      console.log(chalk.bold.redBright(`No library versions in ${libraryName}`));
+    }
+
+  }
+
+  return true;
+};