@eui/tools 5.3.72 → 5.3.74

package/.version.properties

@@ -1 +1 @@
-5.3.72
+5.3.74

package/CHANGELOG.md

@@ -1,3 +1,21 @@
+## 5.3.74 (2022-10-20)
+
+##### Bug Fixes
+
+* **karma:**
+  * tests - EUI-6702 [EUI-6702](https://webgate.ec.europa.eu/CITnet/jira/browse/EUI-6702)  ([d7c136d0](https://webgate.ec.europa.eu/CITnet/stash/scm/csdr/eui-tools.git/commits/d7c136d07f5bf3a8090727f7168a2eb4e21ae247))
+
+* * *
+* * *
+## 5.3.73 (2022-10-11)
+
+##### Chores
+
+* **other:**
+  * allow array of app sources injection and overrides - MWP-8868 [MWP-8868](https://webgate.ec.europa.eu/CITnet/jira/browse/MWP-8868)  ([55ae46fc](https://webgate.ec.europa.eu/CITnet/stash/scm/csdr/eui-tools.git/commits/55ae46fcaea7263983452b9da90c56545561238c))
+
+* * *
+* * *
 ## 5.3.72 (2022-10-07)
 
 ##### Chores

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@eui/tools",
-    "version": "5.3.72",
+    "version": "5.3.74",
     "tag": "latest",
     "license": "EUPL-1.1",
     "description": "eUI common tools and scripts",

package/scripts/csdr/config/angular.js

@@ -1145,6 +1145,10 @@ const angularPackageDef = {
     "test": {
       "builder": "@angular-devkit/build-angular:karma",
       "options": {
+        "polyfills": [
+          "zone.js",
+          "zone.js/testing"
+        ],
         "main": "@path@/@module.name@/src/test.ts",
         "tsConfig": "@path@/@module.name@/tsconfig.spec.json",
         "karmaConfig": "@path@/@module.name@/karma.conf.js"
@@ -1174,6 +1178,10 @@ const angularPackageSubEntryDef = {
     "test": {
       "builder": "@angular-devkit/build-angular:karma",
       "options": {
+        "polyfills": [
+          "zone.js",
+          "zone.js/testing"
+        ],
         "main": "packages/eui/packages/components/@subEntry.path@/test.ts",
         "tsConfig": "packages/eui/packages/components/@subEntry.path@/tsconfig.spec.json",
         "karmaConfig": "packages/eui/packages/components/@subEntry.path@/karma.conf.js"
@@ -1262,6 +1270,44 @@ const angularPackageDefV14 = {
   }
 };
 
+const angularPackageDefV15 = {
+  "root": "@path@/@module.name@",
+  "sourceRoot": "@path@/@module.name@@srcRoot@",
+  "projectType": "library",
+  "prefix": "lib",
+  "architect": {
+    "lint": {
+      "builder": "@angular-eslint/builder:lint",
+      "options": {
+        "lintFilePatterns": [
+          "@path@/@module.name@/**/*.ts",
+          "@path@/@module.name@/**/*.html"
+        ],
+        "eslintConfig": "@path@/@module.name@/.eslintrc.json"
+      }
+    },
+    "build": {
+      "builder": "@angular-devkit/build-angular:ng-packagr",
+      "options": {
+        "tsConfig": "@path@/@module.name@/@tsconfig@",
+        "project": "@path@/@module.name@/ng-package.json"
+      },
+      "configurations": {
+        "production": {
+          "tsConfig": "@path@/@module.name@/tsconfig.lib.prod.json"
+        }
+      }
+    },
+    "test": {
+      "builder": "@angular-devkit/build-angular:karma",
+      "options": {
+        "tsConfig": "@path@/@module.name@/tsconfig.spec.json",
+        "karmaConfig": "@path@/@module.name@/karma.conf.js"
+      }
+    }
+  }
+};
+
 
 
 
@@ -1418,10 +1464,12 @@ module.exports.registerAngularPackage = (pkg, isReset) => {
   if (packageEuiVersion === '13.x') {
     projectDef = JSON.stringify(angularPackageDefV13);
   }
-  if (packageEuiVersion === '14.x' || packageEuiVersion === '15.x') {
+  if (packageEuiVersion === '14.x') {
     projectDef = JSON.stringify(angularPackageDefV14);
   }
-
+  if (packageEuiVersion === '15.x') {
+    projectDef = JSON.stringify(angularPackageDefV15);
+  }
 
   let srcRoot = '/src', srcRootTesting = '';
   if (pkg.build && typeof pkg.build.srcRootDefault === 'boolean' && pkg.build.srcRootDefault === false) {
@@ -1445,15 +1493,25 @@ module.exports.registerAngularPackageSubEntry = (subEntryName, subEntryPath, pkg
   const file = path.join(process.cwd(), 'angular.json');
   const jsonFile = require(file);
 
+  let packageEuiVersion;
+  if (pkg.build && pkg.build.euiVersion) {
+    packageEuiVersion = pkg.build.euiVersion;
+  } else {
+    packageEuiVersion = innerPackages.getPackageEuiVerison(pkg);
+  }
+
   let projectDef = JSON.stringify(angularPackageSubEntryDef);
 
-  let replacePath = tools.replaceAll(projectDef, '@subEntry.path@', subEntryName)
-  replacePath = tools.replaceAll(replacePath, '@subEntry.package.name@', 'ng-package.json');
-  replacePath = tools.replaceAll(replacePath, '@tsconfig@', pkg.tsConfigFileName);
+  if (packageEuiVersion === '15.x') {
+    projectDef = projectDef.replace('"main":"packages/eui/packages/components/@subEntry.path@/test.ts",', '');
+  }
+  projectDef = tools.replaceAll(projectDef, '@subEntry.path@', subEntryName)
+  projectDef = tools.replaceAll(projectDef, '@subEntry.package.name@', 'ng-package.json');
+  projectDef = tools.replaceAll(projectDef, '@tsconfig@', pkg.tsConfigFileName);
 
-  jsonFile['projects'][subEntryName] = JSON.parse(replacePath);
+  jsonFile['projects'][subEntryName] = JSON.parse(projectDef);
 
-  console.log(jsonFile['projects'][subEntryName]);
+  // console.log(jsonFile['projects'][subEntryName]);
 
   tools.writeJsonFileSync(file, jsonFile);
 }

package/scripts/utils/build/package/build-package-utils.js

@@ -221,7 +221,13 @@ module.exports.buildSubEntry = (pkg, subEntry) => {
         };
       }
     })
-
+    .then(() => {
+      tools.logInfo('Testing...');
+      const ng = path.resolve(process.cwd(), 'node_modules', '@angular', 'cli', 'bin', 'ng');
+      let args = ['--max_old_space_size=8096', ng, 'test', subEntry, '--code-coverage', '--watch=false'];
+      tools.logInfo(`running ng test : with args: ${args} on folder : ${pkg.paths.pkgRootDirectory}`);
+      return execa('node', args, { cwd: pkg.paths.pkgRootDirectory, stdio: 'inherit' });
+    })
     .then(() => {
       const ng = path.resolve(process.cwd(), 'node_modules', '@angular', 'cli', 'bin', 'ng');
 

package/scripts/utils/pre-build/injection/externals.js

@@ -64,89 +64,119 @@ module.exports.injectExternalFeatures = (project) => {
 }
 
 
+
+const injectExternalAppSourcesCore = (project, build = false, injectedNpmPkg, injectedFolder) => {
+
+  tools.logInfo(`Injecting : ${injectedNpmPkg} / ${injectedFolder}`);
+
+  return Promise.resolve()
+  .then(() => {
+    // check if package is locally cloned
+    const localPackage = configUtils.packages.getPackages().filter((p) => {
+      return p.npmPkg === injectedNpmPkg
+    })[0];
+
+    let appSourcesSrcPath;
+    const projectSrcPath = path.join(process.cwd(), project.folder, 'src');
+
+    // if local package is found
+    if (localPackage) {
+      tools.logInfo('local project found, copying from local');
+      appSourcesSrcPath = path.join(process.cwd(), 'packages', localPackage.name, injectedFolder);
+
+    // if not sources are taken from the npm package def in node_modules
+    } else {
+      tools.logInfo('remote project found, copying from remote');
+      const npmPkgScope = injectedNpmPkg.substr(0, injectedNpmPkg.indexOf('/'));
+      const npmPkgName = injectedNpmPkg.substr(injectedNpmPkg.indexOf('/') + 1);
+
+      appSourcesSrcPath = path.join(process.cwd(), 'node_modules', npmPkgScope, npmPkgName, injectedFolder);
+    }
+
+    if (!tools.isDirExists(appSourcesSrcPath)) {
+      tools.logWarning(`External sources location : ${appSourcesSrcPath} cannot be found in node_modules`);
+      throw new Error('External sources not found');
+
+    } else {
+
+      return Promise.resolve()
+        .then(() => {
+          tools.logInfo(`${appSourcesSrcPath} injecting in ${projectSrcPath}`);
+          return tools.copydir(appSourcesSrcPath, projectSrcPath, true);
+        })
+        .catch((e) => {
+          throw e;
+        })
+    }
+  })
+
+  .catch((e) => {
+    throw e;
+  })
+}
+
+
+
 module.exports.injectExternalAppSources = (project, build = false) => {
 
   tools.logTitle(`Injecting project external application sources for : ${project.name}`);
 
   return Promise.resolve()
     .then(() => {
-      if (!project.appSources) {
+      if (!build) {
+        // removing previously injected content, except assets
+        const projectSrcPath = path.join(process.cwd(), project.folder, 'src');
+        const projectSrcAppPath = path.join(projectSrcPath, 'app');
+        const projectSrcConfigPath = path.join(projectSrcPath, 'config');
+        const projectSrcEnvironmentsPath = path.join(projectSrcPath, 'environments');
+
+        return Promise.resolve()
+          .then(() => {
+            tools.logInfo(`Removing ${projectSrcAppPath} content`);
+            return tools.rimraf(projectSrcAppPath);
+          })
+          .then(() => {
+            tools.logInfo(`Removing ${projectSrcConfigPath} content`);
+            return tools.rimraf(projectSrcConfigPath);
+          })
+          .then(() => {
+            tools.logInfo(`Removing ${projectSrcEnvironmentsPath} content`);
+            return tools.rimraf(projectSrcEnvironmentsPath);
+          })
+          .catch((e) => {
+            throw e;
+          })
+      }
+    })
+    .then(() => {
+      if (!project.externalSources) {
         tools.logInfo('No external app sources setup...skipping');
         return;
       }
 
-      if (!project.appSources.npmPkg || !project.appSources.folder) {
-        return tools.logWarning('External appSources use requires a source [npmPkg] and a [folder] declared');
-
+      // in case of multiple injection are defined, we promise loop on each injection
+      if (Array.isArray(project.externalSources)) {
+        return Promise.resolve().then(() => {
+          return project.externalSources.reduce((promise, appSource) => {
+            return promise.then(() => (
+              injectExternalAppSourcesCore(project, build, appSource.npmPkg, appSource.folder)
+            ));
+          }, Promise.resolve());
+        })
+
+      // if only one injection externalSources is defined
       } else {
-        // check if package is locally cloned
-        const localPackage = configUtils.packages.getPackages().filter((p) => {
-          return p.npmPkg === project.appSources.npmPkg
-        })[0];
-
-        let appSourcesSrcPath;
-        const projectSrcPath = path.join(process.cwd(), project.folder, 'src');
-
-        // if local package is found
-        if (localPackage) {
-          tools.logInfo('local project found, copying from local');
-          appSourcesSrcPath = path.join(process.cwd(), 'packages', localPackage.name, project.appSources.folder);
-
-        // if not sources are taken from the npm package def in node_modules
-        } else {
-          tools.logInfo('remote project found, copying from remote');
-          const npmPkgScope = project.appSources.npmPkg.substr(0, project.appSources.npmPkg.indexOf('/'));
-          const npmPkgName = project.appSources.npmPkg.substr(project.appSources.npmPkg.indexOf('/') + 1);
-
-          appSourcesSrcPath = path.join(process.cwd(), 'node_modules', npmPkgScope, npmPkgName, project.appSources.folder);
-        }
-
-        if (!tools.isDirExists(appSourcesSrcPath)) {
-          tools.logWarning(`External features location : ${appSourcesSrcPath} cannot be found in node_modules`);
-          throw new Error('External features not found');
+        if (!project.externalSources.npmPkg || !project.externalSources.folder) {
+          return tools.logWarning('External externalSources use requires a source [npmPkg] and a [folder] declared');
 
         } else {
-
-          return Promise.resolve()
-            .then(() => {
-              if (!build) {
-                // removing previously injected content, except assets
-                const projectSrcAppPath = path.join(projectSrcPath, 'app');
-                const projectSrcConfigPath = path.join(projectSrcPath, 'config');
-                const projectSrcEnvironmentsPath = path.join(projectSrcPath, 'environments');
-
-                return Promise.resolve()
-                  .then(() => {
-                    tools.logInfo(`Removing ${projectSrcAppPath} content`);
-                    return tools.rimraf(projectSrcAppPath);
-                  })
-                  .then(() => {
-                    tools.logInfo(`Removing ${projectSrcConfigPath} content`);
-                    return tools.rimraf(projectSrcConfigPath);
-                  })
-                  .then(() => {
-                    tools.logInfo(`Removing ${projectSrcEnvironmentsPath} content`);
-                    return tools.rimraf(projectSrcEnvironmentsPath);
-                  })
-                  .catch((e) => {
-                    throw e;
-                  })
-              }
-            })
-            .then(() => {
-              tools.logInfo(`${appSourcesSrcPath} injecting in ${projectSrcPath}`);
-              return tools.copydir(appSourcesSrcPath, projectSrcPath, true);
-            })
-            .catch((e) => {
-              throw e;
-            })
+          return injectExternalAppSourcesCore(project, build, project.externalSources.npmPkg, project.externalSources.folder);
         }
       }
     })
     .catch((e) => {
       throw e;
     })
-
 }
 
 

package/scripts/utils/pre-build/injection/routes-replacement.js

@@ -6,6 +6,10 @@ const _ = require('lodash');
 const tools = require('../../tools');
 const configUtils = require('../../../csdr/config/config-utils');
 
+// const { subRoutes, debug } = tools.getArgs();
+const { debug } = tools.getArgs();
+
+
 
 const getEnvTarget = (envTargetIn, build) => {
   if (!envTargetIn) {
@@ -71,39 +75,39 @@ const getRoutesFile = (project) => {
 
   return Promise.resolve()
     .then(() => {
-      if (!project.appSources) {
-        tools.logError('project requires appSources definition');
+      if (!project.externalRoutesSources) {
+        tools.logError('project requires externalRoutesSources definition');
         return;
       }
 
       let routesFilePath;
       let srcRoutesFilePath;
 
-      if (!project.appSources.routesFileNpmPkg || !project.appSources.routesFileSource || !project.appSources.routesFilePath) {
-        tools.logError('project requires appSources.routesFileNpmPkg, routesFileSources and routesFilePath definitions');
+      if (!project.externalRoutesSources.routesFileNpmPkg || !project.externalRoutesSources.routesFileSource || !project.externalRoutesSources.routesFilePath) {
+        tools.logError('project requires externalRoutesSources.routesFileNpmPkg, routesFileSources and routesFilePath definitions');
         return;
       }
 
       // check if package is locally cloned
       const localPackage = configUtils.packages.getPackages().filter((p) => {
-        return p.npmPkg === project.appSources.routesFileNpmPkg
+        return p.npmPkg === project.externalRoutesSources.routesFileNpmPkg
       })[0];
 
       // if local package is found
       if (localPackage) {
         tools.logInfo('local package found, copying from local');
-        srcRoutesFilePath = path.join(process.cwd(), 'packages', localPackage.name, project.appSources.routesFileSource);
+        srcRoutesFilePath = path.join(process.cwd(), 'packages', localPackage.name, project.externalRoutesSources.routesFileSource);
 
       // if not sources are taken from the npm package def in node_modules
       } else {
         tools.logInfo('remote package found, copying from remote');
-        const npmPkgScope = project.appSources.routesFileNpmPkg.substr(0, project.appSources.routesFileNpmPkg.indexOf('/'));
-        const npmPkgName = project.appSources.routesFileNpmPkg.substr(project.appSources.routesFileNpmPkg.indexOf('/') + 1);
+        const npmPkgScope = project.externalRoutesSources.routesFileNpmPkg.substr(0, project.externalRoutesSources.routesFileNpmPkg.indexOf('/'));
+        const npmPkgName = project.externalRoutesSources.routesFileNpmPkg.substr(project.externalRoutesSources.routesFileNpmPkg.indexOf('/') + 1);
 
-        srcRoutesFilePath = path.join(process.cwd(), 'node_modules', npmPkgScope, npmPkgName, project.appSources.routesFileSource);
+        srcRoutesFilePath = path.join(process.cwd(), 'node_modules', npmPkgScope, npmPkgName, project.externalRoutesSources.routesFileSource);
       }
 
-      routesFilePath = path.join(project.paths.rootPath, project.appSources.routesFilePath);
+      routesFilePath = path.join(project.paths.rootPath, project.externalRoutesSources.routesFilePath);
 
       // copy source file to project destination
       tools.copy(srcRoutesFilePath, routesFilePath);
@@ -130,8 +134,8 @@ const replaceRoutes = (project, envTarget, build, routesFileContent) => {
       // getting base route defs content
       const projectAssetsPath = path.join(process.cwd(), project.folder, 'src', 'assets');
       let routeDefsBaseFilename = 'route-defs-base.json';
-      if (project.appSources.routesBaseFilename) {
-        routeDefsBaseFilename = project.appSources.routesBaseFilename;
+      if (project.externalRoutesSources.routesBaseFilename) {
+        routeDefsBaseFilename = project.externalRoutesSources.routesBaseFilename;
       }
       const baseRouteDefsPath = path.join(projectAssetsPath, routeDefsBaseFilename);
 
@@ -160,13 +164,22 @@ const replaceRoutes = (project, envTarget, build, routesFileContent) => {
       const mergedRouteDefs = _.merge(_.keyBy(baseRouteDefsJSON, 'path'), _.keyBy(envRouteDefsJSON, 'path'));
       const finalRouteDefs = _.values(mergedRouteDefs);
 
+      // getting subRoutes if passed as arguments
+      // let subRoutesArray;
+
+      // if (subRoutes) {
+      //   subRoutesArray = subRoutes.split(',');
+
+      //   tools.logInfo('subRoutes arguments foound : ');
+      //   tools.logInfo(subRoutesArray);
+      // }
 
       // processing routes
       let placeHolderContent = '';
 
       tools.logInfo('Processing routes replacement');
       finalRouteDefs.forEach((route) => {
-        tools.logInfo(`====> route : ${route.path}`);
+        if (debug) tools.logInfo(`====> route : ${route.path}`);
 
         let routeContent = '{\n';
 
@@ -204,14 +217,24 @@ const replaceRoutes = (project, envTarget, build, routesFileContent) => {
 
         placeHolderContent += routeContent;
 
-        tools.logSuccess('======> OK replaced');
+        // if (subRoutesArray) {
+        //   if (subRoutesArray.includes(route.path)) {
+        //     placeHolderContent += routeContent;
+        //   }
+        // } else {
+        //   placeHolderContent += routeContent;
+        // }
+
+        if (debug) tools.logSuccess('======> OK replaced');
       })
 
       const placeHolderToken = '// routes-placeholder';
       routesFileContent = tools.replaceAll(routesFileContent, placeHolderToken, placeHolderContent);
 
-      tools.logInfo('Routes file content replaced : ');
-      console.log(routesFileContent);
+      if (debug) {
+        tools.logInfo('Routes file content replaced : ');
+        console.log(routesFileContent);
+      }
 
       return routesFileContent;
     })

package/scripts/utils/pre-build/projects.js

@@ -29,7 +29,7 @@ module.exports.preBuild = (project, envTarget, build, configEnvTarget) => {
 
     // inject external app sources declaration
     .then(() => {
-      if (project.appSources && project.appSources.external) {
+      if (project.externalSources) {
         return injectionUtils.externals.injectExternalAppSources(project, build);
       }
     })
@@ -62,7 +62,7 @@ module.exports.preBuild = (project, envTarget, build, configEnvTarget) => {
 
 
     .then(() => {
-      if (project.config && project.appSources && project.appSources.external && project.appSources.remapRoutesByEnvConfig) {
+      if (project.config && project.externalRoutesSources) {
         return injectionUtils.routesReplacement.buildRoutes(project, envTarget, build);
       }
     })