@eui/tools 6.1.0 → 6.1.2

package/scripts/csdr/init/init.js

@@ -29,7 +29,7 @@ module.exports.init = () => {
     skipAppContainers: skipAppContainers || false
   }
 
-  // checking branch and envTarget types
+  // checking branch
   if (initialResponse.branch && typeof (initialResponse.branch) === 'boolean') {
     initialResponse.branch = 'develop';
   }
@@ -65,10 +65,10 @@ module.exports.init = () => {
     // clone or install linked host package to project if any
     .then(() => {
       if (finalResponse.project && !build) {
-        return initUtils.cloneHostPackage(finalResponse.project);
+        return initUtils.packages.cloneHostPackage(finalResponse.project);
 
       } else if (finalResponse.project && build) {
-        return initUtils.installHostPackage(finalResponse.project);
+        return initUtils.packages.installHostPackage(finalResponse.project);
       }
     })
 
@@ -86,25 +86,32 @@ module.exports.init = () => {
 
     // Importing packages and generating definitions
     .then(() => {
-      return initUtils.importPackages(finalResponse);
+      return initUtils.packages.importPackages(finalResponse);
     })
 
     // Importing external sources
     .then(() => {
       if (finalResponse.project) {
-        return initUtils.importExternalSources();
+        return initUtils.projects.importExternalSources();
+      }
+    })
+
+    // Generating virtual remote - experimental
+    .then(() => {
+      if (finalResponse.pkg && finalResponse.pkgOnly) {
+        return initUtils.remotes.generateVirtualRemote(pkg);
       }
     })
 
     // adapt and inject particular root data/config for eUI version detected on project
     // if multiple versions of eUI are detected on the same project, an exception is thrown
     .then(() => {
-      return initUtils.processLocalEuiVersions();
+      return initUtils.global.processLocalEuiVersions();
     })
 
     // specific resolution injection based on NodeJS (recent failure of nodejs10.x for MWP v7)
     .then(() => {
-      return initUtils.processResolutionsForNodeVersion();
+      return initUtils.global.processResolutionsForNodeVersion();
     })
 
     // Install deps based on current config generated => take last know snapshots
@@ -113,7 +120,7 @@ module.exports.init = () => {
       // in case of release the initialisation is managed by the application / package themselves
       if (!build && !skipInstall) {
         if (finalResponse.pkgOnly) {
-          return installUtils.localDev.install(pkg);
+          return installUtils.localDev.installPackage(pkg);
         } else {
           return installUtils.localDev.install();
         }
@@ -124,7 +131,7 @@ module.exports.init = () => {
     // Attaching app scripts to root package.json
     .then(() => {
       if (finalResponse.project) {
-        return initUtils.importScripts();
+        return initUtils.projects.importScripts();
       }
     })
 
@@ -132,7 +139,7 @@ module.exports.init = () => {
     // Attaching extra tsconfig from project
     .then(() => {
       if (finalResponse.project) {
-        return initUtils.importExtraTsConfig();
+        return initUtils.projects.importExtraTsConfig();
       }
     })
 
@@ -140,7 +147,7 @@ module.exports.init = () => {
     // Attaching external features from project
     .then(() => {
       if (finalResponse.project && !build) {
-        return initUtils.importExternalFeatures();
+        return initUtils.projects.importExternalFeatures();
       }
     })
 
@@ -148,7 +155,7 @@ module.exports.init = () => {
     // Attaching external mock repo for project
     .then(() => {
       if (finalResponse.project && !build && !prjOnly) {
-        return initUtils.importExternalMock();
+        return initUtils.projects.importExternalMock();
       }
     })
 

package/scripts/csdr/init/packages.js

@@ -0,0 +1,142 @@
+'use strict';
+
+// GLOBAL
+const path = require('path');
+
+// LOCAL
+const tools = require('../../utils/tools');
+const configUtils = require('../config/config-utils');
+const gitUtils = require('../../utils/git-utils');
+const installUtils = require('../install/install-utils');
+
+
+
+
+const importPackage = (pkg, args) => {
+  tools.logTitle(`importing package ${pkg.name}`);
+
+  if (pkg.parent) {
+    tools.logInfo('Parent package ... skipping import');
+    return Promise.resolve();
+
+  } else {
+    if (pkg.tsPackage !== false) {
+      return Promise.resolve()
+      .then(() => {
+        if (!pkg.element) {
+          return configUtils.angular.registerAngularPackage(pkg, args.reset);
+        } else if (pkg.element) {
+          return configUtils.angular.registerAngularProjectDef(pkg, args.reset, true);
+        } else {
+          return configUtils.angular.registerAngularProjectDef(pkg, args.reset);
+        }
+      })
+      .then(() => {
+        if (pkg.pathInclude !== false && !pkg.element) {
+          return configUtils.angular.registerModulePaths(pkg, args.reset);
+        }
+      })
+
+      .then(() => {
+        tools.logSuccess('OK => package imported');
+      })
+
+      .catch((e) => {
+        throw e;
+      })
+
+    } else {
+      tools.logInfo('Non TS package... skipping registration');
+      return Promise.resolve();
+    }
+  }
+}
+
+
+
+
+
+module.exports.importPackages = (args = {}) => {
+
+  tools.logTitle('Importing configuration of packages');
+
+  const packages = configUtils.packages.getPackages();
+
+  return Promise.resolve()
+    .then(() => {
+      configUtils.angular.checkConfigFiles(args.reset);
+    })
+    .then(() => Promise.resolve().then(() => {
+      return packages.reduce((promise, pkg) => {
+        return promise.then(() => (
+          importPackage(pkg, args)
+        ));
+      }, Promise.resolve());
+    }))
+
+    .then(() => {
+      tools.logSuccess('OK => all packages successfully imported');
+    })
+
+    .catch((e) => {
+      throw e;
+    })
+}
+
+
+module.exports.cloneHostPackage = (projectName) => {
+
+  const project = configUtils.projects.getProject(projectName);
+
+  if (!project.hostPackage) {
+    return;
+  }
+
+  tools.logTitle('Installing host package');
+
+  let pkg;
+
+  return Promise.resolve()
+    .then(() => {
+      pkg = configUtils.packages.getPackageByNpmPkg(project.hostPackage, true);
+      if (!pkg) {
+        throw new Error('Invalid host package provided / unknown to CSDR config');
+      }
+      return gitUtils.cloneAndCheckout(pkg.repository, path.join(process.cwd(), 'packages', pkg.name), 'develop');
+    })
+
+    .then(() => {
+      const newPackages = [];
+      newPackages.push(pkg.name);
+      return configUtils.global.updateConfig(null, newPackages);
+    })
+
+    .catch((e) => {
+      throw e;
+    })
+}
+
+
+module.exports.installHostPackage = (projectName) => {
+  tools.logTitle('Installing host package');
+
+  return Promise.resolve()
+    .then(() => {
+      const project = configUtils.projects.getProject(projectName);
+
+      if (!project.hostPackage) {
+        tools.logInfo('project hostPackage not defined...skipping');
+
+      } else {
+        const pkg = configUtils.packages.getPackageByNpmPkg(project.hostPackage, true);
+        if (!pkg) {
+          throw new Error('Invalid host package provided / unknown to CSDR config');
+        }
+        return installUtils.projects.installHostPackage(project, pkg.npmPkg);
+      }
+    })
+
+    .catch((e) => {
+      throw e;
+    })
+}

package/scripts/csdr/init/projects.js

@@ -0,0 +1,112 @@
+'use strict';
+
+// GLOBAL
+const path = require('path');
+
+// LOCAL
+const tools = require('../../utils/tools');
+const injectionUtils = require('../../utils/pre-build/injection/injection-utils');
+const configUtils = require('../config/config-utils');
+
+
+
+module.exports.importScripts = () => {
+  return Promise.resolve()
+    .then(() => {
+      tools.logTitle("Init scripts for local projects");
+      const projects = configUtils.projects.getProjects();
+
+      const rootPackageJsonFile = path.join(process.cwd(), 'package.json')
+      const rootPackageJson = require(rootPackageJsonFile);
+
+      projects.forEach((p) => {
+        tools.logInfo(`Project :  ${p.name}`);
+
+        const scriptsFile = path.join(process.cwd(), p.folder, 'scripts.json');
+        if (!tools.isFileExists(scriptsFile)) {
+          tools.logInfo('no scripts.json file found - skipping');
+        } else {
+          tools.logInfo('Processing scripts.json file');
+          const scriptsJson = require(scriptsFile);
+          rootPackageJson.scripts = { ...rootPackageJson.scripts, ...scriptsJson };
+        }
+      });
+
+      tools.logInfo('Updating root package.json');
+      tools.writeJsonFileSync(rootPackageJsonFile, rootPackageJson);
+    })
+    .catch((e) => {
+      throw e;
+    })
+}
+
+
+module.exports.importExternalFeatures = () => {
+  return Promise.resolve()
+    .then(() => {
+      tools.logTitle("Import external features for local projects");
+
+      return configUtils.projects.getProjects().reduce((promise, prj) => {
+        return promise.then(() => (
+          injectionUtils.externals.injectExternalFeatures(prj)
+        ));
+      }, Promise.resolve());
+    })
+    .catch((e) => {
+      throw e;
+    })
+}
+
+
+module.exports.importExternalSources = () => {
+  return Promise.resolve()
+    .then(() => {
+      tools.logTitle("Import external sources for local projects");
+
+      return configUtils.projects.getProjects().reduce((promise, prj) => {
+        return promise.then(() => (
+          injectionUtils.externals.injectExternalAppSources(prj)
+        ));
+      }, Promise.resolve());
+    })
+    .catch((e) => {
+      throw e;
+    })
+}
+
+
+
+module.exports.importExternalMock = () => {
+  return Promise.resolve()
+    .then(() => {
+      tools.logTitle("Import external mock for local projects");
+
+      return configUtils.projects.getProjects().reduce((promise, prj) => {
+        return promise.then(() => (
+          injectionUtils.externals.injectExternalMock(prj)
+        ));
+      }, Promise.resolve());
+
+    })
+    .catch((e) => {
+      throw e;
+    })
+}
+
+
+
+module.exports.importExtraTsConfig = () => {
+  tools.logTitle("Init extra ts config for local projects");
+
+  return Promise.resolve()
+    .then(() => {
+
+      configUtils.projects.getProjects().forEach((p) => {
+        tools.logInfo(`Check extra tsconfig for project :  ${p.name}`);
+        configUtils.angular.registerProjectExtraPaths(p);
+      })
+    })
+    .catch((e) => {
+      throw e;
+    })
+}

package/scripts/csdr/init/remotes.js

@@ -0,0 +1,21 @@
+'use strict';
+
+// GLOBAL
+const path = require('path');
+
+// LOCAL
+const tools = require('../../utils/tools');
+const configUtils = require('../config/config-utils');
+
+
+module.exports.generateVirtualRemote = (pkgName) => {
+  const pkg = configUtils.packages.getPackage(pkgName, true);
+
+  if (!pkg.remote && !pkg.virtual) {
+    return;
+  }
+
+  tools.logTitle('Generate virtual remote');
+
+  // TODO
+}