@eui/tools 6.7.0 → 6.7.2

package/scripts/csdr/cli/skeletons/package/frontend/15.x/participant/src/test.ts.TO_REPLACE

@@ -0,0 +1,21 @@
+// This file is required by karma.conf.js and loads recursively all the .spec and framework files
+
+import 'zone.js/dist/zone';
+import 'zone.js/dist/zone-testing';
+import { getTestBed } from '@angular/core/testing';
+import {
+  BrowserDynamicTestingModule,
+  platformBrowserDynamicTesting
+} from '@angular/platform-browser-dynamic/testing';
+
+declare const require: any;
+
+// First, initialize the Angular testing environment.
+getTestBed().initTestEnvironment(
+  BrowserDynamicTestingModule,
+  platformBrowserDynamicTesting()
+);
+// Then we find all the tests.
+const context = require.context('./', true, /\.spec\.ts$/);
+// And load the modules.
+context.keys().map(context);

package/scripts/csdr/cli/skeletons/package/frontend/15.x/participant/tsconfig.lib.json

@@ -0,0 +1,32 @@
+{
+  "extends": "../../tsconfig.build.json",
+  "compilerOptions": {
+    "outDir": "./out-tsc/lib",
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "node",
+    "declaration": true,
+    "sourceMap": true,
+    "inlineSources": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "importHelpers": true,
+    "types": [],
+    "lib": [
+      "ES2022",
+      "dom"
+    ]
+  },
+  "angularCompilerOptions": {
+    "annotateForClosureCompiler": true,
+    "skipTemplateCodegen": true,
+    "strictMetadataEmit": true,
+    "fullTemplateTypeCheck": true,
+    "strictInjectionParameters": true,
+    "enableResourceInlining": true
+  },
+  "exclude": [
+    "src/test.ts",
+    "**/*.spec.ts"
+  ]
+}

package/scripts/csdr/cli/skeletons/package/frontend/15.x/participant/tsconfig.spec.json

@@ -0,0 +1,17 @@
+{
+  "extends": "../../tsconfig.build.json",
+  "compilerOptions": {
+    "outDir": "./out-tsc/spec",
+    "types": [
+      "jasmine",
+      "node"
+    ]
+  },
+  "files": [
+    "src/test.ts"
+  ],
+  "include": [
+    "**/*.spec.ts",
+    "**/*.d.ts"
+  ]
+}

package/scripts/csdr/config/init.js

@@ -15,6 +15,47 @@ const innerGlobal = require('./global');
 
 
 module.exports.run = (args) => {
+  return Promise.resolve()
+    .then(() => {
+      if (args.custom) {
+        return initConfigCustom();
+
+      } else {
+        return initConfigCore(args);
+      }
+    })
+
+    .catch((e) => {
+      throw e;
+    })
+}
+
+
+const initConfigCustom = () => {
+  return Promise.resolve()
+    .then(() => {
+      tools.logInfo('Updating local configuration - custom init');
+
+      const customConfig = innerGlobal.getCustomConfig();
+
+      if (!customConfig) {
+        throw new Error('Custom config not found... run the command "npm run init:custom" to generate your customized config');
+      }
+
+      return innerGlobal.updateConfig({
+        project: customConfig.project,
+        packages: customConfig.packages,
+        remotes: customConfig.remotes,
+        reset: true
+      });
+    })
+    .catch((e) => {
+      throw e;
+    })
+}
+
+
+const initConfigCore = (args) => {
   return Promise.resolve()
     .then(() => {
       tools.logInfo('Updating local configuration')
@@ -28,14 +69,13 @@ module.exports.run = (args) => {
 
       if (args.remote) {
         const remote = innerRemotes.getCsdrRemotes()[args.remote];
-        if (remote) {
+      if (remote) {
           remotes.push(args.remote);
         }
       }
 
       return innerGlobal.updateConfig({ project: args.project, packages: packages, remotes: remotes, reset: args.reset });
     })
-
     .catch((e) => {
       throw e;
     })
@@ -44,6 +84,9 @@ module.exports.run = (args) => {
 
 
 
+
+
+
 const getInputPackages = (project, pkg, team, prjOnly, containerOnly) => {
   tools.logInfo('Gathering team packages');
 

package/scripts/csdr/init/init-custom.js

@@ -0,0 +1,54 @@
+'use strict';
+
+const tools = require('../../utils/tools');
+const configUtils = require('../config/config-utils');
+
+const innerInitProject = require('./init-project');
+const innerRemotes = require('./remotes');
+const innerPackages = require('./packages');
+
+const { skipInstall, build } = tools.getArgs();
+
+
+let customConfig;
+
+module.exports.init = (finalResponse) => {
+  return Promise.resolve()
+    .then(() => {
+      customConfig = configUtils.global.getCustomConfig();
+      if (!customConfig) {
+        throw new Error('Custom config not found... run the command "npm run init:custom" to generate your customized config');
+      }
+    })
+
+    .then(() => {
+      finalResponse.project = customConfig.project;
+      finalResponse.euiVersion = customConfig.euiVersion;
+
+      return innerInitProject.init(finalResponse);
+    })
+
+    .then(() => {
+      return customConfig.remotes.reduce((promise, remote) => {
+        return promise.then(() => (
+          innerRemotes.generateVirtualRemote(remote)
+        ));
+      }, Promise.resolve());
+    })
+
+    .then(() => {
+      return innerPackages.importPackages(finalResponse);
+    })
+
+    .then(() => {
+      // this is only executed for local dev installation,
+      // in case of release the initialisation is managed by the application / package themselves
+      if (!build && !skipInstall) {
+        return installUtils.localDev.install();
+      }
+    })
+
+    .catch((e) => {
+      throw e;
+    });
+}

package/scripts/csdr/init/init-old.js

@@ -0,0 +1,210 @@
+'use strict';
+
+const tools = require('../../utils/tools');
+const initUtils = require('./init-utils');
+const installUtils = require('../install/install-utils');
+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, remote, euiVersion, remoteOnly, remoteBuild, virtual, custom
+} = tools.getArgs();
+
+
+module.exports.init = () => {
+  // Initializing a common response
+  const initialResponse = {
+    project: project || null,
+    team: team || 'all',
+    pkg: pkg || null,
+    remote: remote || null,
+    remoteBuild: remoteBuild || false,
+    virtual: virtual || false,
+    euiVersion: euiVersion || null,
+    branch: branch || 'develop',
+    configOnly: configOnly || false,
+    skipClone: skipClone || false,
+    reset: reset || false,
+    pkgOnly: pkgOnly || false,
+    prjOnly: prjOnly || false,
+    remoteOnly: remoteOnly || false,
+    build: build || false,
+    containerOnly: containerOnly || false,
+    skipAppContainers: skipAppContainers || false,
+    custom: custom || false
+  }
+
+  // converting inputs args
+  initialResponse.branch = tools.convertStringArg(initialResponse.branch, 'develop');
+  initialResponse.euiVersion = tools.convertStringArg(initialResponse.euiVersion);
+  initialResponse.remoteBuild = tools.convertBooleanArg(initialResponse.remoteBuild);
+  initialResponse.virtual = tools.convertBooleanArg(initialResponse.virtual);
+
+
+  // setting project to null if forced to NONE
+  if (initialResponse.project === 'NONE') {
+    initialResponse.project = null;
+  }
+
+  // swapping to remote build if virtual remote is pass to default gitlab call
+  if (initialResponse.remoteBuild && initialResponse.pkg && initialResponse.virtual) {
+    initialResponse.remote = initialResponse.pkg;
+    initialResponse.pkg = null;
+  }
+
+
+  // Storing the response for propagation
+  let finalResponse;
+
+  return Promise.resolve()
+    .then(() => {
+
+      // if no project has been provided we prompt for project and team selection
+      if (!project && !pkg && !remote && !custom ) {
+        // TODO refactor to handle dynamic mywp-host-playground install (pre-remotes install etc...)
+        // return initUtils.prompt.start();
+        tools.logError('****************************************');
+        tools.logError('*************** ERROR ******************');
+        tools.logError('****************************************\n');
+        tools.logError('At least "pkg" or "project" or "remote" type should be used for init, for example :\n');
+        tools.logError('npm run init -- --pkg PKG_NAME [--branch BRANCH_NAME|default develop] [--git local] [--pkgOnly] [--skipInstall]');
+        tools.logError('npm run init -- --project PROJECT_NAME [--branch BRANCH_NAME|default develop] [--git local] [--prjOnly] [--skipInstall]');
+        tools.logError('npm run init -- --remote VIRTUAL_REMOTE_NAME [--remoteOnly] [--skipInstall]');
+        tools.logError('npm run init -- --custom [--skipInstall] [--git local]');
+        process.exit(0);
+
+        // if provided, we are on automated mode, we use the initialized response
+      } else {
+        return initialResponse;
+      }
+    })
+
+    // merge with response found from prompts
+    .then((response) => {
+      finalResponse = { ...initialResponse, ...response };
+
+      tools.logInfo('Configuration generated based on provided args:');
+      console.log(finalResponse);
+    })
+
+    // Initializing .euirc.json local file - the core of CSDR operations
+    .then(() => {
+      // Initialize config
+      return configUtils.init.run(finalResponse);
+    })
+
+    // clone or install linked host package to project if any
+    .then(() => {
+      // TODO
+      // if (finalResponse.project && !build) {
+      if (finalResponse.project) {
+        return initUtils.packages.cloneHostPackage(finalResponse.project);
+      }
+      // TODO
+      // } else if (finalResponse.project && build) {
+      //   return initUtils.packages.installHostPackage(finalResponse.project);
+      // }
+    })
+
+    // Initializing .meta based on .euirc.json for local respoisitories cloning
+    .then(() => {
+      if (!finalResponse.remote) {
+        return initUtils.meta.init();
+      }
+    })
+
+    // Cloning repositories based on the .meta file generated
+    .then(() => {
+      if (!skipClone && !finalResponse.remote) {
+        return initUtils.repos.init(finalResponse);
+      }
+    })
+
+    // Importing external sources
+    .then(() => {
+      if (finalResponse.project) {
+        return initUtils.projects.importExternalSources(true);
+      }
+    })
+
+    // Generating virtual remote - experimental
+    .then(() => {
+      if (finalResponse.remote) {
+        return initUtils.remotes.generateVirtualRemote(finalResponse.remote);
+      }
+    })
+
+    // Importing packages and generating definitions
+    .then(() => {
+      return initUtils.packages.importPackages(finalResponse);
+    })
+
+    // 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
+    .then(() => {
+      return initUtils.global.processLocalEuiVersions();
+    })
+
+    // specific resolution injection based on NodeJS (recent failure of nodejs10.x for MWP v7)
+    .then(() => {
+      return initUtils.global.processResolutionsForNodeVersion();
+    })
+
+    // Install deps based on current config generated => take last know snapshots
+    .then(() => {
+      // 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 || finalResponse.remoteOnly) {
+          if (finalResponse.remote) {
+            return installUtils.localDev.installRemote(finalResponse.remote);
+          } else {
+            return installUtils.localDev.installPackage(finalResponse.pkg);
+          }
+        } else {
+          return installUtils.localDev.install();
+        }
+      }
+    })
+
+    // Attaching app scripts to root package.json
+    .then(() => {
+      if (finalResponse.project) {
+        return initUtils.projects.importScripts();
+      }
+    })
+
+
+    // Attaching extra tsconfig from project
+    .then(() => {
+      if (finalResponse.project) {
+        return initUtils.projects.importExtraTsConfig();
+      }
+    })
+
+
+    // Attaching external features from project
+    .then(() => {
+      if (finalResponse.project && !build) {
+        return initUtils.projects.importExternalFeatures();
+      }
+    })
+
+
+    // Attaching external mock repo for project
+    .then(() => {
+      if (finalResponse.project && !build && !finalResponse.prjOnly) {
+        return initUtils.projects.importExternalMock();
+      }
+    })
+
+
+    .then(() => {
+      tools.logSuccess('OK => Project successfully initialized');
+    })
+
+    .catch((e) => {
+      throw e;
+    });
+}

package/scripts/csdr/init/init-package.js

@@ -0,0 +1,63 @@
+'use strict';
+
+const tools = require('../../utils/tools');
+const initUtils = require('./init-utils');
+const installUtils = require('../install/install-utils');
+const configUtils = require('../config/config-utils');
+
+const { skipClone, skipInstall, build } = tools.getArgs();
+
+
+module.exports.init = (finalResponse) => {
+  return Promise.resolve()
+    // Initializing .euirc.json local file - the core of CSDR operations
+    .then(() => {
+      // Initialize config
+      return configUtils.init.run(finalResponse);
+    })
+
+    // Initializing .meta based on .euirc.json for local respoisitories cloning
+    .then(() => {
+      return initUtils.meta.init();
+    })
+
+    // Cloning repositories based on the .meta file generated
+    .then(() => {
+      if (!skipClone) {
+        return initUtils.repos.init(finalResponse);
+      }
+    })
+
+    // Importing packages and generating definitions
+    .then(() => {
+      return initUtils.packages.importPackages(finalResponse);
+    })
+
+    // 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
+    .then(() => {
+      return initUtils.global.processLocalEuiVersions();
+    })
+
+    // specific resolution injection based on NodeJS (recent failure of nodejs10.x for MWP v7)
+    .then(() => {
+      return initUtils.global.processResolutionsForNodeVersion();
+    })
+
+    // Install deps based on current config generated => take last know snapshots
+    .then(() => {
+      // 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(finalResponse.pkg);
+        } else {
+          return installUtils.localDev.install();
+        }
+      }
+    })
+
+    .catch((e) => {
+      throw e;
+    });
+}

package/scripts/csdr/init/init-project.js

@@ -0,0 +1,103 @@
+'use strict';
+
+const tools = require('../../utils/tools');
+const initUtils = require('./init-utils');
+const installUtils = require('../install/install-utils');
+const configUtils = require('../config/config-utils');
+const injectionUtils = require('../../utils/pre-build/injection/injection-utils');
+
+const { skipClone, skipInstall, build } = tools.getArgs();
+
+
+module.exports.init = (finalResponse) => {
+  return Promise.resolve()
+    // Initializing .euirc.json local file - the core of CSDR operations
+    .then(() => {
+      // Initialize config
+      return configUtils.init.run(finalResponse);
+    })
+
+    // clone or install linked host package to project if any
+    .then(() => {
+      return initUtils.packages.cloneHostPackage(finalResponse.project);
+    })
+
+    // Initializing .meta based on .euirc.json for local respoisitories cloning
+    .then(() => {
+      return initUtils.meta.init();
+    })
+
+    // Cloning repositories based on the .meta file generated
+    .then(() => {
+      if (!skipClone) {
+        return initUtils.repos.init(finalResponse);
+      }
+    })
+
+    // Importing external sources
+    .then(() => {
+      const prj = configUtils.projects.getProject(finalResponse.project);
+      return injectionUtils.externals.injectExternalAppSources(prj, false, true, finalResponse.euiVersion);
+      // return initUtils.projects.importExternalSources(true);
+    })
+
+    // Importing packages and generating definitions
+    .then(() => {
+      return initUtils.packages.importPackages(finalResponse);
+    })
+
+    // 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
+    .then(() => {
+      return initUtils.global.processLocalEuiVersions();
+    })
+
+    // specific resolution injection based on NodeJS (recent failure of nodejs10.x for MWP v7)
+    .then(() => {
+      return initUtils.global.processResolutionsForNodeVersion();
+    })
+
+    // Install deps based on current config generated => take last know snapshots
+    .then(() => {
+      // this is only executed for local dev installation,
+      // in case of release the initialisation is managed by the application / package themselves
+      if (!build && !skipInstall) {
+        return installUtils.localDev.install();
+      }
+    })
+
+    // Attaching app scripts to root package.json
+    .then(() => {
+      return initUtils.projects.importScripts();
+    })
+
+
+    // Attaching extra tsconfig from project
+    .then(() => {
+      return initUtils.projects.importExtraTsConfig();
+    })
+
+
+    // Attaching external features from project
+    .then(() => {
+      if (!build) {
+        return initUtils.projects.importExternalFeatures();
+      }
+    })
+
+
+    // Attaching external mock repo for project
+    .then(() => {
+      if (!build) {
+        return initUtils.projects.importExternalMock();
+      }
+    })
+
+    .then(() => {
+      tools.logSuccess('OK => Project successfully initialized');
+    })
+
+    .catch((e) => {
+      throw e;
+    });
+}

package/scripts/csdr/init/init-remote.js

@@ -0,0 +1,47 @@
+'use strict';
+
+const tools = require('../../utils/tools');
+const initUtils = require('./init-utils');
+const installUtils = require('../install/install-utils');
+const configUtils = require('../config/config-utils');
+
+// Getting arguments if they are provided for the CI/CD pipeline
+const { skipInstall, build } = tools.getArgs();
+
+
+
+module.exports.init = (finalResponse) => {
+  return Promise.resolve()
+    // Initializing .euirc.json local file - the core of CSDR operations
+    .then(() => {
+      // Initialize config
+      return configUtils.init.run(finalResponse);
+    })
+
+    // Generating virtual remote - experimental
+    .then(() => {
+      return initUtils.remotes.generateVirtualRemote(finalResponse.remote);
+    })
+
+    // Importing packages and generating definitions
+    .then(() => {
+      return initUtils.packages.importPackages(finalResponse);
+    })
+
+    // Install deps based on current config generated => take last know snapshots
+    .then(() => {
+      // 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.remoteOnly) {
+          return installUtils.localDev.installRemote(finalResponse.remote);
+        } else {
+          return installUtils.localDev.install();
+        }
+      }
+    })
+
+    .catch((e) => {
+      throw e;
+    });
+}

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

@@ -3,6 +3,9 @@
 // INNER MODULES - RE-EXPORTS
 module.exports.global = require('./global');
 module.exports.init = require('./init');
+module.exports.initProject = require('./init-project');
+module.exports.initPackage = require('./init-package');
+module.exports.initRemote = require('./init-remote');
 module.exports.meta = require('./meta');
 module.exports.packages = require('./packages');
 module.exports.projects = require('./projects');