@pega/custom-dx-components 0.242.28 → 0.242.29

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

@@ -0,0 +1,224 @@
+import fs from 'fs';
+import { promisify } from 'util';
+import { join } from 'path';
+
+import inquirer from 'inquirer';
+import ncp from 'ncp';
+import chalk from 'chalk';
+
+import {
+  checkPathAccess,
+  showVersion,
+  addDebugLog,
+  checkLibraryAndArchives,
+  getConfigDefaults,
+  getLibraryBased,
+  zipVersionAndArchive
+ } from '../../util.js';
+import { TASKS_CONFIG_JSON_FILENAME, COMPONENTS_DIRECTORY_PATH, COMPONENTS_PATH, ARCHIVES_PATH, TEMP_PATH } from '../../constants.js';
+import { getFilePathQuestions, getFileNameQuestions, getLibraryQuestion, getLibraryVersionQuestion  } from './helper.js';
+
+export const DXCB_CONFIG_INTERNAL_JSON_FILENAME = 'src/dxcb.config.json';
+const currentDirectory = process.cwd();
+const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
+
+
+const copy = promisify(ncp);
+
+export const updateConfig = async (
+  {
+    oldComponentKey,
+    newComponentKey,
+    library,
+    version,
+    targetDirectory,
+  },
+  options,
+  onlyCompanion = false
+) => {
+
+addDebugLog("updateConfig", `oldComponentKey: ${oldComponentKey}, newComponentKey: ${newComponentKey}`, "");
+
+  let configData = fs.readFileSync(join(targetDirectory, "/config.json"), { encoding: 'utf8' });
+  configData = configData && JSON.parse(configData);
+
+  configData.name = newComponentKey;
+  if (configData.componentKey) configData.componentKey = newComponentKey;
+  configData.library = library;
+  configData.version = version;
+
+  // stringify "4", makes the json string look like JSON in the file, formated instead of a single line
+  fs.writeFileSync(join(targetDirectory, "/config.json"), JSON.stringify(configData, null, 4), { encoding: 'utf8' });
+
+};
+
+export const updateFile = async (
+    fileName,
+    oldComponentKeyPC,
+    newComponentKeyPC,
+    targetDirectory,
+) => {
+
+addDebugLog("updateFile", `fileName: ${fileName}, oldComponentKeyPC: ${oldComponentKeyPC}, newComponentKeyPC: ${newComponentKeyPC}, targetDirectory: ${targetDirectory}`, "");
+
+  let fileData = fs.readFileSync(join(targetDirectory, "/", fileName), { encoding: 'utf8' });
+
+  if (fileData.indexOf(oldComponentKeyPC) >= 0) {
+    fileData = fileData.replaceAll(oldComponentKeyPC, newComponentKeyPC);
+
+    fs.writeFileSync(join(targetDirectory, "/", fileName), fileData, { encoding: 'utf8' });
+  }
+
+};
+
+
+
+
+export const exportArch = async(exportPath, orgLibName, selectedVersion) => {
+addDebugLog("exportArch", `exportPath: ${exportPath}, orgLibName: ${orgLibName}, selectedVersion: ${selectedVersion}`, "");
+  const currentDirectory = process.cwd();
+  const archiveDirectory = join (currentDirectory, ARCHIVES_PATH, `${orgLibName}`, `${selectedVersion}`);
+  const fileName = `${orgLibName}_${selectedVersion}.zip`;
+  const archFileName = join(archiveDirectory, fileName);
+  const configDef = await getConfigDefaults();
+
+  const exportFile = join(exportPath, fileName);
+
+
+  if (orgLibName === configDef.currentOrgLib && selectedVersion === configDef.buildVersion) {
+
+    console.log("\nYou've selected the current working library/version.");
+    console.log("You export store or the current.");
+    const archAnswers = await inquirer.prompt([
+      {
+        name: 'currentOrStore',
+        type: 'rawlist',
+        message: 'Select current or store',
+        default: "Current",
+        choices: ["Current", "Store"]
+      },
+    ]);
+
+    const currentOrStore = archAnswers.currentOrStore;
+    if (currentOrStore === "Current") {
+      // archive it
+      await zipVersionAndArchive(configDef.currentOrgLib, configDef.buildVersion);
+    }
+  }
+
+  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 });
+    }
+    else {
+      console.log(chalk.green("Store not exported."));
+      process.exit();
+    }
+  }
+
+  if (fs.existsSync(exportFile)) {
+    console.log(`\nFile: ${chalk.green(`${exportFile}`)} already exists.`);
+    const overrideAnswer = await inquirer.prompt([
+      {
+        name: 'overrideExisting',
+        type: 'confirm',
+        message: 'Override existing',
+        default: false
+      },
+    ]);
+
+    const overrideExisting = overrideAnswer.overrideExisting;
+    if (!overrideExisting) {
+      console.log(chalk.green("Store not exported."));
+      process.exit();
+    }
+  }
+
+
+  fs.copyFileSync(archFileName, exportFile );
+
+  console.log(`\n${chalk.green(`${fileName}`)} has been exported to ${chalk.green(`${exportPath}`)}`);
+
+}
+
+export const convertPath = (filePath) => {
+
+  if (filePath.indexOf(":") > 0) {
+    const arFileData = filePath.split("\\");
+    filePath = join(arFileData);
+  }
+
+  return filePath;
+}
+
+export const getZipFileList = async(filePath) => {
+
+  const zipFilePath = convertPath(filePath);
+  if (fs.existsSync(zipFilePath)) {
+    return fs
+      .readdirSync(zipFilePath, { withFileTypes: true })
+      .filter(dirent => !dirent.isDirectory() && dirent.name.match(/.*\.(zip?)/ig))
+      .map(dirent => dirent.name);
+  }
+  else {
+    console.log(chalk.red.bold(`File path: ${filePath} does not exist or no permissions.`));
+    process.exit(1);
+  }
+}
+
+export default async options => {
+  await showVersion();
+  await checkLibraryAndArchives();
+
+  await checkPathAccess(pegaConfigJsonPath);
+  const isLibraryBased = getLibraryBased();
+  if (!isLibraryBased) {
+    console.log(`Command only supported for ${chalk.bold.green('library mode')} components.`)
+    process.exit();
+  }
+
+  addDebugLog("exportArchive", "", "+");
+
+
+  if (options.params.length >= 6) {
+    const filePath = convertPath(options.params[3]);
+    const libraryName = options.params[4];
+    const libraryVersion = options.params[5];
+
+    await exportArch(filePath, libraryName, libraryVersion );
+
+  }
+  else {
+
+    const libraryQuestion = await getLibraryQuestion();
+    const libraryAnswers = await inquirer.prompt(libraryQuestion);
+    const { orgLibName } = libraryAnswers;
+
+    const libraryVersionQuestion = await getLibraryVersionQuestion(orgLibName);
+    const libraryVersionAnswer = await inquirer.prompt(libraryVersionQuestion);
+    const { selectedVersion } = libraryVersionAnswer;
+
+    const filePathQuestions = await getFilePathQuestions();
+    const filePathAnswers = await inquirer.prompt(filePathQuestions);
+    const { filePath } = filePathAnswers;
+
+    const zipFilePath = convertPath(filePath);
+
+
+    await exportArch( zipFilePath, orgLibName, selectedVersion);
+
+  }
+
+addDebugLog("exportArchive", "END", "-");
+
+};

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

@@ -0,0 +1,51 @@
+import chalk from 'chalk';
+import path from 'path';
+import { join } from 'path';
+import { addDebugLog, getConfigDefaults, getLibraryArchiveDirectories, getLibraryBased } 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/...\n");
+  }
+  else {
+    console.log("\tWindows:\tC:\\Users\\name\\...\n");
+  }
+
+  const currentDirectory = process.cwd();
+  const arPathParts = currentDirectory.split(path.sep);
+  let defaultPath = join(arPathParts[0], arPathParts[1], arPathParts[2], "Downloads");
+  if (path.sep === "/") {
+    defaultPath = "/".concat(defaultPath);
+  }
+
+
+  return [
+    {
+      name: 'filePath',
+      message: 'Enter full file path of zip file location:',
+      default: defaultPath
+    }
+  ];
+};
+
+export const getFileNameQuestions = async (zipFileList) => {
+addDebugLog("getFileNameQuestions", "", "");
+
+  return [
+    {
+      name: 'fileName',
+      type: 'rawlist',
+      message: `Select zip file`,
+      choices: zipFileList
+    },
+  ];
+};

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

@@ -0,0 +1,301 @@
+import fs from 'fs';
+import { promisify } from 'util';
+import { join } from 'path';
+
+import inquirer from 'inquirer';
+import ncp from 'ncp';
+import chalk from 'chalk';
+
+import {
+  checkPathAccess,
+  showVersion,
+  getComponentsObj,
+  getDirectoryFiles,
+  addDebugLog,
+  checkLibraryAndArchives,
+  getConfigDefaults,
+  getLibraryBased,
+  unZipFromArchive,
+  zipVersionAndArchive,
+  getLibraryArchivesVersions
+ } from '../../util.js';
+import { TASKS_CONFIG_JSON_FILENAME, COMPONENTS_DIRECTORY_PATH, COMPONENTS_PATH, ARCHIVES_PATH, TEMP_PATH } from '../../constants.js';
+import { getFilePathQuestions, getFileNameQuestions  } from './helper.js';
+
+export const DXCB_CONFIG_INTERNAL_JSON_FILENAME = 'src/dxcb.config.json';
+const currentDirectory = process.cwd();
+const pegaConfigJsonPath = join(currentDirectory, TASKS_CONFIG_JSON_FILENAME);
+
+
+import {
+  convertIntoPascalCase,
+  getComponentDirectoryPath
+} from '../../util.js';
+
+
+const copy = promisify(ncp);
+
+
+export const updateConfig = async (
+  {
+    oldComponentKey,
+    newComponentKey,
+    library,
+    version,
+    targetDirectory,
+  },
+  options,
+  onlyCompanion = false
+) => {
+
+addDebugLog("updateConfig", `oldComponentKey: ${oldComponentKey}, newComponentKey: ${newComponentKey}`, "");
+
+  let configData = fs.readFileSync(join(targetDirectory, "/config.json"), { encoding: 'utf8' });
+  configData = configData && JSON.parse(configData);
+
+  configData.name = newComponentKey;
+  if (configData.componentKey) configData.componentKey = newComponentKey;
+  configData.library = library;
+  configData.version = version;
+
+  // stringify "4", makes the json string look like JSON in the file, formated instead of a single line
+  fs.writeFileSync(join(targetDirectory, "/config.json"), JSON.stringify(configData, null, 4), { encoding: 'utf8' });
+
+};
+
+export const updateFile = async (
+    fileName,
+    oldComponentKeyPC,
+    newComponentKeyPC,
+    targetDirectory,
+) => {
+
+addDebugLog("updateFile", `fileName: ${fileName}, oldComponentKeyPC: ${oldComponentKeyPC}, newComponentKeyPC: ${newComponentKeyPC}, targetDirectory: ${targetDirectory}`, "");
+
+  let fileData = fs.readFileSync(join(targetDirectory, "/", fileName), { encoding: 'utf8' });
+
+  if (fileData.indexOf(oldComponentKeyPC) >= 0) {
+    fileData = fileData.replaceAll(oldComponentKeyPC, newComponentKeyPC);
+
+    fs.writeFileSync(join(targetDirectory, "/", fileName), fileData, { encoding: 'utf8' });
+  }
+
+};
+
+
+// rename the component
+export const renameComponent = async (
+    componentKey,
+    library,
+    version,
+    options
+) => {
+
+addDebugLog("renameComponent", `library: ${library}, componentKey: ${componentKey}`, "");
+
+
+  const componentName = componentKey.split("_")[2];
+
+  const configDef = getConfigDefaults();
+
+  const newComponentKey = `${library}_${componentName}`;
+
+  const oldComponentKey = componentKey;
+  const newComponentKeyPC = convertIntoPascalCase(newComponentKey);
+  const oldComponentKeyPC = convertIntoPascalCase(oldComponentKey);
+
+  const currentDirectory = await getComponentDirectoryPath(componentKey);
+  const targetDirectory = await getComponentDirectoryPath(newComponentKey);
+
+  // custom component
+  try {
+    fs.renameSync(currentDirectory, targetDirectory);
+  } catch(err) {
+    console.log(err)
+  }
+
+  const targetFileList = await getDirectoryFiles(targetDirectory);
+
+  for (var fileIndex in targetFileList) {
+    const fileName = targetFileList[fileIndex];
+
+    if (fileName === "config.json") {
+      await updateConfig(
+        {
+          oldComponentKey,
+          newComponentKey,
+          componentName,
+          library,
+          version,
+          targetDirectory,
+        },
+        options
+      );
+    }
+    else {
+      await updateFile(
+          fileName,
+          oldComponentKeyPC,
+          newComponentKeyPC,
+          targetDirectory );
+
+    }
+
+  } // for
+
+
+  return newComponentKey;
+
+};
+
+
+export const moveComp = async(componentKey, orgLibName, version, copyShared, options) => {
+
+    // put lib/version into temp directory
+    const currentDirectory = process.cwd();
+    const tempDirectory = join(currentDirectory, TEMP_PATH);
+    const archiveDirectory = join (currentDirectory, ARCHIVES_PATH, `${orgLibName}`, `${version}`);
+    const fileName = `${orgLibName}_${version}.zip`;
+    const archFileName = join(archiveDirectory, fileName);
+
+
+    await unZipFromArchive(archFileName);
+
+    // rename the component
+    const newComponentKey = await renameComponent(componentKey, orgLibName, version);
+    const currentCompPath = join(currentDirectory, "src", "components");
+    const tempCompPath = join(tempDirectory, "src", "components");
+
+    const currentComponentsPath = join(currentCompPath, `${newComponentKey}`);
+    const tempDirectoryComponents = join(tempCompPath, `${newComponentKey}`);
+
+    const currentSharedPath = join(currentCompPath, "shared");
+    const targetSharedPatah = join(tempCompPath, "shared");
+
+    // copy component into temp directory
+    fs.cpSync(currentComponentsPath, tempDirectoryComponents, { recursive: true, force: true  });
+
+    // remove from components
+    fs.rmSync(currentComponentsPath, { recursive: true, force: true, maxRetries: 2  });
+
+    // copy shared
+    if (copyShared) {
+      fs.cpSync(currentSharedPath, targetSharedPatah, { recursive: true, force: true  });
+    }
+
+    console.log(`\nCopied ${chalk.green(`${componentKey}`)} to ${chalk.green(`${orgLibName}/${version}`)} as ${chalk.green(`${newComponentKey}`)}\n`);
+
+    // rearchive temp directory
+    await zipVersionAndArchive(orgLibName, version, tempDirectory);
+
+    // delete temp directory
+    fs.rmSync(tempDirectory, { recursive: true, force: true, maxRetries: 2  });
+}
+
+export const importArch = async(filePath, fileName) => {
+addDebugLog("importArch", `filePath: ${filePath}, fileName: ${fileName}`, "");
+
+  const currentDirectory = process.cwd();
+  const tempDirectory = join(currentDirectory, TEMP_PATH);
+  const zipFilePath = join(filePath, fileName);
+
+  await unZipFromArchive(zipFilePath);
+
+  // check to see if have a tasks.config.json file, if not, archive not good
+  const tempTasksConfig = join(tempDirectory, "tasks.config.json");
+  if (!fs.existsSync(tempTasksConfig)) {
+    console.log(chalk.red.bold(`Zip file: ${fileName} not a compatible DX Component archive.`));
+    console.log(chalk.red.bold("Cleaning up..."));
+    fs.rmSync(tempDirectory, { recursive: true, force: true, maxRetries: 5  });
+    console.log(chalk.red.bold("Done."));
+    process.exit(1);
+
+  }
+
+  const arFileData = fileName.split("_");
+  const orgLibName = `${arFileData[0]}_${arFileData[1]}`;
+  const version = arFileData[2].replace(".zip", "");
+
+  // rearchive temp directory
+  await zipVersionAndArchive(orgLibName, version, tempDirectory);
+
+  // delete temp directory
+  fs.rmSync(tempDirectory, { recursive: true, force: true, maxRetries: 2  });
+
+  console.log(`\n${chalk.green(`${fileName}`)} has been imported!`);
+  console.log(`You can switch to ${chalk.green(`${orgLibName}/${version}`)} via npm run switchLib.\n`);
+
+}
+
+export const convertPath = (filePath) => {
+
+  if (filePath.indexOf(":") > 0) {
+    const arFileData = filePath.split("\\");
+    filePath = join(arFileData);
+  }
+
+  return filePath;
+}
+
+export const getZipFileList = async(filePath) => {
+
+  const zipFilePath = convertPath(filePath);
+  if (fs.existsSync(zipFilePath)) {
+    return fs
+      .readdirSync(zipFilePath, { withFileTypes: true })
+      .filter(dirent => !dirent.isDirectory() && dirent.name.match(/.*\.(zip?)/ig))
+      .map(dirent => dirent.name);
+  }
+  else {
+    console.log(chalk.red.bold(`File path: ${filePath} does not exist or no permissions.`));
+    process.exit(1);
+  }
+}
+
+export default async options => {
+  await showVersion();
+  await checkLibraryAndArchives();
+
+  await checkPathAccess(pegaConfigJsonPath);
+  const isLibraryBased = getLibraryBased();
+  if (!isLibraryBased) {
+    console.log(`Command only supported for ${chalk.bold.green('library mode')} components.`)
+    process.exit();
+  }
+
+  addDebugLog("importArchive", "", "+");
+
+
+  if (options.params.length >= 5) {
+    const filePath = convertPath(options.params[3]);
+    const fileName = options.params[4];
+
+
+    await importArch( filePath, fileName);
+
+  }
+  else {
+
+    const filePathQuestions = await getFilePathQuestions();
+    const filePathAnswers = await inquirer.prompt(filePathQuestions);
+    const { filePath } = filePathAnswers;
+
+    const zipFilePath = convertPath(filePath);
+    const zipFileList = await getZipFileList(filePath);
+
+    if (!zipFileList || zipFileList.length === 0) {
+      console.log(chalk.red.bold(`No zip files exist at path: ${filePath}`));
+    }
+
+    const fileNameQuestions = await getFileNameQuestions(zipFileList);
+    const fileNameAnswers = await inquirer.prompt(fileNameQuestions);
+    const {fileName} = fileNameAnswers;
+
+
+    await importArch( filePath, fileName);
+
+  }
+
+addDebugLog("importArchive", "END", "-");
+
+};

package/src/tasks/index.js

@@ -8,11 +8,13 @@ export { default as deleteComponent } from './delete/index.js';
 export { default as deleteAllComponents } from './delete-all/index.js';
 export { default as deleteLibrary } from './delete-lib/index.js';
 export { default as deletePublished } from './delete-pub/index.js';
+export { default as deleteVersion } from './delete-version/index.js';
 export { default as initProject } from './init/index.js';
 export { default as promoteWebPack } from './promote-webpack/index.js';
 export { default as publishComponent } from './publish/index.js';
 export { default as publishAllComponents } from './publish-all/index.js';
 export { default as publishLibrary } from './publish-lib/index.js';
+export { default as moveComponent } from './move/index.js';
 export { default as renameComponent } from './rename/index.js';
 export { default as renameLibrary } from './rename-lib/index.js';
 export { default as revertWebPack } from './revert-webpack/index.js';
@@ -20,6 +22,9 @@ export { default as listComponents } from './list/index.js';
 export { default as listLibrary } from './list-lib/index.js';
 export { default as listPublished } from './list-pub/index.js';
 export { default as showStatus } from './show-status/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 updateComponent } from './update/index.js';
 export { default as validate } from './validator/index.js';
 export { default as authenticate } from './authenticate/index.js';

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

@@ -5,6 +5,7 @@
   "main": "src/index.js",
   "type": "module",
   "scripts": {
+    "_***Component_and_Library_mode***": "Component and library mode commands",
     "startStorybook": "storybook dev --port 6040 --quiet",
     "lint": "eslint .",
     "authenticate": "custom-dx-components authenticate",
@@ -12,26 +13,33 @@
     "buildAllComponents": "custom-dx-components buildAllComponents",
     "create": "custom-dx-components create",
     "createAll": "custom-dx-components createAll",
-    "publish": "custom-dx-components publish",
-    "publishAll": "custom-dx-components publishAll",
     "rename": "custom-dx-components rename",
     "list": "custom-dx-components list",
     "validate-schema": "custom-dx-components validateSchema",
     "update": "custom-dx-components update",
     "delete": "custom-dx-components delete",
     "deleteAll": "custom-dx-components deleteAll",
+    "_***Component_mode_only***": "Component only commands",
+    "publish": "custom-dx-components publish",
+    "publishAll": "custom-dx-components publishAll",
     "promoteWebPack": "custom-dx-components promoteWebPack",
     "revertWebPack": "custom-dx-components revertWebPack",
-    "_library_comments": "library based commands",
-    "createLibrary": "custom-dx-components createLibrary",
-    "switchLibrary": "custom-dx-components switchLibrary",
-    "createVersion": "custom-dx-components createVersion",
-    "switchVersion": "custom-dx-components switchVersion",
-    "listLibrary": "custom-dx-components listLibrary",
-    "listPublished": "custom-dx-components listPublished",
-    "deleteLibrary": "custom-dx-components deleteLibrary",
-    "deletePublished": "custom-dx-components deletePublished",
+    "_***Library_mode_only***": "Library mode only commands",
+    "createLib": "custom-dx-components createLibrary",
+    "switchLib": "custom-dx-components switchLibrary",
+    "createLibVersion": "custom-dx-components createVersion",
+    "switchLibVersion": "custom-dx-components switchVersion",
+    "listLib": "custom-dx-components listLibrary",
+    "listPublishedLib": "custom-dx-components listPublished",
+    "deleteLib": "custom-dx-components deleteLibrary",
+    "deletePublishedLib": "custom-dx-components deletePublished",
+    "deleteLibVersion": "custom-dx-components deleteVersion",
+    "publishLibVersion": "custom-dx-components publish",
+    "storeLibVersion": "custom-dx-components storeComponents",
     "showStatus": "custom-dx-components showStatus",
+    "moveLibVersion": "custom-dx-components moveComponent",
+    "importLibVersion": "custom-dx-components importArchive",
+    "exportLibVersion": "custom-dx-components exportArchive",
     "validate": "custom-dx-components buildComponent",
     "validateAll": "custom-dx-components buildAllComponents",
     "_internal-test-coverage": "node --input-type=module  --experimental-vm-modules node_modules/jest/bin/jest.js --runInBand node_modules/@pega/custom-dx-component --ci --testResultsProcessor='jest-junit' --coverage",
@@ -88,7 +96,7 @@
   },
   "devDependencies": {
     "@pega/configs": "^0.6.0",
-    "@pega/custom-dx-components": "0.242.28",
+    "@pega/custom-dx-components": "0.242.29",
     "@pega/pcore-pconnect-typedefs": "~3.0.0",
     "@storybook/addon-actions": "^7.6.7",
     "@storybook/addon-essentials": "^7.6.19",

package/src/tasks/list/helper.js

@@ -5,14 +5,13 @@ import fetch from 'node-fetch';
 import { join } from 'path';
 
 import { LIST_COMPONENT_SERVICE_REST_ENDPOINT, LP_LIST_COMPONENT_SERVICE_REST_ENDPOINT, TOKEN_PATH, COMPONENT_SCHEMA, TASKS_CONFIG_JSON_FILENAME, COMPONENTS_DIRECTORY_PATH, COMPONENTS_PATH } from '../../constants.js';
-import { constructCompleteUrl, getComponents, getPegaServerConfig, getHttpsAgent, sanitize, addDebugLog, getLibraryBased, getComponentsConfigs, getConfigDefaults } from '../../util.js';
+import { constructCompleteUrl, getComponents, getPegaServerConfig, getHttpsAgent, addDebugLog, getLibraryBased, getComponentsConfigs, getConfigDefaults } from '../../util.js';
 
 export const SOURCE_OF_COMPONENT_TYPES = {
   SERVER: 'Server',
   LOCAL: 'Local'
 };
 
-const isLibraryBased = getLibraryBased();
 
 export const getListComponentsQuestions = async (options) => {
 addDebugLog("getListComponentsQuestions", "", "");
@@ -82,6 +81,7 @@ addDebugLog("getLaunchPadFilterQuestions", "", "");
 export const listLocalComponents = async (sourceOfComponents) => {
 addDebugLog("listLocalComponents", `sourceOfComponents: ${sourceOfComponents}`, "");
 
+  const isLibraryBased = getLibraryBased();
   if (isLibraryBased) {
     const defConfig = getConfigDefaults();
     const data = await getComponentsConfigs();