@eui/tools 6.1.8 → 6.2.1

package/.version.properties

@@ -1 +1 @@
-6.1.8
+6.2.1

package/CHANGELOG.md

@@ -1,3 +1,21 @@
+## 6.2.1 (2022-11-09)
+
+##### Chores
+
+* **other:**
+  * patch project fetch base deps - EUI-6448 [EUI-6448](https://webgate.ec.europa.eu/CITnet/jira/browse/EUI-6448)  ([578739c3](https://webgate.ec.europa.eu/CITnet/stash/scm/csdr/eui-tools.git/commits/578739c338a2b5521fb924cbdd0b4d25e9cbc4e3))
+
+* * *
+* * *
+## 6.2.0 (2022-11-09)
+
+##### New Features
+
+* **other:**
+  * virtual remote feature implementation - add remote build and serve script - remote root skeleton for 15.x - MWP-8946 [MWP-8946](https://webgate.ec.europa.eu/CITnet/jira/browse/MWP-8946)  ([784f9019](https://webgate.ec.europa.eu/CITnet/stash/scm/csdr/eui-tools.git/commits/784f90194305e6ecb9a4ffb1c0d4b74efaf363dd))
+
+* * *
+* * *
 ## 6.1.8 (2022-11-08)
 
 ##### Bug Fixes

package/bin/eui-scripts.js

@@ -13,11 +13,13 @@ const scriptIndex = args.findIndex(
     x === 'build-package-pr-scan' ||
     x === 'build-package-sub' ||
     x === 'build-element' ||
+    x === 'build-remote' ||
     x === 'build-deps' ||
     x === 'build-all' ||
     x === 'build-app' ||
     x === 'serve-app' ||
     x === 'serve-element' ||
+    x === 'serve-remote' ||
     x === 'serve-mock' ||
     x === 'start-symfony' ||
     x === 'a11y-app' ||
@@ -53,11 +55,13 @@ switch (script) {
     case 'build-package-pr-scan':
     case 'build-package-sub':
     case 'build-element':
+    case 'build-remote':
     case 'build-deps':
     case 'build-all':
     case 'build-app':
     case 'serve-app':
     case 'serve-element':
+    case 'serve-remote':
     case 'serve-mock':
     case 'start-symfony':
     case 'a11y-app':

package/bin/scripts/build-remote.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const tools = require('../../scripts/utils/tools');
+const configUtils = require('../../scripts/csdr/config/config-utils');
+const buildPackageUtils = require('../../scripts/utils/build/package/build-package-utils');
+
+Promise.resolve()
+  .then(() => {
+    const remote = configUtils.remotes.getRemote();
+    return buildPackageUtils.build(remote);
+  })
+  .then(() => {
+    tools.logSuccess();
+  })
+  .catch((e) => {
+    tools.logError('ERROR detected during build process');
+    console.error(e);
+    process.exit(1);
+  });
+

package/bin/scripts/serve-remote.js

@@ -0,0 +1,12 @@
+'use strict';
+
+const serveElementUtils = require('../../scripts/utils/serve/element');
+
+Promise.resolve()
+  .then(() => {
+    return serveElementUtils.serve(true);
+  })
+  .catch((e) => {
+    console.error(e);
+    process.exit(1);
+  });

package/package.json

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

package/scripts/csdr/config/angular.js

@@ -170,12 +170,16 @@ module.exports.registerAngularProjectDef = (project, build = false, element = fa
   // checking if root angular.json exists, create if not
   const file = path.join(process.cwd(), 'angular.json');
 
-  // getting the eUI version of the project
+  // getting the eUI version of the project and setting path
   let euiVersion;
+  let angularRootPath;
+
   if (element) {
     euiVersion = innerPackages.getRemoteEuiVersion(project);
+    angularRootPath = project.paths.root;
   } else {
     euiVersion = innerProjects.getProjectEuiVersion(project);
+    angularRootPath = project.paths.angularPath;
   }
 
 
@@ -188,9 +192,9 @@ module.exports.registerAngularProjectDef = (project, build = false, element = fa
   // injecting angular project definition
   let angularConfigFile;
 
-  if (tools.isFileExists(path.join(project.paths.angularPath, 'angular-config.json'))) {
+  if (tools.isFileExists(path.join(angularRootPath, 'angular-config.json'))) {
     tools.logInfo(`Registering project angular config...`);
-    const angularConfigFilePath = path.join(project.paths.angularPath, 'angular-config.json');
+    const angularConfigFilePath = path.join(angularRootPath, 'angular-config.json');
     delete require.cache[angularConfigFilePath];
     angularConfigFile = require(angularConfigFilePath);
   }

package/scripts/csdr/config/config-utils.js

@@ -7,3 +7,4 @@ module.exports.packages = require('./packages');
 module.exports.projects = require('./projects');
 module.exports.init = require('./init');
 module.exports.sync = require('./sync');
+module.exports.remotes = require('./remotes');

package/scripts/csdr/config/packages.js

@@ -190,6 +190,7 @@ module.exports.getPackagePaths = (pkg) => {
     remoteNodeModules: remoteNodeModules,
     packages: resolvePath(packagesBasePath),
     root: resolvePath(packagesPath + '/' + folder),
+    fromRoot: packagesPath + '/' + folder,
     dist: resolvePath(packagesPath + '/' + folder + '/dist'),
     publish: resolvePath(packagesPath + '/' + folder + publishFolder),
     src: resolvePath(packagesPath + '/' + folder + '/src'),
@@ -316,7 +317,7 @@ module.exports.getDepGraph = () => {
 const getEuiVersionCore = (pkg) => {
   let version;
 
-  const depsCompositeFile = path.join(pkg.paths.pkgRootDirectory, 'dependencies-composite.json');
+  const depsCompositeFile = path.join(pkg.paths.root, 'dependencies-composite.json');
   tools.logInfo(`---- Try fetching version from ${depsCompositeFile}`);
 
   if (!tools.isFileExists(depsCompositeFile)) {

package/scripts/csdr/config/remotes.js

@@ -0,0 +1,76 @@
+'use strict';
+
+// GLOBAL
+const path = require('path');
+
+// LOCAL
+const tools = require('../../utils/tools');
+
+module.exports.getRemote = (remoteName, euiVersion) => {
+
+  if (!remoteName) {
+    remoteName = tools.getArgs().root;
+  }
+
+  if (!euiVersion) {
+    euiVersion = tools.getArgs().euiVersion;
+  }
+
+  tools.logTitle(`Getting remote config for ${remoteName} version ${euiVersion}`);
+
+  if (!euiVersion) {
+    throw new error('euiVersion should be provided as parameter');
+  }
+
+  const remotesConfig = require(path.join(process.cwd(), '.csdr', '.euirc-csdr-remotes.json'));
+  const remoteConfig = remotesConfig[remoteName];
+
+  if (!remoteConfig.supportedVersions && !remoteConfig.supportedVersions.includes(euiVersion)) {
+    throw new Error(`Version ${euiVersion} cannot be found in the global config of ${remoteName}`);
+
+  } else {
+    tools.logInfo('Global config found');
+    console.log(remoteConfig);
+  }
+
+  const remotePath = path.join(process.cwd(), 'packages', 'csdr-remotes-config', 'assets', remoteName, euiVersion);
+
+  tools.logInfo(`Getting remote information from ${remotePath}`);
+
+  if (!tools.isDirExists(remotePath)) {
+    throw new Error(`Remote ${remoteName} cannot be found in the remotes config global `);
+  }
+
+
+  const euiVersionNumber = euiVersion.split('.')[0];
+
+  const fullName = `${remoteName}-eui${euiVersionNumber}`;
+  const remoteRootPath = path.join(process.cwd(), 'remotes', fullName);
+
+  const remote = {
+    name: remoteName,
+    version: euiVersion,
+    fullName: fullName,
+    element: true,
+    remote: true,
+    virtual: true,
+    angularConfig: tools.getJsonFileContent(path.join(remotePath, 'angular-config.json')),
+    dependencies: tools.getJsonFileContent(path.join(remotePath, 'dependencies.json')),
+    paths: {
+      root: remoteRootPath,
+      fromRoot: `remotes/${fullName}`,
+      repoNodeModules: path.join(remoteRootPath, 'node_modules'),
+    },
+    devopsMetadataFile: `${fullName}-build-metadata.json`,
+    devopsVersionsMetadataFile: `${fullName}-versions-metadata.json`,
+    devopsHistoryMetadataFile: `${fullName}-history-metadata.json`,
+    devopsEnvsMetadataFile: `${fullName}-envs-metadata.json`,
+    ...remoteConfig,
+  }
+
+  if (!remote.dependencies.composite) {
+    throw new Error('The remote config does not contains the manadatory "composite" dependencies');
+  }
+
+  return remote;
+}

package/scripts/csdr/init/init.js

@@ -8,22 +8,25 @@ const configUtils = require('../config/config-utils');
 // Getting arguments if they are provided for the CI/CD pipeline
 const {
   project, team, pkg, branch, configOnly, skipClone, skipInstall, reset, pkgOnly, prjOnly,
-  build, containerOnly, skipAppContainers
+  build, containerOnly, skipAppContainers, remote, euiVersion, remoteOnly
 } = tools.getArgs();
 
 
 module.exports.init = () => {
   // Initializing a common response
   const initialResponse = {
-    project: project,
+    project: project || null,
     team: team || 'all',
     pkg: pkg || null,
+    remote: remote || null,
+    euiVersion: euiVersion || null,
     branch: branch || 'develop',
     configOnly: configOnly || false,
     skipClone: skipClone || false,
     reset: reset || false,
-    pkgOnly: pkgOnly || false,
+    pkgOnly: pkgOnly || true,
     prjOnly: prjOnly || false,
+    remoteOnly: remoteOnly || true,
     build: build || false,
     containerOnly: containerOnly || false,
     skipAppContainers: skipAppContainers || false
@@ -47,7 +50,7 @@ module.exports.init = () => {
     .then(() => {
 
       // if no project has been provided we prompt for project and team selection
-      if (!project && !pkg) {
+      if (!project && !pkg && !remote) {
         return initUtils.prompt.start();
 
         // if provided, we are on automated mode, we use the initialized response
@@ -64,7 +67,9 @@ module.exports.init = () => {
     // Initializing .euirc.json local file - the core of CSDR operations
     .then(() => {
       // Initialize config
-      return configUtils.init.run(finalResponse);
+      if (!remote) {
+        return configUtils.init.run(finalResponse);
+      }
     })
 
     // clone or install linked host package to project if any
@@ -79,19 +84,23 @@ module.exports.init = () => {
 
     // Initializing .meta based on .euirc.json for local respoisitories cloning
     .then(() => {
-      return initUtils.meta.init();
+      if (!remote) {
+        return initUtils.meta.init();
+      }
     })
 
     // Cloning repositories based on the .meta file generated
     .then(() => {
-      if (!skipClone) {
+      if (!skipClone && !remote) {
         return initUtils.repos.init(finalResponse);
       }
     })
 
     // Importing packages and generating definitions
     .then(() => {
-      return initUtils.packages.importPackages(finalResponse);
+      if (!remote) {
+        return initUtils.packages.importPackages(finalResponse);
+      }
     })
 
     // Importing external sources
@@ -101,12 +110,17 @@ module.exports.init = () => {
       }
     })
 
-    // Generating virtual remote - experimental TODO
-    // .then(() => {
-    //   if (finalResponse.pkg && finalResponse.pkgOnly) {
-    //     return initUtils.remotes.generateVirtualRemote(pkg);
-    //   }
-    // })
+    // Generating virtual remote - experimental
+    .then(() => {
+      if (finalResponse.remote) {
+        if (finalResponse.euiVersion) {
+          return initUtils.remotes.generateVirtualRemote(remote, euiVersion);
+        } else {
+          tools.logError('When a remote is initialized, an "euiVersion" parameter must be specified');
+          process.exit(1);
+        }
+      }
+    })
 
     // 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
@@ -124,8 +138,12 @@ module.exports.init = () => {
       // this is only executed for local dev installation,
       // in case of release the initialisation is managed by the application / package themselves
       if (!build && !skipInstall) {
-        if (finalResponse.pkgOnly) {
-          return installUtils.localDev.installPackage(pkg);
+        if (finalResponse.pkgOnly || finalResponse.remoteOnly) {
+          if (finalResponse.remote) {
+            return installUtils.localDev.installRemote(remote);
+          } else {
+            return installUtils.localDev.installPackage(pkg);
+          }
         } else {
           return installUtils.localDev.install();
         }

package/scripts/csdr/init/remotes/15.x/package.json

@@ -0,0 +1,8 @@
+{
+    "name": "generated",
+    "version": "1.0.0-SNAPSHOT.0",
+    "files": [
+        "bundles"
+    ],
+    "dependencies": {}
+}

package/scripts/csdr/init/remotes.js

@@ -6,16 +6,112 @@ const path = require('path');
 // LOCAL
 const tools = require('../../utils/tools');
 const configUtils = require('../config/config-utils');
+const gitUtils = require('../../utils/git-utils');
 
 
-module.exports.generateVirtualRemote = (pkgName) => {
-  const pkg = configUtils.packages.getPackage(pkgName, true);
 
-  if (!pkg.remote && !pkg.virtual) {
-    return;
-  }
+const cloneRemotesConfig = module.exports.cloneRemotesConfig = () => {
 
+  tools.logTitle('Cloning global remotes config');
+
+  let pkg;
+
+  return Promise.resolve()
+    .then(() => {
+      pkg = configUtils.packages.getPackageByNpmPkg('@csdr/remotes-config', true);
+      return gitUtils.cloneAndCheckout(pkg.repository, path.join(process.cwd(), 'packages', pkg.name), 'master');
+    })
+
+    .then(() => {
+      const newPackages = [];
+      newPackages.push(pkg.name);
+      return configUtils.global.updateConfig(null, newPackages);
+    })
+
+    .catch((e) => {
+      throw e;
+    })
+}
+
+
+
+module.exports.generateVirtualRemote = (remoteName, euiVersion) => {
   tools.logTitle('Generate virtual remote');
 
-  // TODO
+  return Promise.resolve()
+
+    // clone remotes config if first init
+    .then(() => {
+      return cloneRemotesConfig();
+    })
+
+    .then(() => {
+      // getting the remote config
+      const remote = configUtils.remotes.getRemote(remoteName, euiVersion);
+
+      if (!remote) {
+        throw new Error(`Remote ${remoteName} can't be found in the remotes CSDR configuration OR the remotes configs of the project`);
+      }
+
+      tools.logInfo('Remote config gathered:')
+      console.log(remote);
+
+      // constructing the remote folder
+      const remotePath = path.join(process.cwd(), 'remotes', remote.fullName);
+      const remoteSkeletonPath = path.join(__dirname, 'remotes', euiVersion);
+
+      tools.copy(remoteSkeletonPath, remotePath);
+
+      // adding the dependendies files
+      tools.writeJsonFileSync(path.join(remotePath, 'dependencies-composite.json'), remote.dependencies.composite);
+      if (remote.dependencies.base) {
+        tools.writeJsonFileSync(path.join(remotePath, 'dependencies-base.json'), remote.dependencies.base);
+      }
+
+      // adding dependencies per env
+      const envs = ['INT', 'ACC', 'DLT', 'TRN', 'PROD'];
+
+      envs.forEach((env) => {
+        if (remote.dependencies[env]) {
+          tools.writeJsonFileSync(path.join(remotePath, `dependencies-composite-${env}.json`), remote.dependencies[env]);
+        }
+      });
+
+      // generating angular json
+      const angularJsonPath = path.join(remotePath, 'angular.json');
+      let angularJson = tools.getJsonFileContent(angularJsonPath);
+
+      let angularContent = JSON.stringify(angularJson);
+      angularContent = angularContent.replace('@remote.name@',  remote.fullName);
+
+      angularJson = JSON.parse(angularContent);
+      angularJson.projects[remote.fullName].architect.build.options.styles = remote.angularConfig.styles;
+
+      if (remote.angularConfig.scripts) {
+        angularJson.projects[remote.fullName].architect.build.options.scripts = [
+          ...angularJson.projects[remote.fullName].architect.build.options.scripts,
+          ...remote.angularConfig.scripts
+        ];
+      }
+
+      tools.writeJsonFileSync(angularJsonPath, angularJson);
+
+      tools.logSuccess('OK => angular.json generated');
+
+
+      // generating package.json
+      const packageJsonPath = path.join(remotePath, 'package.json');
+      let packageJson = tools.getJsonFileContent(packageJsonPath);
+
+      packageJson.name = remote.npmPkg;
+
+      tools.writeJsonFileSync(packageJsonPath, packageJson);
+
+      tools.logSuccess('OK => package.json generated');
+    })
+
+
+    .catch((e) => {
+      throw e;
+    })
 }

package/scripts/csdr/install/local-dev.js

@@ -34,6 +34,24 @@ module.exports.installPackage = (pkgName) => {
 }
 
 
+module.exports.installRemote = (remoteName) => {
+
+  const remote = configUtils.remotes.getRemote(remoteName);
+
+  return Promise.resolve()
+    .then(() => {
+      return metadataUtils.common.cloneMetadataRepo(true);
+    })
+
+    .then(() => {
+      return innerRemotes.installDeps(remote);
+    })
+
+    .catch((e) => {
+      throw e;
+    })
+}
+
 
 module.exports.install = () => {
   let finalDeps = {}, resolvedDeps = {}, remoteDeps = {};

package/scripts/csdr/install/projects.js

@@ -154,7 +154,15 @@ module.exports.installDeps = (prj, envTarget, compositeType) => {
 
       // fetching extra dependencies on project
       const prjBaseJsonFile = path.join(process.cwd(), prj.folder, 'dependencies-base.json');
+
+      tools.logInfo(`Getting base dependencies from : ${prjBaseJsonFile}`);
+      console.log(tools.getJsonFileContent(prjBaseJsonFile));
+
       const prjBaseDeps = tools.getJsonFileContent(prjBaseJsonFile) || {};
+
+      tools.logInfo('Found base dependencies:');
+      console.log(prjBaseDeps);
+
       const fixedDeps = configUtils.global.getConfig().npm.fixedDependencies;
 
       return innerCommon.installDeps({ ...prjBaseDeps, ...compositeDeps, ...prjFixedDeps, ...fixedDeps });

package/scripts/csdr/install/remotes.js

@@ -62,7 +62,7 @@ const pkgInstall = (pkg, envTarget, compositeType) => {
       // getting base deps (3rd parties)
       let baseDeps = {}, deps;
 
-      const depsBaseJsonFile = path.join(pkg.paths.pkgRootDirectory, 'dependencies-base.json');
+      const depsBaseJsonFile = path.join(pkg.paths.root, 'dependencies-base.json');
       if (tools.isFileExists(depsBaseJsonFile)) {
         baseDeps = tools.getJsonFileContent(depsBaseJsonFile);
       }
@@ -71,7 +71,7 @@ const pkgInstall = (pkg, envTarget, compositeType) => {
       deps = { ...baseDeps, ...compositeDeps };
 
       // updating package json file before installation
-      const pkgJsonFile = path.resolve(pkg.paths.pkgRootDirectory, 'package.json');
+      const pkgJsonFile = path.resolve(pkg.paths.root, 'package.json');
       const pkgJson = require(pkgJsonFile);
 
       pkgJson.dependencies = deps;
@@ -87,7 +87,7 @@ const pkgInstall = (pkg, envTarget, compositeType) => {
           tools.logInfo('installing dependencies');
           console.log(pkgJson.dependencies);
 
-          return innerCommon.executeInstall(pkg.paths.pkgRootDirectory);
+          return innerCommon.executeInstall(pkg.paths.root);
 
         } else {
           tools.logWarning('No dependencies found to install');
@@ -107,7 +107,7 @@ const pkgInstall = (pkg, envTarget, compositeType) => {
     // reseting package.json
     .finally(() => {
       if (!dryRun) {
-        const pkgJsonFile = path.resolve(pkg.paths.pkgRootDirectory, 'package.json');
+        const pkgJsonFile = path.resolve(pkg.paths.root, 'package.json');
         const pkgJson = require(pkgJsonFile);
 
         pkgJson.dependencies = {};
@@ -126,7 +126,7 @@ const getDeps = module.exports.getDeps = (pkg, envTarget, compositeType) => {
     })
     .then((envsMetadata) => {
       return innerCompositeCore.getCompositeDeps(
-        pkg.paths.pkgFromRoot,
+        pkg.paths.fromRoot,
         envTarget,
         compositeType,
         pkg.build && pkg.build.prevSnapshotEnabled,

package/scripts/utils/build/package/element.js

@@ -21,10 +21,17 @@ module.exports.build = (pkg, isMaster) => {
 
   const remoteEuiVersion = configUtils.packages.getRemoteEuiVersion(pkg);
 
+  let pkgName;
+  if (pkg.remote && pkg.virtual) {
+    pkgName = pkg.fullName;
+  } else {
+    pkgName = pkg.name;
+  }
+
   return Promise.resolve()
 
   .then(() => {
-    tools.logTitle(`Building element : ${pkg.name}...`);
+    tools.logTitle(`Building element : ${pkgName}...`);
 
     // force skipLint and skipTest on element
     skipLint = true;
@@ -41,13 +48,13 @@ module.exports.build = (pkg, isMaster) => {
 
       const tslint = path.resolve(pkg.paths.repoNodeModules, 'tslint', 'bin', 'tslint');
 
-      const tsLintPath = path.join(pkg.paths.pkgRootDirectory, 'tslint.json');
-      const tsConfigPath = path.join(pkg.paths.pkgRootDirectory, 'tsconfig.app.json');
+      const tsLintPath = path.join(pkg.paths.root, 'tslint.json');
+      const tsConfigPath = path.join(pkg.paths.root, 'tsconfig.app.json');
       tools.logInfo(`running tslint -c ${tsLintPath} -p ${tsConfigPath}`);
       // return tools.runScript(`tslint -c ${tsLintPath} -p ${tsConfigPath}`);
 
       const args = [tslint, '-c', tsLintPath, '-p', tsConfigPath];
-      return execa('node', args, { cwd: pkg.paths.pkgRootDirectory, stdio: 'inherit' });
+      return execa('node', args, { cwd: pkg.paths.root, stdio: 'inherit' });
     }
   })
 
@@ -61,9 +68,9 @@ module.exports.build = (pkg, isMaster) => {
 
       // return tools.runScript(`stylelint ${pkg.paths.pkgRootDirectory}/src/app/**/*.scss`);
       const stylelint = path.resolve(pkg.paths.repoNodeModules, 'stylelint', 'bin', 'stylelint');
-      const args = [stylelint, `${pkg.paths.pkgRootDirectory}/src/app/**/*.scss`];
+      const args = [stylelint, `${pkg.paths.root}/src/app/**/*.scss`];
 
-      return execa('node', args, { cwd: pkg.paths.pkgRootDirectory, stdio: 'inherit' });
+      return execa('node', args, { cwd: pkg.paths.root, stdio: 'inherit' });
     }
   })
 
@@ -78,9 +85,9 @@ module.exports.build = (pkg, isMaster) => {
       let args;
 
       if (maxSpaceSize) {
-        args = ['--max_old_space_size=4096', ng, 'test', pkg.name];
+        args = ['--max_old_space_size=4096', ng, 'test', pkgName];
       } else {
-        args = [ng, 'test', pkg.name];
+        args = [ng, 'test', pkgName];
       }
 
       if (watch) {
@@ -94,10 +101,10 @@ module.exports.build = (pkg, isMaster) => {
       tools.logInfo(`ng test : watching = ${watch || false}`);
 
       tools.logInfo(`running Angular TEST with args: ${args} on`);
-      console.log(pkg.paths.pkgRootDirectory);
+      console.log(pkg.paths.root);
 
       if (!dryRun) {
-        return execa('node', args, { cwd: pkg.paths.pkgRootDirectory, stdio: 'inherit' });
+        return execa('node', args, { cwd: pkg.paths.root, stdio: 'inherit' });
       }
     }
   })
@@ -115,9 +122,9 @@ module.exports.build = (pkg, isMaster) => {
     let args;
 
     if (versionNumber <= 10) {
-      args = ['--max_old_space_size=8096', ng, 'build', pkg.name, '--prod'];
+      args = ['--max_old_space_size=8096', ng, 'build', pkgName, '--prod'];
     } else {
-      args = ['--max_old_space_size=8096', ng, 'build', pkg.name];
+      args = ['--max_old_space_size=8096', ng, 'build', pkgName];
     }
 
     if (statsJson) {
@@ -132,7 +139,7 @@ module.exports.build = (pkg, isMaster) => {
       args.push(`--base-href=${baseHref}`);
     }
 
-    const webpackExtraFile = path.join(pkg.paths.pkgRootDirectory, 'webpack.extra.js');
+    const webpackExtraFile = path.join(pkg.paths.root, 'webpack.extra.js');
     if (tools.isFileExists(webpackExtraFile)) {
       args.push(`--extra-webpack-config=${webpackExtraFile}`);
     }
@@ -156,10 +163,10 @@ module.exports.build = (pkg, isMaster) => {
     tools.logInfo(`ng build for configuration : ${configuration || 'production'}`);
 
     tools.logInfo(`running Angular BUILD with args: ${args} on`);
-    console.log(pkg.paths.pkgRootDirectory);
+    console.log(pkg.paths.root);
 
     if (!dryRun) {
-      return execa('node', args, { cwd: pkg.paths.pkgRootDirectory, stdio: 'inherit' });
+      return execa('node', args, { cwd: pkg.paths.root, stdio: 'inherit' });
     }
   })
 

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

@@ -279,7 +279,7 @@ module.exports.injectElementExternalSources = (pkg) => {
         })[0];
 
         let externalSourcesSrcPath;
-        const pkgSrcPath = path.join(pkg.paths.pkgRootDirectory, 'src');
+        const pkgSrcPath = path.join(pkg.paths.root, 'src');
 
         // if local package is found
         if (localPackage) {
@@ -292,7 +292,7 @@ module.exports.injectElementExternalSources = (pkg) => {
           const npmPkgScope = pkg.externalSources.npmPkg.substr(0, pkg.externalSources.npmPkg.indexOf('/'));
           const npmPkgName = pkg.externalSources.npmPkg.substr(pkg.externalSources.npmPkg.indexOf('/') + 1);
 
-          externalSourcesSrcPath = path.join(pkg.paths.pkgRootDirectory, 'node_modules', npmPkgScope, npmPkgName, pkg.externalSources.folder);
+          externalSourcesSrcPath = path.join(pkg.paths.root, 'node_modules', npmPkgScope, npmPkgName, pkg.externalSources.folder);
         }
 
         if (!tools.isDirExists(externalSourcesSrcPath)) {

package/scripts/utils/serve/element.js

@@ -10,11 +10,24 @@ const preBuildUtils = require('../pre-build/pre-build-utils');
 const configUtils = require('../../csdr/config/config-utils');
 
 
-module.exports.serve = () => {
+module.exports.serve = (remote = false) => {
 
   let { project, configuration, baseHref, host, proxyConfig, maxSpaceSize, port } = tools.getArgs();
 
-  const pkg = configUtils.packages.getPackage();
+  let pkg;
+  if (remote) {
+    pkg = configUtils.remotes.getRemote();
+  } else {
+    pkg = configUtils.packages.getPackage();
+  }
+
+  let pkgName;
+  if (pkg.remote && pkg.virtual) {
+    pkgName = pkg.fullName;
+  } else {
+    pkgName = pkg.name;
+  }
+
 
   const remoteEuiVersion = configUtils.packages.getRemoteEuiVersion(pkg);
 
@@ -30,7 +43,7 @@ module.exports.serve = () => {
 
   return Promise.resolve()
     .then(() => {
-      tools.logTitle(`Serving element : ${pkg.name}...`);
+      tools.logTitle(`Serving element : ${pkgName}...`);
     })
 
     .then(() => {
@@ -41,17 +54,17 @@ module.exports.serve = () => {
       var args;
 
       if (maxSpaceSize) {
-        args = ['--max_old_space_size=4096', ng, 'build', pkg.name];
+        args = ['--max_old_space_size=4096', ng, 'build', pkgName];
       } else {
-        args = [ng, 'build', pkg.name];
+        args = [ng, 'build', pkgName];
       }
 
       const projectConfig = configUtils.projects.getProject(project);
 
       if (projectConfig.host && projectConfig.virtual) {
-        destPath = path.join(process.cwd(), 'hosts', project, 'src', 'assets', 'elements', pkg.name, 'bundles');
+        destPath = path.join(process.cwd(), 'hosts', project, 'src', 'assets', 'elements', pkgName, 'bundles');
       } else {
-        destPath = path.join(process.cwd(), 'apps', project, 'src', 'assets', 'elements', pkg.name, 'bundles');
+        destPath = path.join(process.cwd(), 'apps', project, 'src', 'assets', 'elements', pkgName, 'bundles');
       }
 
       const versionNumber = remoteEuiVersion.split('.')[0];
@@ -70,7 +83,7 @@ module.exports.serve = () => {
         args.push(`--configuration=${configuration || 'production'}`);
       }
 
-      const webpackExtraFile = path.join(pkg.paths.pkgRootDirectory, 'webpack.extra.js');
+      const webpackExtraFile = path.join(pkg.paths.root, 'webpack.extra.js');
       if (tools.isFileExists(webpackExtraFile)) {
         args.push(`--extra-webpack-config=${webpackExtraFile}`);
       }
@@ -78,7 +91,7 @@ module.exports.serve = () => {
       tools.logInfo(`ng build with args ${args}`);
 
       const spawnSync = require('child_process').spawnSync;
-      const output = spawnSync('node', args, { cwd: pkg.paths.pkgRootDirectory, stdio: 'inherit' });
+      const output = spawnSync('node', args, { cwd: pkg.paths.root, stdio: 'inherit' });
 
       if (output.error) {
         throw new Error(JSON.stringify(output));