@eui/tools 6.8.0 → 6.9.0

package/.version.properties

@@ -1 +1 @@
-6.8.0
+6.9.0

package/CHANGELOG.md

@@ -1,3 +1,21 @@
+## 6.9.0 (2023-03-11)
+
+##### New Features
+
+* **other:**
+  * route config and replacement v2 - setup default files pre-integration - EUI-7121 [EUI-7121](https://webgate.ec.europa.eu/CITnet/jira/browse/EUI-7121)  ([ba99c941](https://webgate.ec.europa.eu/CITnet/stash/scm/csdr/eui-tools.git/commits/ba99c941145d7c48b21b654a2ead2889462a525d))
+
+* * *
+* * *
+## 6.8.1 (2023-03-10)
+
+##### Bug Fixes
+
+* **other:**
+  * project eUI version fetch when no dependencies-composite - EUI-7240 [EUI-7240](https://webgate.ec.europa.eu/CITnet/jira/browse/EUI-7240)  ([f78ecdc8](https://webgate.ec.europa.eu/CITnet/stash/scm/csdr/eui-tools.git/commits/f78ecdc823d2d7ebd49b21dea47ac70c59cfc6db))
+
+* * *
+* * *
 ## 6.8.0 (2023-03-09)
 
 ##### New Features

package/package.json

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

package/sandbox.js

@@ -1214,9 +1214,10 @@ const versionUtils = require('./scripts/csdr/version/version-utils');
 
 Promise.resolve()
   .then(() => {
-    return metadataUtils.stats.getRemoteAllStats();
+    const prjName = 'my-workplace-host-playground';
+    const project = configUtils.projects.getCsdrProject(prjName);
+    return preBuildUtils.projects.preBuild(project, 'TST', true, 'TST');
   })
-  .then((stats) => {
-    // console.log(stats);
-    console.log(JSON.stringify(stats, null, 2));
+  .catch((e) => {
+    console.log(e);
   })

package/scripts/csdr/config/angular.js

@@ -189,6 +189,13 @@ module.exports.registerAngularProjectDef = (project, build = false, element = fa
     angularRootPath = project.paths.root;
   } else {
     euiVersion = innerProjects.getProjectEuiVersion(project);
+
+    if (!euiVersion) {
+      if (project.build && project.build.euiVersion) {
+        euiVersion = project.build.euiVersion;
+      }
+    }
+
     angularRootPath = project.paths.angularPath;
   }
 

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

@@ -0,0 +1,281 @@
+'use strict';
+const path = require('path');
+const tools = require('../../tools');
+
+
+// ONE-TIME ONLY !!!! as manual updates has been made...
+
+
+const defaultSample =         {
+  "path": "sample -- full options",
+  "authMetadata": {
+      "id": "SECUNDA_TASK_ID",
+      "ids": "['SECUNDA_TASK_ID', 'SECUNDA_TASK_ID', ...]",
+      "canActivate": "[AuthGuardService] -- if data.id or data.ids present"
+  },
+  "lazyLoadDef": {
+      "npmPkg": "@scope/packageName",
+      "moduleName": "RootPackageModuleName"
+  },
+  "remoteDef": {
+      "featureName": "FEATURE_FLAG_NAME in openid config files - to activate/deactivate links in environment (runtime config)",
+      "moduleId": "used by the elementLoader - name of the remote name in the config : scope-package-euiXX-remote-el-ui",
+      "elementTag": "used by the elementLoader - unique name identifying the remote - scope-package-vXX",
+      "iframe": true
+  },
+  "menuLinkDef": {
+      "label": "sidebar-link.KEY - as defined in the assets/i18n/lng files",
+      "iconClass": "eui-icon eui-icon-ICON_NAME for the menu link entry in the sidebar",
+      "deniedRightId": "SECUNDA_TASK_ID - denied right to not show this link for category of user having this taskId set",
+      "allowedRightId": "SECUNDA_TASK_ID - allowed right to show this link for category of user having this taskId set",
+      "allowedRightIds": "['SECUNDA_TASK_ID', 'SECUNDA_TASK_ID', ...] - multiple taskId are allowed to view this link",
+      "parenLinkId": "PARENT_ID -- children of existing parent in defs-links.json menu links structure"
+  }
+};
+
+
+Promise.resolve()
+  .then(() => {
+    const rPath = path.join(process.cwd(), 'packages', 'mywp-routes-config', 'assets', 'route-defs.dev.json');
+    const rDev = tools.getJsonFileContent(rPath);
+    const lPath = path.join(process.cwd(), 'packages', 'mywp-routes-config', 'assets', 'route-defs-links.json');
+    const rLink = tools.getJsonFileContent(lPath);
+    const plPath = path.join(process.cwd(), 'packages', 'mywp-routes-config', 'assets', 'route-defs-base-v10-playground.json');
+    const rPg = tools.getJsonFileContent(plPath);
+    const plPath15 = path.join(process.cwd(), 'packages', 'mywp-routes-config', 'assets', 'route-defs-base-v15-playground.json');
+    const rPg15 = tools.getJsonFileContent(plPath15);
+
+    const parentLinks = rLink.filter(r => r.parentId !== undefined);
+
+    // base routes
+
+    const resultRoutes = [];
+
+    resultRoutes.push(defaultSample);
+
+    rDev.forEach((route) => {
+      const n = {};
+      n.path = route.path;
+
+      const auth = {};
+      let lazy = {};
+      let remote = {};
+
+      lazy.npmPkg = 'TO_BE_FILLED';
+      lazy.moduleName = 'TO_BE_FILLED';
+
+      if (route.data) {
+        if (route.data.id) {
+          auth.id = route.data.id;
+          auth.canActivate = "[AuthGuardService]";
+          n.authMetadata = auth;
+        }
+        if (route.data.ids) {
+          auth.ids = route.data.ids;
+          auth.canActivate = "[AuthGuardService]";
+          n.authMetadata = auth;
+        }
+
+        if (route.data.elementTag) {
+          remote = {
+            featureName: route.data.featureName,
+            moduleId: route.data.moduleId,
+            elementTag: route.data.elementTag,
+            iframe: route.data.iframe,
+          }
+        }
+      }
+
+      const linkRoute = rLink.filter((r) => {
+        if (r.url) {
+          return r.url.indexOf(route.path) > 0;
+        }
+      })[0];
+
+      if (linkRoute) {
+        n.menuLinkDef = linkRoute;
+
+      } else {
+        let childRoute;
+
+        parentLinks.forEach((pl) => {
+          pl.children.forEach((r) => {
+            if (r.url) {
+              if (r.url.indexOf(route.path) > 0) {
+                childRoute = r;
+                childRoute.parentLinkId = pl.parentId;
+              }
+            }
+          });
+
+          if (childRoute) {
+            n.menuLinkDef = childRoute;
+          }
+        })
+      }
+
+      let mod, imp;
+      let mdRoute;
+
+      mdRoute = rPg.filter(r => r.path === route.path || r.path === route.path.substr(0, route.path.length - 4))[0];
+
+      if (mdRoute) {
+        const libModFilename = mdRoute.loadChildren.substr(0, mdRoute.loadChildren.length - 7);
+        const libModFilePath = path.join(process.cwd(), 'packages', 'mywp-host-ui', 'assets', '10.x', 'app-sources-playground', 'app', libModFilename + '.ts');
+
+        if (tools.isFileExists(libModFilePath)) {
+          const libModFileContent = tools.getFileContent(libModFilePath);
+          const lines = libModFileContent.split('\n');
+          let libModLine;
+          libModLine = lines.filter(l => l.indexOf('LibModule') > 0)[0];
+          if (!libModLine) {
+            libModLine = lines[1];
+          }
+          // console.log(libModFilename, libModLine);
+          const words = libModLine.split(' ');
+          // console.log(words);
+          mod = words.filter(w => w.indexOf('Module') > -1)[0];
+          // console.log(route.path, mod);
+          const impLast = words[words.length-1];
+          imp = impLast.substr(1, impLast.length - 4);
+        }
+      }
+
+      mdRoute = rPg15.filter(r => r.path === route.path || r.path === route.path.substr(0, route.path.length - 4))[0];
+
+      if (mdRoute) {
+        const libModFilename = mdRoute.loadChildren.substr(0, mdRoute.loadChildren.length - 7);
+        const libModFilePath = path.join(process.cwd(), 'packages', 'mywp-host-ui', 'assets', '15.x', 'app-sources-playground', 'app', libModFilename + '.ts');
+
+        if (tools.isFileExists(libModFilePath)) {
+          const libModFileContent = tools.getFileContent(libModFilePath);
+          const lines = libModFileContent.split('\n');
+          let libModLine;
+          libModLine = lines.filter(l => l.indexOf('LibModule') > 0)[0];
+          if (!libModLine) {
+            libModLine = lines[1];
+          }
+          // console.log(libModFilename, libModLine);
+          const words = libModLine.split(' ');
+          // console.log(words);
+          mod = words.filter(w => w.indexOf('Module') > -1)[0];
+          // console.log(route.path, mod);
+          const impLast = words[words.length-1];
+          imp = impLast.substr(1, impLast.length - 4);
+        }
+      }
+
+      if (route.path.indexOf('delegations-manager-v15') > -1) {
+        mod = 'DelegationManagerModule';
+        imp = '@mywp/delegations-manager';
+      }
+      if (route.path.indexOf('task-details-v15') > -1) {
+        mod = 'CcTaskDetailsModule';
+        imp = '@cc/task-details';
+      }
+      if (route.path.indexOf('item-v15') > -1) {
+        mod = 'CcPortfolioItemModule';
+        imp = '@cc/portfolio-item';
+      }
+      if (route.path.indexOf('process-v15') > -1) {
+        mod = 'ProcessCentreListModule';
+        imp = '@cc/process-centre';
+      }
+      if (route.path.indexOf('flex-v15') > -1) {
+        mod = 'FlexModule';
+        imp = '@cc/flex';
+      }
+      if (route.path.indexOf('rsp-management') > -1) {
+        mod = 'Module';
+        imp = '@rsp/management';
+      }
+      if (route.path.indexOf('cps-tools') > -1) {
+        mod = 'CpsCigipModule';
+        imp = '@cps/cigip-orchestrator';
+      }
+      if (route.path.indexOf('decide-poc') > -1) {
+        mod = 'DecideSectionModule';
+        imp = '@cc/decidepoc/section';
+      }
+
+
+      if (mod) {
+        lazy.moduleName = mod;
+      } else {
+        console.log('mod not found : ', route.path);
+      }
+      if (imp) {
+        lazy.npmPkg = imp;
+      } else {
+        console.log('import not found : ', route.path);
+      }
+
+      n.lazyLoadDef = lazy;
+      n.remoteDef = remote;
+
+      resultRoutes.push(n);
+    });
+
+    resultRoutes.push({
+        "path": "notifications",
+        "menuLinkDef": {
+            "url": "/notifications/view-all",
+            "label": "sidebar-link.NOTIFICATIONS",
+            "iconClass": "ux-icon ux-icon-envelope-o",
+            "deniedRightId": "IGNORE_NOTIFICATION"
+        },
+        "lazyLoadDef": {
+            "npmPkg": "@mywp/notifications",
+            "moduleName": "NotificationsModule"
+        }
+    });
+
+    tools.writeJsonFileSync(path.join(process.cwd(), 'packages', 'mywp-host-ui', 'assets', 'routes', 'route-defs-base.json'), resultRoutes);
+    // console.log(JSON.stringify(resultRoutes, null, 2));
+
+
+    // env routes
+    const envs = ['dev', 'test', 'int', 'acc', 'dlt', 'trn', 'prod'];
+
+    envs.forEach((env) => {
+      const envPath = path.join(process.cwd(), 'packages', 'mywp-routes-config', 'assets', `route-defs.${env}.json`);
+      const rEnv = tools.getJsonFileContent(envPath);
+
+      const routes = rEnv.map((r) => {
+        return {
+          "path": r.path,
+          "remote": true
+        };
+      });
+
+      routes.push({
+        path: "notifications",
+        lazy: true
+      });
+
+      tools.writeJsonFileSync(path.join(process.cwd(), 'packages', 'mywp-host-ui', 'assets', 'routes', `route-defs.${env}.json`), routes);
+    });
+
+
+    // playground routes
+    const pgs = ['v10', 'v15'];
+
+    pgs.forEach((pg) => {
+      const pgPath = path.join(process.cwd(), 'packages', 'mywp-routes-config', 'assets', `route-defs-base-${pg}-playground.json`);
+      const rPg = tools.getJsonFileContent(pgPath);
+
+      const routes = rPg.map((r) => {
+        return {
+          "path": r.path,
+          "lazy": true
+        };
+      });
+
+      routes.push({
+        path: "notifications",
+        lazy: true
+      });
+
+      tools.writeJsonFileSync(path.join(process.cwd(), 'packages', 'mywp-host-ui', 'assets', 'routes', `route-defs-base-${pg}-playground.json`), routes);
+    });
+  })

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

@@ -43,31 +43,6 @@ const getEnvTarget = (envTargetIn, build) => {
 }
 
 
-
-const getEnvConfig = (project, envTarget, build) => {
-  tools.logInfo(`Getting config file for env : ${envTarget}`);
-
-  return Promise.resolve()
-    .then(() => {
-      // getting config file
-      const projectAssetsPath = path.join(process.cwd(), project.folder, 'src', 'assets');
-      const envTargetFinal = getEnvTarget(envTarget, build);
-      const configFile = path.join(projectAssetsPath, 'openid-login-config.' + envTargetFinal + '.json');
-
-      tools.logInfo(`checking ${configFile}`);
-      if (!tools.isFileExists(configFile)) {
-        tools.logError(`config file for ${envTarget} does not exists`);
-        return;
-      }
-
-      return require(configFile);
-    })
-
-    .catch((e) => {
-      throw e;
-    })
-}
-
 const getRoutesFile = (project, euiVersion) => {
   tools.logInfo('Getting routes file for replacement');
 
@@ -158,7 +133,7 @@ const getRoutesFile = (project, euiVersion) => {
     })
 }
 
-
+/* @deprecated - TO REMOVE */
 const replaceRouteLegacy = (route) => {
   let routeContent = '{\n';
 
@@ -198,7 +173,7 @@ const replaceRouteLegacy = (route) => {
 }
 
 
-
+/* @deprecated - TO REMOVE */
 const replaceRoute = (route) => {
   let routeContent = '{\n';
 
@@ -242,10 +217,52 @@ const replaceRoute = (route) => {
 
 
 
+const replaceRouteV2 = (route) => {
+  let routeContent = '{\n';
+
+  routeContent += `  path: '${route.path}',\n`;
+  if (Object.keys(route.data).length > 0) {
+    routeContent += '  data: {\n';
+
+    if (route.data.id) {
+      routeContent += `    id: '${route.data.id}',\n`;
+    }
+    if (route.data.ids) {
+      routeContent += `    ids: ${route.data.ids},\n`;
+    }
+    if (route.data.featureName) {
+      routeContent += `    featureName: '${route.data.featureName}',\n`;
+    }
+    if (route.data.moduleId) {
+      routeContent += `    moduleId: '${route.data.moduleId}',\n`;
+    }
+    if (route.data.elementTag) {
+      routeContent += `    elementTag: '${route.data.elementTag}',\n`;
+    }
+    if (route.data.iframe) {
+      routeContent += `    iframe: ${route.data.iframe},\n`;
+    }
+    routeContent += '  },\n';
+  }
+  if (route.canActivate) {
+    routeContent += `  canActivate: ${route.canActivate},\n`;
+  }
+  if (route.loadChildren) {
+    routeContent += `  ${route.loadChildren},\n`
+  }
+  routeContent += '},\n\n';
+
+  return routeContent;
+}
+
+
+/* @deprecated - TO REMOVE */
 const replaceRoutes = (project, envTarget, build, routesFileContent, euiVersion) => {
   return Promise.resolve()
     .then(() => {
 
+      tools.logInfo('Replace routes legacy started...');
+
       // getting base route defs content
       // default route
       let routeDefsBaseFilename = 'route-defs-base.json';
@@ -360,6 +377,294 @@ const replaceRoutes = (project, envTarget, build, routesFileContent, euiVersion)
 }
 
 
+
+const processRoutesConfigV2 = (project, envTarget, build, routesFileContent, euiVersion) => {
+  return Promise.resolve()
+    .then(() => {
+      tools.logInfo('Replace routes v2...');
+
+      // source of all routes - routes defs base
+      const projectAssetsPath = path.join(process.cwd(), project.folder, 'src', 'assets');
+
+      const routeDefsBaseFilename = 'route-defs-base.json';
+      const routeDefsBaseJSON = require(path.join(projectAssetsPath, routeDefsBaseFilename));
+
+      // getting generated from input params
+      const euiVersionNumber = euiVersion.split('.')[0];
+      const envTargetFinal = getEnvTarget(envTarget, build);
+
+
+      // getting the input file definitions of routes for replacements
+      // from tokenized template in config -- allowing to control playground vs normal env (when using the MWP HOST for release)
+      // format :
+      //    playground : "routesFilenameTemplate": "route-defs-base-v@eui.version@-playground.json"
+      //    host : "routesFilenameTemplate": "route-defs.@env.target@.json"
+
+      let routeDefsInputFilename;
+
+      if (!project.externalRoutesSources.routesFilenameTemplate) {
+        throw 'ROUTES_CONFIG_V2_TEMPLATE_NOT_FOUND';
+      }
+
+      routeDefsInputFilename = project.externalRoutesSources.routesFilenameTemplate.replace('@eui.version@', euiVersionNumber);
+      routeDefsInputFilename = routeDefsInputFilename.replace('@env.target@', envTargetFinal);
+
+      tools.logInfo(`Starting replacement of routes based on generated template : ${routeDefsInputFilename}`);
+
+
+
+      // Getting input routeDefs entry
+
+      const routeDefsInputPath = path.join(projectAssetsPath, routeDefsInputFilename);
+
+      if (!tools.isFileExists(routeDefsInputPath)) {
+        tools.logError(`${routeDefsInputPath} File NOT FOUND`);
+        throw 'ROUTE_DEFS_INPUT_FILE_NOT_FOUND';
+      }
+
+      const routeDefsInputJSON = require(path.join(routeDefsInputPath));
+
+      const appRoutes = [], appFeatureLibs = [];
+
+      routeDefsInputJSON.forEach((route) => {
+        tools.logInfo(`Processing route : ${route.path}`);
+
+        const defRoute = routeDefsBaseJSON.filter(r => r.path === route.path)[0];
+        if (!defRoute) {
+          tools.logError('==>route not found');
+
+        } else {
+          let loadChildrenGenerated;
+
+          if (route.lazy) {
+            const scopeName = defRoute.lazyLoadDef.npmPkg.split('/')[0].substr(1);
+            const pkgName = defRoute.lazyLoadDef.npmPkg.split('/')[1];
+            const lazyFeatureLibName = `${scopeName}-${pkgName}-${defRoute.lazyLoadDef.moduleName}.lib.module`;
+
+            if (euiVersion === '10.x') {
+              loadChildrenGenerated = `loadChildren: "./features/${lazyFeatureLibName}#Module"`;
+            } else {
+              loadChildrenGenerated = `loadChildren: () => import("./features/${lazyFeatureLibName}").then(m => m.Module)`;
+            }
+
+            appFeatureLibs.push({
+              filename: `${lazyFeatureLibName}.ts`,
+              npmPkg: defRoute.lazyLoadDef.npmPkg,
+              moduleName: defRoute.lazyLoadDef.moduleName
+            });
+
+          } else {
+            if (euiVersion === '10.x') {
+              loadChildrenGenerated = 'loadChildren: "./features/element-loader.module#ElementLoaderModule"';
+            } else {
+              loadChildrenGenerated = 'loadChildren: () => import("./features/element-loader.module").then(m => m.ElementLoaderModule)';
+            }
+          }
+
+          const newAppRoute = {
+            path: defRoute.path,
+            loadChildren: loadChildrenGenerated,
+            data: {}
+          };
+
+          if (defRoute.authMetadata) {
+            newAppRoute.data.id = defRoute.authMetadata.id;
+            newAppRoute.data.ids = defRoute.authMetadata.ids;
+            newAppRoute.canActivate = defRoute.authMetadata.canActivate;
+          }
+
+          if (route.remote) {
+            newAppRoute.data.featureName = defRoute.remoteDef.featureName;
+            newAppRoute.data.moduleId = defRoute.remoteDef.moduleId;
+            newAppRoute.data.elementTag = defRoute.remoteDef.elementTag;
+            newAppRoute.data.iframe = defRoute.remoteDef.iframe;
+          }
+
+          appRoutes.push(newAppRoute);
+        }
+      })
+
+
+      // processing creation of features lib modules entries
+
+      tools.logInfo('Processing creation of features lib modules entries');
+
+      appFeatureLibs.forEach((f) => {
+        const featureLibPath = path.join(process.cwd(), project.folder, 'src', 'app', 'features', f.filename);
+
+        const featureLibDef = `
+          import { NgModule } from '@angular/core';
+          import { ${f.moduleName} as LibModule } from '${f.npmPkg}';
+
+          @NgModule({
+              imports: [LibModule],
+              exports: [LibModule],
+          })
+          export class Module {
+          }
+        `;
+
+        tools.logInfo(`Creating lazy feature lib module : ${f.filename}`);
+
+        tools.writeFileContent(featureLibPath, featureLibDef);
+      });
+
+
+      // processing links generation
+
+      const routeDefsBaseLinksFileName = 'route-defs-base-links.json';
+      const routeDefsBaseLinksJSON = require(path.join(projectAssetsPath, routeDefsBaseLinksFileName));
+
+      tools.logInfo('Processing links generation');
+
+      const getRouteMenuDef = (link) => {
+        let routeDef = null;
+
+        if (link.url) {
+          routeDefsBaseJSON.forEach((r) => {
+            if (r.menuLinkDefs && r.menuLinkDefs.length > 0) {
+              r.menuLinkDefs.forEach((md) => {
+                if (md.url === link.url) {
+                  routeDef = md;
+                  return;
+                }
+              });
+            }
+          });
+        }
+
+        return routeDef;
+      }
+
+      const isLinkAllowed = (link) => {
+        // allow all link for playground - local env
+        if (envTargetFinal.indexOf('local') > -1) {
+          return true;
+        }
+
+        // checking if current envTarget generated is allowed
+        if (link.allowedEnvs) {
+          if (link.allowedEnvs.includes(envTargetFinal)) {
+            return true;
+          } else {
+            return false;
+          }
+        } else {
+          return true;
+        }
+      }
+
+      const linksGenerated = [];
+
+      routeDefsBaseLinksJSON.forEach((link) => {
+        let newLink;
+
+        if (link.parentId) {
+          if (isLinkAllowed(link)) {
+            newLink = { ...link};
+            newLink.children = [];
+
+            link.children.forEach((subLink) => {
+              if (isLinkAllowed(subLink)) {
+                const defRoute = getRouteMenuDef(subLink);
+
+                if (defRoute) {
+                  newLink.children.push(defRoute);
+                }
+              }
+            })
+          }
+
+        } else {
+          if (isLinkAllowed(link)) {
+            const defRoute = getRouteMenuDef(link);
+
+            if (defRoute) {
+              newLink = defRoute;
+            } else {
+              newLink = link;
+            }
+          }
+        }
+
+        if (newLink) {
+          linksGenerated.push(newLink);
+        }
+
+        if (debug) {
+          console.log('Links generated');
+          console.log(JSON.stringify(linksGenerated));
+        }
+      });
+
+      tools.logInfo(`Links generated : ${linksGenerated.length} found`);
+
+      tools.writeJsonFileSync(path.join(projectAssetsPath, 'route-defs-links.json'), linksGenerated);
+
+
+      // getting routes content for replacement
+
+      tools.logInfo('Processing routes replacement');
+
+      let placeHolderContent = '';
+
+      appRoutes.forEach((route) => {
+        placeHolderContent += replaceRouteV2(route);
+      });
+
+      const placeHolderToken = '// routes-placeholder';
+      routesFileContent = tools.replaceAll(routesFileContent, placeHolderToken, placeHolderContent);
+
+      if (debug) {
+        tools.logInfo('Routes file content replaced : ');
+        console.log(routesFileContent);
+      }
+
+      return routesFileContent;
+    })
+
+    .catch((e) => {
+      throw e;
+    })
+}
+
+
+
+
+const injectRoutesConfig = (project, npmPkg) => {
+  // check if package is locally cloned
+  const localPackage = configUtils.packages.getPackages().filter((p) => {
+    return p.npmPkg === npmPkg
+  })[0];
+
+  var pkgAssetsPath;
+  const projectAssetsPath = path.join(process.cwd(), project.folder, 'src', 'assets');
+
+  // if local package is found
+  if (localPackage) {
+    pkgAssetsPath = path.join(process.cwd(), 'packages', localPackage.name, 'assets');
+
+  // if not sources are taken from the npm package def in node_modules
+  } else {
+    const npmPkgScope = npmPkg.substr(0, npmPkg.indexOf('/'));
+    const npmPkgName = npmPkg.substr(npmPkg.indexOf('/') + 1);
+    pkgAssetsPath = path.join(process.cwd(), 'node_modules', npmPkgScope, npmPkgName, 'assets');
+  }
+
+  if (!tools.isDirExists(pkgAssetsPath)) {
+    tools.logWarning(`Linked config pkg : ${npmPkg} cannot be found in node_modules`);
+    return;
+  }
+
+  const routesConfigPath = path.join(pkgAssetsPath, project.externalRoutesSources.routesConfigAssetsPath);
+
+  tools.logInfo(`${routesConfigPath} - injecting in ${projectAssetsPath}`);
+  tools.copydir(routesConfigPath, projectAssetsPath);
+}
+
+
+
+
 module.exports.buildRoutes = (project, envTarget, build) => {
   tools.logTitle('Starting routes replacement');
 
@@ -369,13 +674,9 @@ module.exports.buildRoutes = (project, envTarget, build) => {
 
   return Promise.resolve()
     .then(() => {
-      return getEnvConfig(project, envTarget, build);
-    })
-    .then((envConfig) => {
-      if (!envConfig) {
-        throw 'ENV_CONFIG_NOT_FOUND';
+      if (project.externalRoutesSources.routesConfigVersion === '2') {
+        return injectRoutesConfig(project, project.externalRoutesSources.routesConfigNpmPkg);
       }
-      config = envConfig;
     })
 
     .then(() => {
@@ -390,12 +691,17 @@ module.exports.buildRoutes = (project, envTarget, build) => {
     })
 
     .then(() => {
-      return replaceRoutes(project, envTarget, build, routesFileContent, euiVersion);
+      if (project.externalRoutesSources.routesConfigVersion === '2') {
+        return processRoutesConfigV2(project, envTarget, build, routesFileContent, euiVersion);
+      } else {
+        return replaceRoutes(project, envTarget, build, routesFileContent, euiVersion);
+      }
     })
 
     .then((finalRouteFileContent) => {
       return tools.writeFileContent(routesFile, finalRouteFileContent);
     })
+
     .then(() => {
       tools.logSuccess();
     })

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

@@ -45,9 +45,9 @@ module.exports.preBuild = (project, envTarget, build, configEnvTarget) => {
       if (project.build && project.build.compiledTranslations) {
         const scopes = project.build.translationScopes;
         if (scopes) {
-          return translationUtils.projects.generate(scopes);
+          return translationUtils.projects.generate(scopes, project);
         } else {
-          return translationUtils.projects.generate();
+          return translationUtils.projects.generate(null, project);
         }
       }
     })

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

@@ -13,11 +13,18 @@ const configUtils = require('../../../csdr/config/config-utils');
 const { dryRun, scopes } = tools.getArgs();
 
 
-module.exports.generate = (inputScopes = 'opsys,cc,mywp,sygma,gem,cotg,eac') => {
+module.exports.generate = (inputScopes = 'opsys,cc,mywp,sygma,gem,cotg,eac', project) => {
 
   tools.logTitle('Generating translations...');
 
-  const rootFolder = path.join(process.cwd(), configUtils.projects.getProject().folder);
+  let prj;
+  if (project) {
+    prj = project;
+  } else {
+    prj = configUtils.projects.getProject();
+  }
+
+  const rootFolder = path.join(process.cwd(), prj.folder);
   const rootSrcFolder = path.join(rootFolder,'src');
   const destFolder = path.join(rootSrcFolder, 'assets/i18n-compiled');
   const globalTranslationsFolder = path.join(rootSrcFolder, 'assets/i18n-global');