@pega/custom-dx-components 0.25.60 → 0.25.62

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pega/custom-dx-components",
-  "version": "0.25.60",
+  "version": "0.25.62",
   "description": "Utility for building custom UI components",
   "bin": "./bin/index.js",
   "keywords": [

package/src/cli.js

@@ -19,6 +19,7 @@ import {
   deleteVersion,
   importArchive,
   exportArchive,
+  exportRC,
   importComponent,
   initProject,
   listComponents,
@@ -84,6 +85,7 @@ const TASKS = {
   DELETE_VERSION: 'deleteVersion',
   IMPORT_ARCHIVE: 'importArchive',
   EXPORT_ARCHIVE: 'exportArchive',
+  EXPORT_RC: 'exportRC',
   IMPORT_COMP: 'importComponent',
   AUTHENTICATE: 'authenticate',
   UPGRADE: 'upgrade',
@@ -234,6 +236,10 @@ export default async (args = []) => {
       exportArchive(options);
       break;
     }
+    case TASKS.EXPORT_RC: {
+      exportRC(options);
+      break;
+    }
     case TASKS.IMPORT_COMP: {
       importComponent(options);
       break;

package/src/tasks/export-archive/helper.js

@@ -162,7 +162,7 @@ export const updateSavedExportFilePath = async(filePath) => {
       let relativePath = "";
       if (filePath !== defaultPath) {
         // same starting path, so we can save the relative
-        relativePath = filePath.replace(defaultPath.concat("/"), "");
+        relativePath = filePath.replace(defaultPath.concat(path.sep), "");
       }
 
       await setConfigExportRelativePath(relativePath);

package/src/tasks/export-rc/helper.js

@@ -0,0 +1,356 @@
+import chalk from 'chalk';
+import path from 'path';
+import { join } from 'path';
+import fetch from 'node-fetch';
+import archiver from 'archiver';
+import fs from 'fs';
+import {
+  addDebugLog,
+  getConfigDefaults,
+  getLibraryArchiveDirectories,
+  getLibraryArchivesVersions,
+  setConfigExportRelativePath,
+  getComponentDirectoryPath,
+  getPegaServerConfig,
+  forceDefaultsUpdate } from '../../util.js';
+
+
+
+export const SOURCE_OF_COMPONENT_TYPES = {
+  SERVER: 'Server',
+  LOCAL: 'Local'
+};
+
+
+export const getFilePathQuestions = async () => {
+addDebugLog("getFilePathQuestions", "", "");
+
+  console.log("\nFile path examples:");
+  if (path.sep === "/") {
+    console.log("\tMac OS/Unix:\t/Users/name/...");
+  }
+  else {
+    console.log("\tWindows:\tC:\\Users\\name\\...\n");
+  }
+
+  const configDef = getConfigDefaults();
+
+  const currentDirectory = process.cwd();
+  const arPathParts = currentDirectory.split(path.sep);
+  let defaultPath = join(arPathParts[0], arPathParts[1], arPathParts[2], configDef.exportRelativePath);
+  let startDirectory = join(arPathParts[0], arPathParts[1], arPathParts[2]);
+
+  if (path.sep === "/") {
+    defaultPath = "/".concat(defaultPath);
+    startDirectory = "/".concat(startDirectory).concat("/");
+  }
+
+  return [
+    {
+      name: 'filePath',
+      type: 'fuzzypath',
+      message: 'Enter full file path of directory to export zip file:',
+      default: defaultPath,
+      excludePath: nodePath => nodePath.startsWith('node_modules'),
+        // excludePath :: (String) -> Bool
+        // excludePath to exclude some paths from the file-system scan
+      excludeFilter: nodePath => nodePath.indexOf('/.') >= 0,
+        // excludeFilter :: (String) -> Bool
+        // excludeFilter to exclude some paths from the final list, e.g. '.'
+      itemType: 'directory',
+        // itemType :: 'any' | 'directory' | 'file'
+        // specify the type of nodes to display
+        // default value: 'any'
+        // example: itemType: 'file' - hides directories from the item list
+      rootPath: startDirectory,
+        // rootPath :: String
+        // Root search directory
+      suggestOnly: true,
+        // suggestOnly :: Bool
+        // Restrict prompt answer to available choices or use them as suggestions
+      depthLimit: 2,
+        // depthLimit :: integer >= 0
+        // Limit the depth of sub-folders to scan
+        // Defaults to infinite depth if undefined
+    }
+  ];
+};
+
+export const getFileNameQuestions = async (zipFileList) => {
+addDebugLog("getFileNameQuestions", "", "");
+
+  return [
+    {
+      name: 'fileName',
+      type: 'rawlist',
+      message: `Select zip file`,
+      choices: zipFileList
+    },
+  ];
+};
+
+export const getLibraryQuestion = async () => {
+addDebugLog("getLibraryQuestion", "", "");
+  const componentDefaults = getConfigDefaults();
+  const orgLib = getConfigDefaults();
+  const currentOrgLib = `${orgLib.organization}_${orgLib.library}`;
+
+  const archVersionList = await getLibraryArchiveDirectories("");
+
+
+  return [
+    {
+      name: 'orgLibName',
+      type: 'rawlist',
+      message: `Select a library (current library is ${chalk.bold.green(`${currentOrgLib}`)}) `,
+      choices: archVersionList
+    }
+  ];
+};
+
+export const getLibraryVersionQuestion = async (newOrgLib) => {
+addDebugLog("getLibraryVersionQuestion", "", "");
+
+  const archVersionList = await getLibraryArchivesVersions(newOrgLib, "0.0.0");
+
+  return [
+    {
+      name: 'selectedVersion',
+      type: 'rawlist',
+      message: `Select a version  `,
+      choices: archVersionList
+    }
+  ];
+};
+
+export const getServerOrDirectoryQuestion = async () => {
+addDebugLog("getLibraryVersionQuestion", "", "");
+
+    return [
+    {
+      name: 'exportTo',
+      type: 'rawlist',
+      message: `Export to`,
+      choices:  [{name: 'Local directory', value: 'Directory'}, {name: 'Server', value: 'Server'}],
+      default: 'Directory'
+    }
+  ];
+};
+
+export const getFullArchiveQuestions = async () => {
+
+  return [
+    {
+      name: 'fullArchive',
+      type: 'rawlist',
+      message: 'Type of export',
+      choices: [{name: 'Full Archive (code)', value: 'Full'}, {name: 'CL Binary (runtime only)', value: 'Binary'}],
+      default: 'Full'
+    }
+
+  ];
+}
+
+export const getComponentInfoQuestions = async (rPackageJSON, library) => {
+
+  return [
+    {
+      name: 'author',
+      message: 'Author of this component',
+      default: rPackageJSON.author
+    },
+    {
+      name: 'isLocalized',
+      type: 'confirm',
+      message: 'Is this component fully localized',
+      default: false
+    },
+    {
+      name: 'isAccessible',
+      type: 'confirm',
+      message: 'Is this component accessible',
+      default: false
+    },
+    {
+      name: 'isSecure',
+      type: 'confirm',
+      message: 'Is this component and dependent modules secure',
+      default: false
+    },
+    {
+      name: 'license',
+      message: 'License of this component (MIT, Apache, GPL, etc.)',
+      default: rPackageJSON.license
+    },
+    {
+      name: 'organization',
+      message: 'Organization name',
+      default: rPackageJSON.organization
+    },
+    {
+      name: 'library',
+      message: 'Library name',
+      default: library
+    }
+  ];
+}
+
+export const zipComponent = async componentKey => {
+addDebugLog("zipComponent", `componentKey: ${componentKey}`, "");
+  const srcDirectory = await getComponentDirectoryPath(componentKey);
+  const buildDirectory = await path.join(path.resolve(), 'dist/components', componentKey);
+  const configJson = `${srcDirectory}/config.json`;
+  const localizationJson = `${srcDirectory}/localizations.json`;
+
+  const archive = archiver('zip', { zlib: { level: 9 } });
+  const zipChunks = [];
+  archive.on('data', chunk => zipChunks.push(chunk));
+
+  // Add src directory
+  archive.directory(srcDirectory, 'src');
+
+  // Add config.json file
+  if (fs.existsSync(configJson)) {
+    archive.file(configJson, { name: path.basename(configJson) });
+  }
+
+  let lJson = "";
+
+  // Add localizations.json file if it exists
+  if (fs.existsSync(localizationJson)) {
+    archive.file(localizationJson, { name: path.basename(localizationJson) });
+    lJson = JSON.parse(Buffer.from(fs.readFileSync((localizationJson))).toString());
+  }
+
+  // Add build directory
+  archive.directory(buildDirectory, false);
+
+  await archive.finalize();
+
+  const zipBuffer = Buffer.concat(zipChunks);
+  console.log(chalk.green(`component zipped with size: ${Math.ceil(zipBuffer.length / 1024)} KB`));
+  const zipContent = zipBuffer.toString('base64');
+
+  //let configContent = Buffer.from(fs.readFileSync(configJson)).toString();
+  const configContent = JSON.parse(Buffer.from(fs.readFileSync(configJson)).toString());
+  // configContent = configContent.replaceAll("\n", "");
+
+  let output = { configContent };
+  if (lJson != "") {
+    output = { ...output, localizationJson: lJson};
+  }
+
+  if (fs.existsSync('dist')) {
+    fs.rm('dist', { recursive: true }, err => {
+      if (err) {
+        throw err;
+      }
+    });
+  }
+
+
+  return { zipContent, ...output};
+};
+
+export const zipRC = async (content, archiveDirectory, archiveFileName) => {
+addDebugLog("zipRC", ``, "");
+
+
+
+  // const configContent = Buffer.from(fs.readFileSync(configJson)).toString();
+  // const mainDirectory = process.cwd();
+  // const archiveDirectory = join (mainDirectory, ARCHIVES_PATH, `${componentKey}`, `${version}`);
+
+
+  if (!fs.existsSync(archiveDirectory)) {
+    fs.mkdirSync(archiveDirectory, { recursive: true });
+  }
+
+  const archiveFile = join(archiveDirectory, archiveFileName);
+
+  const output = fs.createWriteStream(archiveFile);
+  const archive = archiver('zip', {
+    zlib: { level: 9 } // Sets the compression level.
+  });
+
+  const zipChunks = [];
+  archive.on('data', chunk => zipChunks.push(chunk));
+
+
+  archive.append( JSON.stringify(content),  { name: 'componentData.json' });
+
+  // pipe archive data to the file
+  archive.pipe(output);
+
+  output.on('end', function() {
+    console.log('Data has been drained');
+  });
+
+
+  // good practice to catch warnings (ie stat failures and other non-blocking errors)
+  archive.on('warning', function(err) {
+    if (err.code === 'ENOENT') {
+      // log warning
+    } else {
+      // throw error
+      throw err;
+    }
+  });
+
+  // good practice to catch this error explicitly
+  archive.on('error', function(err) {
+    throw err;
+  });
+
+  await archive.finalize();
+
+  return output;
+
+};
+
+
+
+export const updateSavedExportFilePath = async(filePath) => {
+  const currentDirectory = process.cwd();
+  const arPathParts = currentDirectory.split(path.sep);
+  const configDef = getConfigDefaults();
+
+  let defaultPath = join(path.sep, arPathParts[0], arPathParts[1], arPathParts[2]);
+
+  if (path.sep != "/") {
+    // windows
+    if (defaultPath.indexOf(path.sep) === 0) {
+      // if start with \\, then remove
+      defaultPath = defaultPath.substring(1);
+    }
+
+    if (filePath.indexOf(defaultPath) === 0) {
+      let relativePath = "";
+      if (filePath !== defaultPath) {
+        // same starting path, so we can save the relative
+        relativePath = filePath.replace(defaultPath.concat(path.sep), "");
+      }
+
+      await setConfigExportRelativePath(relativePath);
+      await forceDefaultsUpdate();
+
+    }
+  }
+  else {
+    // mac
+    if (filePath.indexOf(defaultPath) === 0) {
+
+      let relativePath = "";
+      if (filePath !== defaultPath) {
+        // same starting path, so we can save the relative
+        relativePath = filePath.replace(defaultPath.concat("/"), "");
+      }
+
+
+      await setConfigExportRelativePath(relativePath);
+      await forceDefaultsUpdate();
+
+    }
+  }
+
+}

package/src/tasks/export-rc/index.js

@@ -0,0 +1,268 @@
+import fs from 'fs';
+import { join } from 'path';
+
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { Listr } from 'listr2';
+
+import validate from '../validator/index.js';
+import bundleComponent from '../bundle/index.js';
+import { lintComponent } from '../linter/index.js';
+
+import {
+  checkPathAccess,
+  showVersion,
+  addDebugLog,
+  getComponents,
+  getConfigDefaults,
+  getPegaServerConfig,
+  getLibraryBased,
+  getComponentDirectoryPath,
+  getServerType
+ } from '../../util.js';
+import { TASKS_CONFIG_JSON_FILENAME, PACKAGE_JSON_FILENAME } from '../../constants.js';
+import { getFilePathQuestions, updateSavedExportFilePath, zipComponent, zipRC, getComponentInfoQuestions  } from './helper.js';
+
+
+import inquirerFuzzyPath from '@pega/inquirer-fuzzy-path';
+
+const currentDirectory = process.cwd();
+const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
+
+export default async options => {
+  await showVersion();
+
+  await checkPathAccess(pegaConfigJsonPath);
+
+  const isLibraryBasedCL = getLibraryBased();
+  if (isLibraryBasedCL) {
+    console.log(`Command only supported for ${chalk.bold.green('non library mode')} components.`)
+    process.exit();
+  }
+
+  const serverType = getServerType();
+  if (serverType != "launchpad") {
+    console.log(`Command only supported for ${chalk.green('Launchpad')}.`);
+    process.exit(1);
+  }
+
+
+  addDebugLog("export RC", "", "+");
+
+  let exportTo = "";
+
+  if (options.params.length >= 8) {
+
+    // params pick full, what library/name  and path
+    // vs no params then we will select the current library
+    // let fullArchive = options.params[3];
+    // const libraryName = options.params[4];
+    // const libraryVersion = options.params[5];
+    // const filePath = options.params[6];
+    // exportTo = "Directory";
+
+
+    // const currentOrArchive = options.params[7];
+
+    // await exportArch(filePath, libraryName, libraryVersion, fullArchive, currentOrArchive );
+
+  }
+  else {
+    let orgLibName = "";
+    let selectedVersion = "";
+    let fullArchive = "";
+
+
+    // if (options.params.length >= 5) {
+    //   fullArchive = options.params[3];
+    //   orgLibName = options.params[4];
+    //   if (options.params.length >= 6) {
+    //     selectedVersion = options.params[5];
+    //   }
+    // }
+
+    // disable question to build "CL"
+    // if (fullArchive === "" ) {
+    //   const fullArchiveQuestions = await getFullArchiveQuestions();
+    //   const fullArchiveAnswers = await inquirer.prompt(fullArchiveQuestions);
+    //   ({ fullArchive } = fullArchiveAnswers);
+    // }
+
+    // force full archive, binary deprecated
+    fullArchive = "Full";
+
+    let filePathQuestions;
+    let filePathAnswers;
+    let filePath;
+    let content;
+
+    const localComponents = await getComponents();
+    const defaultPegaConfig = await getPegaServerConfig();
+    const configDef = getConfigDefaults();
+
+
+    if (localComponents.length > 0) {
+
+      const compAnswers = await inquirer.prompt([
+        {
+          name: 'componentKey',
+          type: 'rawlist',
+          message: 'Select component to export as a runtime component',
+          choices: localComponents
+        },
+        {
+          name: 'devBuild',
+          type: 'confirm',
+          message: 'Generate development build ?',
+          default: defaultPegaConfig.devBuild
+        }
+      ]);
+
+      content = {
+        ...compAnswers
+      };
+
+
+      inquirer.registerPrompt('fuzzypath', inquirerFuzzyPath);
+      const filePathQuestions = await getFilePathQuestions();
+      const filePathAnswers = await inquirer.prompt(filePathQuestions);
+      const exportPath = filePathAnswers.filePath;
+      const componentKey = compAnswers.componentKey;
+      const devBuild = compAnswers.devBuild;
+
+
+
+      if (!fs.existsSync(exportPath)) {
+        console.log(`\Path: ${chalk.yellow(`${exportPath}`)} doesn't exist.`);
+        const newPathAnswer = await inquirer.prompt([
+          {
+            name: 'createNewPath',
+            type: 'confirm',
+            message: 'Create path',
+            default: true
+          },
+        ]);
+        const createNewPath = newPathAnswer.createNewPath;
+        if (createNewPath) {
+          fs.mkdirSync(exportPath, { recursive: true });
+
+          await updateSavedExportFilePath(exportPath);
+        }
+        else {
+          console.log(chalk.green("Store not exported."));
+          process.exit();
+        }
+      }
+
+      const archiveFileName = `${componentKey}_${configDef.version}.RC.zip`;
+
+      if (fs.existsSync(join(exportPath, archiveFileName))) {
+        console.log(`\nFile: ${chalk.yellow(`${archiveFileName}`)} already exists in ${chalk.yellow(`${exportPath}`)}.`);
+        const overwriteQuestion = await inquirer.prompt([
+          {
+            name: 'overWriteFile',
+            type: 'confirm',
+            message: 'Overwrite',
+            default: true
+          },
+        ]);
+
+        if (!overwriteQuestion.overWriteFile) {
+          console.log(chalk.green("Archive not created."));
+          process.exit();
+        }
+      }
+
+      console.log(chalk.yellow(`\n>> You are about to create a zip file containing an independent component `));
+      console.log(chalk.yellow(`>> that others can import directly into Launchpad.`));
+      console.log(chalk.yellow(`>> You will be asked a series of questions for the benefit of others`));
+      console.log(chalk.yellow(`>> who might choose to use your component.`));
+      console.log(chalk.yellow(`\n>> These answers will be recorded in a json file within the zip file.`));
+      console.log(chalk.yellow(`>> These questions will NOT be used as a gate to prevent the creation of this component.\n`));
+
+
+      const currentDirectory = process.cwd();
+      const packagePath = join (currentDirectory, PACKAGE_JSON_FILENAME);
+      let retrievedPackageData;
+
+      try {
+        retrievedPackageData = fs.readFileSync(packagePath);
+      }
+      catch (ex) {
+        console.log(chalk.red(`\nUnable to retrieve package.json.`))
+        process.exit(1);
+      }
+
+      const rPackage = JSON.parse(retrievedPackageData);
+
+
+      const componentInfoQuestions = await getComponentInfoQuestions(rPackage, configDef.library);
+      let componentInfo = await inquirer.prompt(componentInfoQuestions);
+
+      const currentDate = new Date(Date.now());
+      const dateStamp = currentDate.toString();
+      const timeStamp = currentDate.toJSON();
+
+      componentInfo = { ...componentInfo, dependencies: rPackage.dependencies, buildDate: dateStamp, timeStamp  };
+
+      console.log("\nBuilding RC...");
+
+      const sDevBuild = devBuild ? '(dev build)' : '';
+      const tasks = 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);
+            }
+          },
+          {
+            title: `Bundle Component ${sDevBuild}`,
+            task: async () => bundleComponent(componentKey, defaultPegaConfig.sourceMap, devBuild),
+            skip: () => (options.skipBundle ? 'Skipped bundling component' : undefined)
+          },
+          {
+            title: 'Create internal zip of component',
+            task: async () => {
+              const output = await zipComponent(componentKey);
+              content = { ...content, ...output, componentInfo: componentInfo };
+            }
+          },
+          {
+            title: 'Create zip file',
+            task: async () => {
+              const output = await zipRC(content, exportPath, archiveFileName);
+              content = { ...content, ...output };
+            }
+          }
+        ],
+        {
+          exitOnError: true
+        }
+      );
+
+      await tasks.run().catch(err => {
+        console.log(chalk.bold.red(err.toString()));
+        process.exit(1);
+      });
+
+      console.log(`\nRuntime component ${chalk.green(`${archiveFileName}`)} has been created in ${chalk.green(`${exportPath}`)}.\n`);
+
+    }
+    else {
+      console.log(chalk.bold.red(`\nNo components to export.\n`));
+    }
+
+  }
+
+addDebugLog("export RC", "END", "-");
+
+};

package/src/tasks/import-archive/helper.js

@@ -350,7 +350,7 @@ export const updateSavedFilePath = async(filePath) => {
       let relativePath = "";
       if (filePath !== defaultPath) {
         // same starting path, so we can save the relative
-        relativePath = filePath.replace(defaultPath.concat("/"), "");
+        relativePath = filePath.replace(defaultPath.concat(path.sep), "");
       }
 
       await setConfigImportRelativePath(relativePath);

package/src/tasks/import-comp/helper.js

@@ -30,7 +30,7 @@ addDebugLog("getFilePathQuestions", "", "");
     {
       name: 'filePath',
       type: 'fuzzypath',
-      message: 'Enter full file path of zip file location:',
+      message: 'Enter full path of the component folder',
       default: defaultPath,
       excludePath: nodePath => nodePath.startsWith('node_modules'),
         // excludePath :: (String) -> Bool

package/src/tasks/index.js

@@ -28,6 +28,7 @@ export { default as setPermanent } from './set-perm/index.js';
 export { default as storeComponents } from './store/index.js';
 export { default as importArchive } from './import-archive/index.js';
 export { default as exportArchive } from './export-archive/index.js';
+export { default as exportRC } from './export-rc/index.js';
 export { default as importComponent } from './import-comp/index.js';
 export { default as updateComponent } from './update/index.js';
 export { default as validate } from './validator/index.js';

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

@@ -25,6 +25,7 @@
     "delete": "custom-dx-components delete",
     "deleteAll": "custom-dx-components deleteAll",
     "importComponent": "custom-dx-components importComponent",
+    "exportRC" : "custom-dx-components exportRC",
     "help": "custom-dx-components showHelp",
     "publish": "custom-dx-components publish",
     "_***Component_mode_only***": "Component only commands",
@@ -107,7 +108,7 @@
     "@babel/preset-react": "^7.27.1",
     "@babel/preset-typescript": "^7.27.1",
     "@pega/configs": "^0.16.3",
-    "@pega/custom-dx-components": "~0.25.60",
+    "@pega/custom-dx-components": "~0.25.62",
     "@pega/pcore-pconnect-typedefs": "^4.1.0",
     "@storybook/addon-actions": "^8.6.14",
     "@storybook/addon-essentials": "^8.6.14",

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

@@ -54,7 +54,7 @@ export default async (options) => {
   }
 
   await showVersion();
-  await checkLibraryAndArchives();
+  await checkLibraryAndArchives(false);
 addDebugLog("listPublished", "", "+");
   await cleanUpTemp();
 

package/src/util.js

@@ -47,7 +47,6 @@ import {
 } from './constants.js';
 
 
-
 const access = promisify(fs.access);
 
 let showDebug = false;
@@ -2651,10 +2650,14 @@ if (showDebug) addDebugLog("deleteArchives", ``, "");
   }
 }
 
-export const checkLibraryAndArchives = async () => {
+export const checkLibraryAndArchives = async (checkArch = true) => {
 if (showDebug) addDebugLog("checkLibraryAndArchives", ``, "");
   const isLibraryBased =  getLibraryBased();
-  const hasArch = await hasArchives();
+  let hasArch  = true;
+  if (checkArch) {
+    hasArch = await hasArchives();
+
+  }
 
   if (isLibraryBased && !hasArch) {
     console.log(chalk.yellow('\nPlease create/import a library before proceeding.'));