@pega/custom-dx-components 0.26.3 → 0.26.5

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/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/eslint.config.mjs

@@ -1,8 +1,6 @@
 import { globalIgnores } from 'eslint/config';
-import path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import js from '@eslint/js';
-import { FlatCompat } from '@eslint/eslintrc';
+import eslint from '@eslint/js';
 import tseslint from 'typescript-eslint';
 import sonarjs from 'eslint-plugin-sonarjs';
 import importPlugin from 'eslint-plugin-import';
@@ -12,20 +10,10 @@ import reactHooks from 'eslint-plugin-react-hooks';
 import { defineConfig } from 'eslint/config';
 
 const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-const compat = new FlatCompat({
-  baseDirectory: __dirname,
-  recommendedConfig: js.configs.recommended,
-  sonarjs: sonarjs.configs.recommended,
-  importPlugin: importPlugin.configs.recommended,
-  react: react.configs.recommended,
-  reactHooks: reactHooks.configs.recommended,
-  allConfig: js.configs.all
-});
 
 export default defineConfig([
-  tseslint.configs.recommended,
+  eslint.configs.recommended,
+  ...tseslint.configs.recommended,
   globalIgnores([
     '**/node_modules',
     'packages/*/lib',

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

@@ -107,7 +107,7 @@
     "@babel/preset-react": "^7.27.1",
     "@babel/preset-typescript": "^7.27.1",
     "@pega/configs": "^0.16.3",
-    "@pega/custom-dx-components": "~0.26.3",
+    "@pega/custom-dx-components": "~0.26.5",
     "@pega/pcore-pconnect-typedefs": "^4.1.0",
     "@storybook/addon-docs": "^9.1.7",
     "@storybook/addon-essentials": "^9.0.0-alpha.12",
@@ -130,7 +130,8 @@
     "@types/react-color": "^3.0.13",
     "@types/react-dom": "^18.3.7",
     "@types/styled-components": "^5.1.34",
-    "@typescript-eslint/eslint-plugin": "^5.62.0",
+    "@typescript-eslint/eslint-plugin": "^8.44.1",
+    "@typescript-eslint/parser": "^8.44.1",
     "core-js": "^3.42.0",
     "eslint": "^9.27.0",
     "eslint-plugin-import": "^2.31.0",
@@ -155,7 +156,7 @@
     "stylelint": "^16.19.1",
     "ts-jest": "^29.3.2",
     "typescript": "~5.5.4",
-    "typescript-eslint": "^8.32.1",
+    "typescript-eslint": "^8.44.1",
     "vite": "^6.3.5"
   }
 }