@eui/tools 5.0.0-rc.1 → 5.0.0-rc.13

package/scripts/csdr/init/resources/13.x/browserslistrc

@@ -0,0 +1,6 @@
+last 1 Chrome version
+last 1 Firefox version
+last 2 Edge major versions
+last 2 Safari major versions
+last 2 iOS major versions
+Firefox ESR

package/scripts/csdr/init/resources/13.x/resolutions.json

@@ -0,0 +1,6 @@
+{
+    "@types/node": ">=14.14.10",
+    "https-proxy-agent": ">=2.2.3",
+    "mem": ">=4.3.0 <=8.1.1",
+    "isbinaryfile": "4.0.8"
+}

package/scripts/csdr/init/resources/14.x/browserslistrc

@@ -0,0 +1,6 @@
+last 1 Chrome version
+last 1 Firefox version
+last 2 Edge major versions
+last 2 Safari major versions
+last 2 iOS major versions
+Firefox ESR

package/scripts/csdr/init/resources/14.x/resolutions.json

@@ -0,0 +1,5 @@
+{
+    "@types/node": ">=14.14.10",
+    "https-proxy-agent": ">=2.2.3",
+    "mem": ">=4.3.0 <=8.1.1"
+}

package/scripts/csdr/install/build-app.js

@@ -1,57 +1,25 @@
 'use strict';
 
-// GLOBAL
-const execa = require('execa');
-const path = require('path');
-
 // LOCAL
 const tools = require('../../utils/tools');
-const configUtils = require('../config/config-utils');
-const compositeUtils = require('./composite-utils');
-const metadataUtils = require('../metadata/metadata-utils');
 
 // INNER MODULES
-const innerCommon = require('./common');
-
-// FETCH ARGS
-const { dryRun, skipInstall } = tools.getArgs();
+const innerProjects = require('./projects');
 
 
 module.exports.install = (prj, envTarget, compositeType) => {
-  let finalDeps, compositeDeps;
-
   return Promise.resolve()
+    // checking remotes
     .then(() => {
-      return compositeUtils.getDeps(prj, envTarget, compositeType);
-    })
-    .then((deps) => {
-      // storing compositeDeps
-      compositeDeps = deps;
-    })
-
-    .then(() => {
-      return innerCommon.getLocalProjectFixedDeps(prj);
+      return innerProjects.installDeps(prj, envTarget, compositeType);
     })
 
-    .then((prjFixedDeps) => {
-      // storing for archiving
-      finalDeps = { ...compositeDeps, ...prjFixedDeps };
-
-      // fetching extra dependencies on project
-      const prjBaseJsonFile = path.join(process.cwd(), prj.folder, 'dependencies-base.json');
-      const prjBaseDeps = tools.getJsonFileContent(prjBaseJsonFile) || {};
-      const fixedDeps = configUtils.global.getConfig().npm.fixedDependencies;
-
-      return innerCommon.installDeps({ ...prjBaseDeps, ...compositeDeps, ...prjFixedDeps, ...fixedDeps });
-    })
-
-    .then(() => {
-      // returning only the composite deps found, only those will be stored in the metadata
-      return finalDeps;
+    // returning metadata dependencies
+    .then((deps) => {
+      return deps;
     })
 
     .catch((e) => {
       throw e;
     })
 }
-

package/scripts/csdr/install/build-package.js

@@ -1,186 +1,45 @@
 'use strict';
 
-// GLOBAL
-const path = require('path');
-const glob = require('glob');
-
 // LOCAL
 const tools = require('../../utils/tools');
-const configUtils = require('../config/config-utils');
-const compositeUtils = require('./composite-utils');
-const metadataUtils = require('../metadata/metadata-utils');
-const notificationUtils = require('../../utils/notification/notification-utils');
 
 // INNER MODULES
-const innerCommon = require('./common');
-const innerRemote = require('./remote');
+const innerPackages = require('./packages');
+const innerRemotes = require('./remotes');
+
 
 
-module.exports.install = (prj, pkg, isMaster) => {
-  let compositeDeps, localPkgDeps, localPkgCompositeDeps, pkgCompositeDeps;
 
+module.exports.installPackage = (prj, pkg) => {
   return Promise.resolve()
+    // checking remotes
     .then(() => {
-      // when package is built against an app (depends on this app deps defined)
-      // the composite deps of that app is returned (default to DEV target)
-      if (prj) {
-        return compositeUtils.getDeps(prj);
-
-      // when package is stand-alone, then we take only the deps from within the package.json
-      } else {
-        return {};
-      }
+      return innerPackages.installDeps(prj, pkg);
     })
 
+    // returning metadata dependencies
     .then((deps) => {
-      // storing
-      compositeDeps = deps;
-
-      tools.logInfo(`Found composite deps : `);
-      console.log(JSON.stringify(compositeDeps, null, 2));
-
-      // fetching package own deps
-      return innerCommon.getLocalPackagesDeps();
-    })
-
-
-    .then((localPkgDepsIn) => {
-      // storing
-      localPkgDeps = localPkgDepsIn;
-
-      tools.logInfo(`Found local packages deps : `);
-      console.log(JSON.stringify(localPkgDeps, null, 2));
-
-      // fetching local package composite
-      return innerCommon.getLocalPackagesCompositeDeps();
-    })
-
-    // Get last known working build dependencies from DEVOPS metadata, including snapshot releases
-    .then((localPkgCompositeDepsIn) => {
-      // storing
-      localPkgCompositeDeps = localPkgCompositeDepsIn;
-
-      return metadataUtils.package.getPackagesDeps('packages');
-    })
-
-    .then((depsMetadata) => {
-      return innerCommon.getRemappedDeps(depsMetadata, localPkgCompositeDeps);
+      return deps;
     })
 
-    .then((remappedLocalPkgCompositeDeps) => {
-      // fetching extra dependencies on project if any
-      let prjDeps = {};
-
-      if (prj) {
-        const prjJsonFile = path.join(process.cwd(), prj.folder, 'dependencies-base.json');
-        prjDeps = tools.getJsonFileContent(prjJsonFile) || {};
-      }
-
-      const fixedDeps = configUtils.global.getConfig().npm.fixedDependencies;
-
-      if (pkg.build && pkg.build.ownDepsOnly) {
-        return innerCommon.installDeps({ ...remappedLocalPkgCompositeDeps, ...localPkgDeps, ...fixedDeps});
-
-      } else {
-        return innerCommon.installDeps({ ...remappedLocalPkgCompositeDeps, ...localPkgDeps, ...prjDeps, ...compositeDeps, ...fixedDeps });
-      }
+    .catch((e) => {
+      throw e;
     })
+}
 
+module.exports.installRemote = (pkg, envTarget, compositeType) => {
+  return Promise.resolve()
     // checking remotes
     .then(() => {
-      return innerRemote.installDeps(null, isMaster);
+      return innerRemotes.installDeps(pkg, envTarget, compositeType);
     })
 
     // returning metadata dependencies
-    .then((remoteDeps) => {
-      return remoteDeps;
+    .then((deps) => {
+      return deps;
     })
 
     .catch((e) => {
       throw e;
     })
 }
-
-
-
-
-
-
-module.exports.checkDeps = (pkg) => {
-  tools.logTitle('Checking package internal dependencies');
-
-  return Promise.resolve()
-   .then(() => {
-     var depsFound = [];
-     var files = glob.sync('**/*.ts', { cwd: pkg.paths.pkgLibFolder, nodir: true, follow: true, dot: true });
-     files.forEach(file => {
-       const filePath = path.join(pkg.paths.pkgLibFolder, file);
-       const fileContent = tools.getFileContent(filePath);
-       var regex = /@cc\/|@mywp\/|@opsys\/|@sfc\//gi, result, indices = [];
-       while ( (result = regex.exec(fileContent)) ) {
-           indices.push(result.index);
-       }
-       if (indices.length !== 0) {
-         // tools.logInfo(`Number of occurences found : ${indices.length}`);
-         indices.forEach((i) => {
-           const endPos = fileContent.substr(i, 40).indexOf("'");
-           const dep = fileContent.substr(i, endPos);
-           if (endPos > -1) {
-             // tools.logInfo(`dep found on : ${dep}`);
-             depsFound.push(dep);
-
-           } else {
-             tools.logInfo(`Potential wrong import detected on file : ${file}`);
-             const subContent = fileContent.substr(i, 40);
-             const detectMultiSlashes = subContent.match(/\//g);
-             if (detectMultiSlashes.length > 0) {
-               tools.logError('Multislashes on import : ');
-               console.log(subContent);
-             }
-           }
-         })
-       }
-     });
-     depsFound = tools.removeArrayDuplicates(depsFound);
-     tools.logWarning(`Dependencies found : ${depsFound.length}`);
-     console.log(depsFound);
-
-     return depsFound;
-   })
-
-   .then((depsFound) => {
-     var depsLevel;
-
-     switch(true) {
-         case (depsFound.length === 1):
-           depsLevel = 'LOW (1)';
-           break;
-         case (depsFound.length > 1 && depsFound.length <= 3):
-           depsLevel = 'MEDIUM (between 1 and 3)';
-           break;
-         case (depsFound.length > 3 && depsFound.length <= 5):
-           depsLevel = 'HIGH (between 3 and 5)';
-           break;
-         case (depsFound.length > 5):
-           depsLevel = 'VERY HIGH (>5)';
-           break;
-         default:
-           depsLevel = 'NONE';
-     }
-
-     var message = `Internal dependencies detected : ${depsFound.length} - deps level: ${depsLevel}\n`;
-     message += depsFound.join('\n');
-
-
-     return notificationUtils.package.sendPackageMessage({
-      package: pkg,
-      text: message
-     });
-   })
-
-   .catch((e) => {
-     console.log(e);
-   })
-
- }
-

package/scripts/csdr/install/common.js

@@ -12,6 +12,8 @@ const metadataUtils = require('../metadata/metadata-utils');
 // FETCH ARGS
 const { dryRun, skipInstall, registry, npm } = tools.getArgs();
 
+
+
 const installDeps = (deps) => {
 
   return Promise.resolve()
@@ -70,7 +72,7 @@ const executeInstall = (cwdPath) => {
 }
 
 
-const getRemappedDeps = (pkgDeps, pkgDefaultDeps) => {
+const getRemappedDeps = (pkgDeps, pkgDefaultDeps, isMaster) => {
 
   return Promise.resolve()
     .then(() => {
@@ -112,7 +114,7 @@ const getRemappedDeps = (pkgDeps, pkgDefaultDeps) => {
     })
 
     .then((remappedDeps) => {
-      return getResolvedCarretDeps(remappedDeps);
+      return getResolvedCarretDeps(remappedDeps, isMaster);
     })
 
 
@@ -125,9 +127,12 @@ const getRemappedDeps = (pkgDeps, pkgDefaultDeps) => {
 
 
 
-const getResolvedCarretDeps = (deps) => {
+const getResolvedCarretDeps = (deps, isMaster) => {
   tools.logTitle('Resolving carret for next version packages');
 
+  tools.logInfo('processing dependencies : ');
+  console.log(deps);
+
   return Promise.resolve()
     .then(() => {
 
@@ -143,9 +148,10 @@ const getResolvedCarretDeps = (deps) => {
             const pkg =  configUtils.packages.getPackageByNpmPkg(npmPkg, true);
 
             // getting last major version from metadata history for pkg found
-            const lastMajorVersion = metadataUtils.package.getLastMajorVersion(pkg, version.substr(1).split('.')[0]);
+            const lastMajorVersion = metadataUtils.package.getLastMajorVersion(pkg, version.substr(1).split('.')[0], isMaster);
 
             if (lastMajorVersion) {
+              tools.logInfo(`--version found : ${lastMajorVersion}`);
               acc[k] = lastMajorVersion;
 
             } else {
@@ -199,7 +205,9 @@ const getLocalPackagesDeps = () => {
     const pdeps = Object.keys(pkgDeps)
       .reduce((acc, k) => {
         if (k.indexOf('@eui') !== -1 ) {
-          if (k.indexOf('@eui/ecl') !== -1) {
+          if (k.indexOf('@eui/ecl') !== -1 ||
+              k.indexOf('@eui/styles-base') !== -1
+          ) {
             acc[k] = pkgDeps[k];
           }
         } else {
@@ -218,14 +226,14 @@ const getLocalPackagesDeps = () => {
 const getLocalPackageCompositeDeps = (pkg) => {
   let pkgJsonFile;
 
-  if (pkg.parent) {
-    return {};
+  if (pkg.child) {
+    pkgJsonFile = path.join(process.cwd(), 'packages', pkg.parentPkg, 'packages', pkg.folder || pkg.name, 'dependencies-composite.json');
   } else {
-    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');
-    }
+    pkgJsonFile = path.join(process.cwd(), 'packages', pkg.name, 'dependencies-composite.json');
+  }
+
+  if (tools.isFileExists(pkgJsonFile)) {
+    tools.logInfo(`found ${pkgJsonFile}, parsing...`);
   }
 
   return tools.getJsonFileContent(pkgJsonFile) || {};
@@ -267,7 +275,7 @@ const getLocalPackagesCompositeDepsRemapped = () => {
     .then((depsMetadata) => {
       const compositeDeps = getLocalPackagesCompositeDeps();
 
-      return getRemappedDeps(depsMetadata, compositeDeps);
+      return getRemappedDeps(depsMetadata, compositeDeps, false);
     })
 
     .then((remappedDeps) => {

package/scripts/csdr/install/composite-core.js

@@ -0,0 +1,256 @@
+'use strict';
+
+// GLOBAL
+const path = require('path');
+
+// LOCAL
+const tools = require('../../utils/tools');
+const metadataUtils = require('../metadata/metadata-utils');
+
+// INNER MODULES
+const innerCommon = require('./common');
+
+
+
+
+const getDeps_DEV = (compositeDeps, prevSnapshotEnabled) => {
+  return Promise.resolve()
+    .then(() => {
+      if (prevSnapshotEnabled) {
+        tools.logInfo('project has prevSnapshot enabled, getting deps list from prevSnapshotsTag');
+        return metadataUtils.package.getPackagesDeps('packagesPrevSnapshotsTag');
+      } else {
+        tools.logInfo('getting project deps from snapshots metadata list');
+        return metadataUtils.package.getPackagesDeps('packages');
+      }
+    })
+
+    // Re-mapping the dependencies found against their max "carret" versions found in the base dependencies defs in the project
+    .then((metadataDeps) => {
+      return innerCommon.getRemappedDeps(metadataDeps, compositeDeps);
+    })
+
+    .catch((e) => {
+      throw e;
+    })
+}
+
+
+
+const getDeps_TST = (compositeDeps, prevSnapshotEnabled) => {
+  return Promise.resolve()
+    .then(() => {
+      if (prevSnapshotEnabled) {
+        tools.logInfo('project has prevSnapshot enabled, getting deps list from prevTag');
+        return metadataUtils.package.getPackagesDeps('packagesPrevTag');
+      } else {
+        tools.logInfo('getting project deps from packagesLatest metadata list');
+        return metadataUtils.package.getPackagesDeps('packagesLatestTag');
+      }
+    })
+
+    // Re-mapping the dependencies found against their max "carret" versions found in the base dependencies defs in the project
+    .then((metadataDeps) => {
+      return innerCommon.getRemappedDeps(metadataDeps, compositeDeps);
+    })
+
+    .catch((e) => {
+      throw e;
+    })
+}
+
+
+
+
+const getCompositeDepsByEnv = (compositePath, envTarget, compositeType, envsMetadata, prevEnv, currentEnv) => {
+
+  let prevEnvDeps = {}, currentEnvDeps = {};
+
+  if (envsMetadata[prevEnv]) {
+    prevEnvDeps = envsMetadata[prevEnv].dependencies;
+  } else {
+    throw new Error(`
+      ${prevEnv} dependencies not found for ${currentEnv} dependencies fetch, ensure that the project/remote has been delivered to a previous environment first
+    `);
+  }
+
+  if (envsMetadata[currentEnv]) {
+    currentEnvDeps = envsMetadata[currentEnv].dependencies;
+  }
+
+
+  // if default composite type then we iterate over all detected composite files by env
+  if (compositeType === 'DEFAULT') {
+    return Promise.resolve()
+    .then(() => {
+      tools.logTitle('Processing accumulated composites for ALL composite types');
+      const filesByEnv = tools.getFiles(compositePath).filter(f => f.startsWith(`dependencies-composite-${envTarget}` ));
+      var returnedDeps = {};
+
+      filesByEnv.forEach((f) => {
+        tools.logInfo(`Parsing : ${f}`);
+        const compositeFile = path.join(process.cwd(), compositePath, f);
+        const fileDeps = tools.getJsonFileContent(compositeFile).lockedDependencies || {};
+        console.log(JSON.stringify(fileDeps, null, 2));
+        returnedDeps = { ...returnedDeps, ...fileDeps};
+      });
+
+      return { ...prevEnvDeps, ...returnedDeps };
+    })
+    .catch((e) => {
+      throw e;
+    })
+
+  // if particular composite type is provided, the dependencies are taken only from this one
+  } else {
+    return Promise.resolve()
+    .then(() => {
+      tools.logTitle(`Processing dependencies for composite type : ${compositeType}`);
+      const compositeFile = path.join(process.cwd(), compositePath, `dependencies-composite-${envTarget}-${compositeType}.json`);
+      const fileDeps = tools.getJsonFileContent(compositeFile).lockedDependencies || {};
+      console.log(JSON.stringify(fileDeps, null, 2));
+      return { ...currentEnvDeps, ...fileDeps };
+    })
+    .catch((e) => {
+      throw e;
+    })
+  }
+}
+
+
+
+
+
+
+
+
+module.exports.getCompositeDeps = (
+  compositePath,
+  envTarget = 'DEV',
+  compositeType = 'DEFAULT',
+  prevSnapshotEnabled = false,
+  envsMetadata
+) => {
+
+  tools.logInfo(`Processing installation at : ${compositePath} for env: ${envTarget} - compositeType: ${compositeType}`);
+
+  return Promise.resolve()
+    // getting root composite - dependencies-composite.json content
+    .then(() => {
+      const compositeJsonFile = path.join(process.cwd(), compositePath, 'dependencies-composite.json');
+      return tools.getJsonFileContent(compositeJsonFile) || {};
+    })
+
+    // getting env specific composite with compositeType if provided
+    .then((compositeDeps) => {
+      /**
+      * For DEV target, we take the outermost known versions of the packages,
+      * including : SNAPSHOTS & LATEST
+      */
+      if (envTarget === 'DEV') {
+        return getDeps_DEV(compositeDeps, prevSnapshotEnabled);
+      }
+
+
+      /**
+      * For TST target, we take only the LATEST know versions of the packages,
+      * including : LATEST
+      */
+      if (envTarget === 'TST') {
+        return getDeps_TST(compositeDeps, prevSnapshotEnabled);
+      }
+
+
+      /**
+      * For INT target, the base versions of packages is
+      * Default : dependencies of LATEST TST known composite
+      * overridden by : INT composite - locked dependencies to declare the deps that are staying on the TST env and
+      * will not go further for the moment.
+      */
+      if (envTarget === 'INT') {
+        return getCompositeDepsByEnv(
+          compositePath,
+          envTarget,
+          compositeType,
+          envsMetadata,
+          'TST', 'INT'
+        );
+      }
+
+
+     /**
+      * For ACC, the base versions of packages is
+      * Default : dependencies of LATEST INT known composite
+      * overridden by : lockedDependencies if any
+      */
+      if (envTarget === 'ACC') {
+        return getCompositeDepsByEnv(
+          compositePath,
+          envTarget,
+          compositeType,
+          envsMetadata,
+          'INT', 'ACC'
+        );
+      }
+
+
+     /**
+      * For PROD target, the base versions of packages is
+      * Default : PROD respective composite
+      */
+      if (envTarget === 'PROD') {
+        return getCompositeDepsByEnv(
+          compositePath,
+          envTarget,
+          compositeType,
+          envsMetadata,
+          'TRN', 'PROD'
+        );
+      }
+
+
+     /**
+      * For TRN, the base versions of packages is
+      * Default : dependencies of LATEST PROD known composite
+      * overridden by : hotfixDependencies if any
+      */
+      if (envTarget === 'TRN') {
+        return getCompositeDepsByEnv(
+          compositePath,
+          envTarget,
+          compositeType,
+          envsMetadata,
+          'ACC', 'TRN'
+        );
+      }
+
+
+      /**
+      * For DLT, the base versions of packages is
+      * Default : dependencies of LATEST ACC known composite
+      */
+      if (envTarget === 'DLT') {
+        return getCompositeDepsByEnv(
+          compositePath,
+          envTarget,
+          compositeType,
+          envsMetadata,
+          'ACC', 'DLT'
+        );
+      }
+    })
+
+    // Finally the re-mapped env-based composite of dependencies is returned
+    .then((finalDeps) => {
+      tools.logInfo('Packages composite found for target : ');
+      console.log(finalDeps);
+
+      // returning the composite packages found
+      return finalDeps;
+    })
+
+    .catch((e) => {
+      throw e;
+    })
+}
+

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

@@ -5,12 +5,16 @@ const innerBuildApp = require('./build-app');
 const innerBuildPackage = require('./build-package');
 const innerLocalDev = require('./local-dev');
 const innerCommon = require('./common');
-const innerCompositeUtils = require('./composite-utils');
-const innerRemote = require('./remote');
+const innerProjects = require('./projects');
+const innerRemotes = require('./remotes');
+const innerPackages = require('./packages');
+const innerCompositeCore = require('./composite-core');
 
 module.exports.buildApp = innerBuildApp;
 module.exports.buildPackage = innerBuildPackage;
 module.exports.localDev = innerLocalDev;
 module.exports.common = innerCommon;
-module.exports.compositeUtils = innerCompositeUtils;
-module.exports.remote = innerRemote;
+module.exports.projects = innerProjects;
+module.exports.remotes = innerRemotes;
+module.exports.packages = innerPackages;
+module.exports.compositeCore = innerCompositeCore;