@eui/tools 5.3.90 → 6.1.1

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
+}

package/scripts/csdr/init/repos.js

@@ -5,6 +5,8 @@ const gitUtils = require('../../utils/git-utils');
 
 const innerMeta = require('./meta');
 
+const { skipEuiToolsClone } = tools.getArgs();
+
 
 const getRepos = (project, pkg, prjOnly, pkgOnly) => {
   const projects = innerMeta.getMetaProjects();
@@ -21,6 +23,8 @@ const getRepos = (project, pkg, prjOnly, pkgOnly) => {
   } else {
     if (prjOnly) {
       return repos.filter((i) => i.folder.indexOf(project) > -1);
+    } else if (skipEuiToolsClone) {
+      return repos.filter((i) => i.folder.indexOf('eui-tools') === -1);
     } else {
       return repos;
     }
@@ -67,37 +71,7 @@ const cloneAndCheckout = (repo, args) => {
 
   return Promise.resolve()
     .then(() => {
-      return gitUtils.cloneRepo(repo.uri, repo.folder);
-    })
-
-    .then(() => {
-      if (!tools.isDirExists(repo.folder)) {
-        return;
-      }
-
-      return Promise.resolve()
-        .then(() => {
-          return gitUtils.checkout(args.branch, repo.folder);
-        })
-        .catch((e) => {
-          tools.logError(`Branch ${args.branch} NOT FOUND, retrying on develop`);
-
-          return Promise.resolve()
-            .then(() => {
-              return gitUtils.checkout('develop', repo.folder);
-            })
-            .catch((e2) => {
-              tools.logError(`Branch develop NOT FOUND, retrying on master`);
-
-              return Promise.resolve()
-                .then(() => {
-                  return gitUtils.checkout('master', repo.folder);
-                })
-                .catch((e3) => {
-                  throw e3;
-                })
-            })
-        })
+      return gitUtils.cloneAndCheckout(repo.uri, repo.folder, args.branch);
     })
 
     .catch((e) => {

package/scripts/csdr/install/common.js

@@ -10,20 +10,34 @@ const configUtils = require('../config/config-utils');
 const metadataUtils = require('../metadata/metadata-utils');
 
 // FETCH ARGS
-const { dryRun, skipInstall, registry, remotesImport, skipLocalPackagesDeps } = tools.getArgs();
+const { dryRun, skipInstall, registry, skipLocalPackagesDeps } = tools.getArgs();
 
 
+const getInstallRegistry = () => {
+  const NPM_REGISTRY_INSTALL = configUtils.global.getConfigOptions().NPM_REGISTRY_INSTALL;
 
-const installDeps = (deps) => {
+  // check if registry has been passed as argument
+  var installRegistry;
+  if (registry) {
+    installRegistry = registry;
+  } else {
+    installRegistry = NPM_REGISTRY_INSTALL;
+  }
+
+  return installRegistry;
+}
+
+
+module.exports.installDeps = (deps) => {
 
   return Promise.resolve()
-    // Install dependencies
-    .then(() => {
-      tools.logTitle('Package dependencies to install : ');
+  // Install dependencies
+  .then(() => {
+    tools.logTitle('Package dependencies to install : ');
 
-      const rootFolder = process.cwd();
-      const pkgJsonFile = path.resolve(rootFolder, 'package.json');
-      const pkgJson = require(pkgJsonFile);
+    const rootFolder = process.cwd();
+    const pkgJsonFile = path.resolve(rootFolder, 'package.json');
+    const pkgJson = require(pkgJsonFile);
 
       pkgJson.dependencies = deps;
 
@@ -43,19 +57,10 @@ const installDeps = (deps) => {
 }
 
 
-const executeInstall = (cwdPath) => {
+const executeInstall = module.exports.executeInstall = (cwdPath) => {
   return Promise.resolve()
     .then(() => {
-      // getting the default installation registry
-      const NPM_REGISTRY_INSTALL = configUtils.global.getConfigOptions().NPM_REGISTRY_INSTALL;
-
-      // check if registry has been passed as argument
-      var installRegistry;
-      if (registry) {
-        installRegistry = registry;
-      } else {
-        installRegistry = NPM_REGISTRY_INSTALL;
-      }
+      const installRegistry = getInstallRegistry();
 
       tools.logInfo(`Install from : ${installRegistry}`);
       if (!dryRun && !skipInstall) {
@@ -69,7 +74,24 @@ const executeInstall = (cwdPath) => {
 }
 
 
-const getRemappedDeps = (pkgDeps, pkgDefaultDeps, isMaster) => {
+module.exports.executeInstallPackage = (cwdPath, npmPkg) => {
+  return Promise.resolve()
+  .then(() => {
+    const installRegistry = getInstallRegistry();
+
+    tools.logInfo(`Install ${npmPkg} from : ${installRegistry}`);
+    if (!dryRun && !skipInstall) {
+      return execa.shellSync(`yarn add ${npmPkg} --no-lockfile --registry ${installRegistry}`, { cwd: cwdPath, stdio: 'inherit' });
+    }
+  })
+
+  .catch((e) => {
+    throw e;
+  })
+}
+
+
+module.exports.getRemappedDeps = (pkgDeps, pkgDefaultDeps, isMaster) => {
   tools.logTitle('Remapping major version carret declared dependencies');
 
   return Promise.resolve()
@@ -128,7 +150,7 @@ const getRemappedDeps = (pkgDeps, pkgDefaultDeps, isMaster) => {
 
 
 
-const getResolvedCarretDeps = (deps, isMaster) => {
+const getResolvedCarretDeps = module.exports.getResolvedCarretDeps = (deps, isMaster) => {
   tools.logTitle('Resolving carret versions for prev or next version packages');
 
   tools.logInfo('processing dependencies : ');
@@ -173,367 +195,3 @@ const getResolvedCarretDeps = (deps, isMaster) => {
     })
 }
 
-
-
-
-const getLocalPackageDeps = (pkg) => {
-  let pkgJsonFile;
-
-  if (pkg.parent) {
-    return {};
-  } else {
-    if (pkg.child) {
-      pkgJsonFile = path.join(process.cwd(), 'packages', pkg.parentPkg, 'packages', pkg.folder || pkg.name, 'package.json');
-    } else {
-      pkgJsonFile = path.join(process.cwd(), 'packages', pkg.name, 'package.json');
-    }
-  }
-
-  return tools.getJsonFileContent(pkgJsonFile).dependencies || {};
-}
-
-
-const getLocalPackagesDeps = () => {
-  const packages = configUtils.packages.getPackages();
-  let deps = {};
-
-  packages.forEach(p => {
-    const pkgDeps = getLocalPackageDeps(p);
-
-    tools.logInfo(`Getting local dependencies for ${p.name}`);
-    console.log(JSON.stringify(pkgDeps, null, 2));
-
-    const pdeps = Object.keys(pkgDeps)
-      .reduce((acc, k) => {
-        if (k.indexOf('@eui') !== -1 ) {
-          if (k.indexOf('@eui/ecl') !== -1 ||
-              k.indexOf('@eui/styles-base') !== -1
-          ) {
-            acc[k] = pkgDeps[k];
-          }
-        } else {
-          acc[k] = pkgDeps[k];
-        }
-        return acc;
-      }, {});
-
-    deps = { ...deps, ...pdeps };
-  })
-
-  return deps;
-}
-
-
-const getLocalPackageCompositeDeps = (pkg) => {
-  let pkgJsonFile;
-
-  if (!skipLocalPackagesDeps) {
-    if (pkg.child) {
-      pkgJsonFile = path.join(process.cwd(), 'packages', pkg.parentPkg, 'packages', pkg.folder || pkg.name, 'dependencies-composite.json');
-    } else {
-      pkgJsonFile = path.join(process.cwd(), 'packages', pkg.name, 'dependencies-composite.json');
-    }
-
-    if (tools.isFileExists(pkgJsonFile)) {
-      tools.logInfo(`found ${pkgJsonFile}, parsing...`);
-    }
-
-    return tools.getJsonFileContent(pkgJsonFile) || {};
-
-  } else {
-    tools.logInfo('Skipping gathering local packages composite deps');
-
-    return {};
-  }
-}
-
-
-const getLocalPackagesCompositeDeps = () => {
-  tools.logTitle('Parsing composite deps for local packages');
-
-  let deps = {};
-
-  // getting locally mounted packages, don't take into account remotely installed packages (elements remote)
-  const packages = configUtils.packages.getPackages().filter((p) => {
-    return !p.paths.remoteNodeModules;
-  });
-
-  packages.forEach(p => {
-    tools.logInfo(`Parsing package : ${p.name}`);
-
-    // getting the package composite if any
-    const compositeDeps = getLocalPackageCompositeDeps(p);
-
-    deps = { ...deps, ...compositeDeps };
-
-    tools.logInfo('Deps found : ');
-    console.log(deps);
-  })
-
-  return deps;
-}
-
-
-const getLocalPackageBaseDeps = (pkg) => {
-  let pkgJsonFile;
-
-  if (!skipLocalPackagesDeps) {
-    if (pkg.child) {
-      pkgJsonFile = path.join(process.cwd(), 'packages', pkg.parentPkg, 'packages', pkg.folder || pkg.name, 'dependencies-base.json');
-    } else {
-      pkgJsonFile = path.join(process.cwd(), 'packages', pkg.name, 'dependencies-base.json');
-    }
-
-    if (tools.isFileExists(pkgJsonFile)) {
-      tools.logInfo(`found ${pkgJsonFile}, parsing...`);
-    }
-
-    return tools.getJsonFileContent(pkgJsonFile) || {};
-
-  } else {
-    tools.logInfo('Skipping gathering local packages base deps');
-
-    return {};
-  }
-}
-
-
-
-const getLocalPackagesBaseDeps = () => {
-  tools.logTitle('Parsing base deps for local packages');
-
-  let deps = {};
-
-  // getting locally mounted packages, don't take into account remotely installed packages (elements remote)
-  const packages = configUtils.packages.getPackages().filter((p) => {
-    return !p.paths.remoteNodeModules;
-  });
-
-  packages.forEach(p => {
-    tools.logInfo(`Parsing package : ${p.name}`);
-
-    // getting the package base if any
-    const baseDeps = getLocalPackageBaseDeps(p);
-
-    deps = { ...deps, ...baseDeps };
-
-    tools.logInfo('Deps found : ');
-    console.log(deps);
-  })
-
-  return deps;
-}
-
-
-const getLocalPackagesCompositeDepsRemapped = () => {
-  return Promise.resolve()
-    .then(() => {
-      return metadataUtils.package.getPackagesDeps('packages');
-    })
-
-    .then((depsMetadata) => {
-      const compositeDeps = getLocalPackagesCompositeDeps();
-
-      return getRemappedDeps(depsMetadata, compositeDeps, false);
-    })
-
-    .then((remappedDeps) => {
-      tools.logInfo('Remapped deps : ');
-
-      console.log(remappedDeps);
-
-      return remappedDeps;
-    })
-
-    .catch((e) => {
-      throw e;
-    })
-}
-
-
-const getLocalProjectDeps = (prj, snapshotsMetadata) => {
-  tools.logInfo(`Getting deps for ${prj.name}`);
-
-  // check dependencies file - default
-  const prjJsonFile = path.join(process.cwd(), prj.folder, 'dependencies-base.json');
-  const prjDeps = tools.getJsonFileContent(prjJsonFile) || {};
-
-  // check dependencies composite file - default
-  const prjCompJsonFile = path.join(process.cwd(), prj.folder, 'dependencies-composite.json');
-
-  const depsJson = tools.getJsonFileContent(prjCompJsonFile);
-  let prjCompDeps;
-  if (depsJson.dependencies) {
-    prjCompDeps = depsJson.dependencies || {};
-  } else {
-    prjCompDeps = depsJson || {}
-  }
-
-  let remoteDeps = {};
-  if (prj.initRemoteDependencies && remotesImport && snapshotsMetadata) {
-
-    tools.logInfo('Importing remotes deps... this might take a while');
-
-    const remotes = configUtils.packages.getCsdrRemotePackages()
-      .filter((p) => {
-        return p.active === true
-      })
-      .map((p) => {
-        return { npmgPkg: p.npmPkg, version: snapshotsMetadata[p.npmPkg] }
-      })
-      .filter((dep) => {
-        return dep.version !== undefined
-      })
-
-    remotes.forEach((r) => {
-      remoteDeps[r.npmgPkg] = r.version;
-    });
-  }
-
-  return { ...prjDeps, ...prjCompDeps, ...remoteDeps };
-}
-
-
-const getLocalProjectsDeps = (snapshotsMetadata) => {
-  tools.logTitle('Getting project dependencies');
-
-  const projects = configUtils.projects.getProjects();
-  let deps = {};
-
-  projects.forEach(p => {
-    if (p) {
-      const prjDeps = getLocalProjectDeps(p, snapshotsMetadata);
-      deps = { ...deps, ...prjDeps };
-    }
-  })
-
-  return deps;
-}
-
-
-const getLocalProjectFixedDeps = (prj) => {
-  tools.logTitle('Getting project fixed dependencies - not part of the composite');
-
-  return Promise.resolve()
-    .then(() => {
-      return metadataUtils.package.getPackagesDeps('packages');
-    })
-
-    // extracting the fixed deps versions from metadata
-    .then((pkgDeps) => {
-      let deps = {};
-
-      if (prj.fixedDependencies) {
-        tools.logInfo('Project fixed dependencies found...processing');
-        console.log(prj.fixedDependencies);
-
-        prj.fixedDependencies.forEach((dep) => {
-          const newDep = { [dep]: pkgDeps[dep] };
-          deps = { ...deps, ...newDep }
-        })
-      }
-
-      tools.logInfo('Project fixed dependencies remapped : ');
-      console.log(deps);
-
-      return deps;
-    })
-
-    .catch((e) => {
-      throw e;
-    })
-}
-
-
-const getLocalProjectsFixedDeps = async _ => {
-  const projects = configUtils.projects.getProjects();
-  let deps = {};
-
-  const promises = projects.map(async prj => {
-    const prjDeps = await getLocalProjectFixedDeps(prj)
-    deps = { ...deps, ...prjDeps};
-    return deps;
-  })
-
-  await Promise.all(promises);
-  return deps;
-}
-
-
-const importLocalProjectRemotes = (prj, deps) => {
-  if (prj.initRemoteDependencies) {
-    tools.logInfo(`Import remotes for project : ${prj.name}`);
-
-    const remoteDeps = Object.keys(deps).filter((dep) => {
-      return dep.indexOf('remote-el') !== -1;
-    })
-
-    if (remoteDeps.length === 0) {
-      tools.logWarning('Remotes not found...skipping');
-
-    } else {
-      tools.logInfo(`Initializing ${remoteDeps.length} remotes`);
-
-      remoteDeps.forEach((remoteNpmPkg) => {
-        tools.logInfo(`Checking import for : ${remoteNpmPkg}`);
-
-        // check if package has been installed locally
-        const localPackage = configUtils.packages.getPackages().filter((p) => {
-          return p.npmPkg === remoteNpmPkg
-        })[0];
-
-        if (localPackage) {
-          tools.logInfo('remote is installed locally...skipping import');
-
-        } else {
-          const pkg = configUtils.packages.getPackageByNpmPkg(remoteNpmPkg, true);
-          const projectElementsPath = path.join(process.cwd(), prj.folder, 'src', 'assets', 'elements', pkg.name, 'bundles');
-
-          const npmPkgScope = remoteNpmPkg.substr(0, remoteNpmPkg.indexOf('/'));
-          const npmPkgName = remoteNpmPkg.substr(remoteNpmPkg.indexOf('/') + 1);
-          const remoteNmPath = path.join(process.cwd(), 'node_modules', npmPkgScope, npmPkgName, 'bundles');
-
-          tools.logInfo(`${remoteNpmPkg} - injecting in ${projectElementsPath}`);
-          tools.copydir(remoteNmPath, projectElementsPath);
-        }
-
-      });
-    }
-  }
-}
-
-
-const importLocalProjectsRemotes = (deps) => {
-  const projects = configUtils.projects.getProjects();
-
-  tools.logTitle('Importing local projects remotes');
-
-  if (remotesImport) {
-    projects.forEach(p => {
-      if (p) {
-        importLocalProjectRemotes(p, deps);
-      }
-    })
-  }
-}
-
-
-
-module.exports = {
-  installDeps,
-  executeInstall,
-  getRemappedDeps,
-  getLocalPackageDeps,
-  getLocalPackagesDeps,
-  getLocalPackageCompositeDeps,
-  getLocalPackagesCompositeDeps,
-  getLocalPackagesCompositeDepsRemapped,
-  getLocalPackageBaseDeps,
-  getLocalPackagesBaseDeps,
-  getLocalProjectDeps,
-  getLocalProjectsDeps,
-  getLocalProjectFixedDeps,
-  getLocalProjectsFixedDeps,
-  importLocalProjectRemotes,
-  importLocalProjectsRemotes
-}