@eui/tools 6.3.22 → 6.3.23

package/.version.properties

@@ -1 +1 @@
-6.3.22
+6.3.23

package/CHANGELOG.md

@@ -1,3 +1,12 @@
+## 6.3.23 (2023-02-08)
+
+##### Chores
+
+* **other:**
+  * updated full v15 remote generation for remote participant - MWP-9204 [MWP-9204](https://webgate.ec.europa.eu/CITnet/jira/browse/MWP-9204)  ([310e9816](https://webgate.ec.europa.eu/CITnet/stash/scm/csdr/eui-tools.git/commits/310e981676ef479d3dda5b47b39a4dee92e9cde5))
+
+* * *
+* * *
 ## 6.3.22 (2023-02-08)
 
 ##### Chores

package/package.json

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

package/scripts/csdr/audit/styles.js

@@ -9,7 +9,7 @@ const tools = require('../../utils/tools');
 const notificationUtils = require('../../utils/notification/notification-utils');
 
 
-const runStylesAudit = module.exports.runStylesAudit = (pkg) => {
+const runStylesAudit = module.exports.runStylesAudit = (pkg, customPath) => {
 
   const generateIndicesContent = (indices, file, fileContent) => {
     let content = [];
@@ -43,7 +43,22 @@ const runStylesAudit = module.exports.runStylesAudit = (pkg) => {
 
 
 
-  tools.logTitle(`Auditing : ${pkg.name}`);
+
+
+  // checking params
+
+  let srcPath;
+
+  if (customPath) {
+    srcPath = customPath;
+    tools.logTitle(`Auditing : ${customPath}`);
+  } else {
+    srcPath = pkg.paths.src;
+    tools.logTitle(`Auditing : ${pkg.name}`);
+  }
+
+
+  // setting default report object
 
   const report = {
     package: null,
@@ -107,14 +122,18 @@ const runStylesAudit = module.exports.runStylesAudit = (pkg) => {
   };
 
 
-  report.package = pkg.name;
+  if (customPath) {
+    report.package = customPath;
+  } else {
+    report.package = pkg.name;
+  }
 
-  let files = glob.sync('**/*.scss', { cwd: pkg.paths.src, nodir: true, follow: true, dot: true });
+  let files = glob.sync('**/*.scss', { cwd: srcPath, nodir: true, follow: true, dot: true });
 
   report.scssFilesCount += files.length;
 
   files.forEach(file => {
-    const filePath = path.join(pkg.paths.src, file);
+    const filePath = path.join(srcPath, file);
     const fileContent = tools.getFileContent(filePath).trim();
     const linesCount = fileContent.split('\n').length;
 
@@ -184,12 +203,12 @@ const runStylesAudit = module.exports.runStylesAudit = (pkg) => {
 
 
 
- files = glob.sync('**/*.html', { cwd: pkg.paths.src, nodir: true, follow: true, dot: true });
+ files = glob.sync('**/*.html', { cwd: srcPath, nodir: true, follow: true, dot: true });
 
  report.htmlFilesCount += files.length;
 
  files.forEach(file => {
-   const filePath = path.join(pkg.paths.src, file);
+   const filePath = path.join(srcPath, file);
    const fileContent = tools.getFileContent(filePath);
    const linesCount = fileContent.split('\n').length;
 
@@ -215,10 +234,10 @@ const runStylesAudit = module.exports.runStylesAudit = (pkg) => {
 
 
 
- files = glob.sync('**/*.ts', { cwd: pkg.paths.src, nodir: true, follow: true, dot: true });
+ files = glob.sync('**/*.ts', { cwd: srcPath, nodir: true, follow: true, dot: true });
 
  files.forEach(file => {
-   const filePath = path.join(pkg.paths.src, file);
+   const filePath = path.join(srcPath, file);
    const fileContent = tools.getFileContent(filePath);
    const linesCount = fileContent.split('\n').length;
 

package/scripts/csdr/config/register.js

@@ -94,8 +94,6 @@ module.exports.registerCsdrPackage = (pkg, isRemote, rootPkgScope, rootPkgName,
     "build": {
       "compiledTranslations": true,
       "translationScopes": "eui,csdr,cc,mywp",
-      "skipLint": true,
-      "skipTest": true,
       "sonarScanner": false,
       "envTargetActive": true
     },
@@ -119,8 +117,6 @@ module.exports.registerCsdrPackage = (pkg, isRemote, rootPkgScope, rootPkgName,
       "compiledTranslations": true,
       "translationScopes": "eui,csdr,cc,mywp",
       "envTargetActive": true,
-      "skipLint": true,
-      "skipTest": true,
       "sonarScanner": false
     },
     "release": {
@@ -142,8 +138,6 @@ module.exports.registerCsdrPackage = (pkg, isRemote, rootPkgScope, rootPkgName,
       "compiledTranslations": true,
       "translationScopes": "eui,csdr,cc,mywp",
       "envTargetActive": true,
-      "skipLint": true,
-      "skipTest": true,
       "sonarScanner": false
     },
     "release": {

package/scripts/csdr/init/init.js

@@ -159,7 +159,6 @@ module.exports.init = () => {
       }
     })
 
-
     // Attaching app scripts to root package.json
     .then(() => {
       if (finalResponse.project) {

package/scripts/csdr/init/packages.js

@@ -66,13 +66,24 @@ module.exports.importPackages = (args = {}) => {
     .then(() => {
       configUtils.angular.checkConfigFiles(args.reset);
     })
-    .then(() => Promise.resolve().then(() => {
-      return packages.reduce((promise, pkg) => {
-        return promise.then(() => (
-          importPackage(pkg, args)
-        ));
-      }, Promise.resolve());
-    }))
+
+    .then(() => {
+      if (args.pkgOnly || args.remoteOnly) {
+        if (args.pkg) {
+          return importPackage(configUtils.packages.getPackage(args.pkg), args);
+        } else if (args.remote) {
+          return importPackage(configUtils.remotes.getRemote(args.remote), args);
+        }
+      } else {
+        Promise.resolve().then(() => {
+          return packages.reduce((promise, pkg) => {
+            return promise.then(() => (
+              importPackage(pkg, args)
+            ));
+          }, Promise.resolve());
+        })
+      }
+    })
 
     .then(() => {
       tools.logSuccess('OK => all packages successfully imported');

package/scripts/csdr/init/remotes/15.x/full/{src → common}/app/module.ts

@@ -1,7 +1,7 @@
 import { NgModule, Injector, DoBootstrap, ApplicationRef } from '@angular/core';
 import { BrowserModule } from '@angular/platform-browser';
 import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
-import { HttpClientModule } from '@angular/common/http';
+import { HttpClient, HttpClientModule, HttpHeaders } from '@angular/common/http';
 import { createCustomElement } from '@angular/elements';
 
 import { StoreModule, USER_PROVIDED_META_REDUCERS } from '@ngrx/store';
@@ -17,43 +17,50 @@ import {
     EUI_CONFIG_TOKEN,
     translateConfig,
 } from '@eui/core';
+import { EUI_COMPONENTS_MODULES } from './eui-components';
 import {
     CsdrCoreModule,
     ElementStorageService,
 } from '@csdr/core';
 
+import { TOKEN, reducerProvider, metaReducers } from './reducers/index';
+import { CustomSerializer } from './reducers/custom-route-serializer';
+
+import { environment } from '../environments/environment';
+import { appConfig } from '../config';
+
 import { @root.common.module@ as RootCommonModule } from '@root.npm.pkg@';
 import {
     DEFAULT_MAPPED_PROVIDERS,
 } from '@csdr/integration/element';
+import {
+    CONTAINER_MAPPED_PROVIDERS,
+} from '@csdr/integration';
 import { RoutingModule } from './routing.module';
 
-import { TOKEN, reducerProvider, getMetaReducers } from './reducers/index';
-import { CustomSerializer } from './reducers/custom-route-serializer';
-import { environment } from '../environments/environment';
-import { appConfig } from '../config';
 import { FallbackComponent } from './fallback.component';
 import { ModuleComponent } from './module.component';
-import { EUI_COMPONENTS_MODULES } from './eui-components';
+
+// IMPORTS
+
+// DECLARATIONS
 
 @NgModule({
     imports: [
         BrowserModule,
         BrowserAnimationsModule,
         HttpClientModule,
-        StoreRouterConnectingModule.forRoot({ stateKey: 'router', serializer: CustomSerializer }),
-        StoreModule.forRoot(TOKEN),
         EffectsModule.forRoot([]),
         StoreDevtoolsModule.instrument({ name: appConfig.global.storeName, maxAge: 150, logOnly: environment.production }),
         TranslateModule.forRoot(translateConfig),
 
         CoreModule.forRoot(),
         CsdrCoreModule.forRoot(),
-
         RootCommonModule,
         RoutingModule,
-
         ...EUI_COMPONENTS_MODULES,
+
+       // DEFINITIONS
     ],
     declarations: [
         FallbackComponent,
@@ -65,22 +72,20 @@ import { EUI_COMPONENTS_MODULES } from './eui-components';
     ],
     providers: [
         reducerProvider,
-        {
-            provide: USER_PROVIDED_META_REDUCERS,
-            deps: [CONFIG_TOKEN, ElementStorageService],
-            useFactory: getMetaReducers,
-        },
         {
             provide: EUI_CONFIG_TOKEN,
             useValue: { appConfig: { ...appConfig, ...environment }, environment },
         },
 
         ...DEFAULT_MAPPED_PROVIDERS,
+
+        // PROVIDERS
     ],
 })
 export class AppModule implements DoBootstrap {
 
-    constructor(private injector: Injector) {
+    constructor(private injector: Injector, private http: HttpClient) {
+        // CONSTRUCTOR DECLARATIONS
     }
 
     ngDoBootstrap(appRef: ApplicationRef): void {

package/scripts/csdr/init/remotes/15.x/full/common/app/reducers/index.ts

@@ -0,0 +1,42 @@
+import { InjectionToken } from '@angular/core';
+import { ActionReducer, ActionReducerMap, MetaReducer } from '@ngrx/store';
+import * as fromRouter from '@ngrx/router-store';
+import { storeFreeze } from 'ngrx-store-freeze';
+import { reducers as coreReducers, CoreState, localStorageSync } from '@eui/core';
+
+import { environment } from '../../environments/environment';
+
+export interface AppState extends CoreState {
+    router: fromRouter.RouterReducerState<any>;
+}
+
+// -----------------
+// ------------ AOT
+export const TOKEN = new InjectionToken<any>('AppReducers');
+
+export function getReducers(): ActionReducerMap<AppState, any> {
+    return {
+        router: fromRouter.routerReducer,
+        ...coreReducers,
+    };
+}
+
+export const reducerProvider = [
+    { provide: TOKEN, useFactory: getReducers },
+];
+
+// console.log all actions
+export function logger(reducer: ActionReducer<AppState>): ActionReducer<AppState> {
+    return (state, action) => {
+        const result = reducer(state, action);
+        console.groupCollapsed(action.type);
+        console.log('prev state', state);
+        console.log('action', action);
+        console.log('next state', result);
+        console.groupEnd();
+
+        return result;
+    };
+}
+
+export const metaReducers: MetaReducer<AppState>[] = !environment.production ? [logger, localStorageSync, storeFreeze] : [localStorageSync];

package/scripts/csdr/init/remotes/15.x/full/{src → common}/config/global.ts

@@ -52,4 +52,7 @@ export const GLOBAL: GlobalConfig = {
     storeName: '@store.name@',
     i18n: i18nConfig,
     locale: localeConfig,
+    eui: {
+        assetsBaseUrl: 'assets/elements/@remote.name@/bundles/assets',
+    },
 };

package/scripts/csdr/init/remotes/15.x/full/options/definitions/dynatrace.json

@@ -0,0 +1,4 @@
+{
+    "declarations": "declare const window: { dT_: { initAngularNg?: any } | undefined };",
+    "constructorDeclarations": "if (window?.dT_?.initAngularNg) { window.dT_.initAngularNg(http, HttpHeaders); }"
+}

package/scripts/csdr/init/remotes/15.x/full/options/definitions/participant.json

@@ -0,0 +1,3 @@
+{
+    "providers": "...CONTAINER_MAPPED_PROVIDERS"
+}

package/scripts/csdr/init/remotes/15.x/full/options/definitions/user-reducers.json

@@ -0,0 +1,3 @@
+{
+    "providers": "{ provide: USER_PROVIDED_META_REDUCERS, deps: [CONFIG_TOKEN, ElementStorageService], useFactory: metaReducers }"
+}

package/scripts/csdr/init/remotes/15.x/full/options/definitions/zipkin.json

@@ -0,0 +1,5 @@
+{
+    "imports": "import { getZipkinConfig, TRACE_MODULE_CONFIGURATION, ZipkinModule } from '@csdr/zipkin-tracing';",
+    "definitions": "ZipkinModule.forRoot()",
+    "providers": "{ provide: TRACE_MODULE_CONFIGURATION, useFactory: getZipkinConfig, deps: [CONFIG_TOKEN] }"
+}

package/scripts/csdr/init/remotes/15.x/full/options/participant/app/module.component.ts

@@ -0,0 +1,94 @@
+import { Component, OnInit, Inject, ElementRef, OnDestroy } from '@angular/core';
+
+import { take } from 'rxjs/operators';
+
+import { CONFIG_TOKEN } from '@eui/core';
+import { ElementSetupService, ElementLifeCycleService } from '@csdr/integration/element';
+
+enum ElementStatus {
+    Loading = 'loading',
+    Loaded = 'loaded',
+    Error = 'error',
+}
+
+@Component({
+    template: `
+        <eui-block-content *ngIf="moduleStatus === ElementStatus.Loading" [isBlocked]="true">
+            <div style="height: 100%"></div>
+        </eui-block-content>
+        <ng-container *ngIf="moduleStatus === ElementStatus.Loaded">
+            <@block.container.name@ [block]="block"></@block.container.name@>
+        </ng-container>
+        <ng-container *ngIf="moduleStatus === ElementStatus.Error">
+            <div class="error-container">
+                <div>
+                    <h1>Translations or user data for this module failed to load.</h1>
+                    <p>Do you want to try again?</p>
+                    <button euiButton euiPrimary (click)="loadData()">
+                        <span euiLabel>{{ "global.RELOAD" | translate }}</span>
+                    </button>
+                </div>
+            </div>
+        </ng-container>
+    `,
+    styles: [`
+        .error-container {
+            width: 50vw;
+            height: 50vh;
+            position: absolute;
+            top: 50%;
+            left: 50%;
+            transform: translate(-50%, -50%);
+        }
+
+        .error-container div {
+            text-align: center
+        }
+    `],
+})
+export class ModuleComponent implements OnInit, OnDestroy {
+    ElementStatus = ElementStatus;
+    moduleStatus: ElementStatus;
+
+    block: any;
+
+    constructor(private elRef: ElementRef,
+                @Inject(CONFIG_TOKEN) public config: any,
+                private elementLifeCycleService: ElementLifeCycleService,
+                private elementSetupService: ElementSetupService) {
+    }
+
+    ngOnInit() {
+        this.block = this.elRef.nativeElement.block;
+        const elementData = this.elementLifeCycleService.getElementData(this.elRef);
+        this.elementLifeCycleService.setup(elementData);
+        this.loadData();
+    }
+
+    ngOnDestroy(): void {
+        this.elementLifeCycleService.cleanup();
+    }
+
+    private loadData() {
+        this.setStatus(ElementStatus.Loading);
+        try {
+            this.elementSetupService.init()
+                .pipe(take(1))
+                .subscribe((loadStatus: { success: boolean, error?: string }) => {
+                    if (!loadStatus.success) {
+                        this.setStatus(ElementStatus.Error);
+                        console.error(`[ELEMENT: ${this.config.global.elementName}] `, loadStatus.error);
+                    } else {
+                        this.setStatus(ElementStatus.Loaded);
+                    }
+                });
+        } catch (e) {
+            console.log(e);
+            this.setStatus(ElementStatus.Error);
+        }
+    }
+
+    private setStatus(status: ElementStatus) {
+        this.moduleStatus = status;
+    }
+}

package/scripts/csdr/init/remotes/15.x/full/options/participant/app/routing.module.ts

@@ -0,0 +1,26 @@
+import { NgModule } from '@angular/core';
+import { RouterModule, Routes } from '@angular/router';
+
+import { ELEMENT_ROUTES_TOKEN } from '@csdr/integration/element';
+
+import { appConfig } from '../config/index'; // tslint:disable-line
+import { FallbackComponent } from './fallback.component'; // tslint:disable-line
+import { ModuleComponent } from './module.component';
+
+const elementRoutes: Routes = [
+    { path: '**', component: ModuleComponent },
+];
+
+@NgModule({
+    imports: [
+        RouterModule.forRoot(elementRoutes),
+    ],
+    providers: [
+        { provide: ELEMENT_ROUTES_TOKEN, useValue: elementRoutes },
+    ],
+    exports: [
+        RouterModule,
+    ],
+})
+export class RoutingModule {
+}

package/scripts/csdr/init/remotes/15.x/full/options/participant/config/index.ts

@@ -0,0 +1,10 @@
+import { GLOBAL } from './global';
+import { MODULES } from './modules';
+
+import { EuiAppConfig } from '@eui/core';
+import { configMapping } from '@csdr/integration/element';
+
+export const appConfig: EuiAppConfig = configMapping({
+    global: GLOBAL,
+    modules: MODULES,
+});

package/scripts/csdr/init/remotes/15.x/full/{src → options/user-reducers}/app/reducers/index.ts

@@ -58,7 +58,7 @@ export function hydrationFactory(config: any, elementStorage: ElementStorageServ
     };
 }
 
-export function getMetaReducers(config: any, elementStorage: ElementStorageService): MetaReducer<AppState>[] {
+export function metaReducers(config: any, elementStorage: ElementStorageService): MetaReducer<AppState>[] {
     if (!environment.production) {
         return [logger, localStorageSync, storeFreeze, hydrationFactory(config, elementStorage)];
     }

package/scripts/csdr/init/remotes.js

@@ -39,6 +39,22 @@ const cloneRemotesConfig = module.exports.cloneRemotesConfig = () => {
 module.exports.generateVirtualRemote = (remoteName, cloneRemote = true) => {
   tools.logTitle('Generating virtual remote');
 
+  // getting the remote config
+  const remote = configUtils.remotes.getRemote(remoteName);
+
+  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 found: ')
+  console.log(remote);
+
+  const remotePath = path.join(process.cwd(), 'remotes', remote.name);
+  const remoteSrcPath = path.join(remotePath, 'src');
+  const remoteSkeletonRootPath = path.join(__dirname, 'remotes', remote.euiVersion);
+  const remoteSkeletonPath = path.join(remoteSkeletonRootPath, 'base');
+
+
   return Promise.resolve()
 
     // clone remotes config if first init
@@ -49,24 +65,12 @@ module.exports.generateVirtualRemote = (remoteName, cloneRemote = true) => {
     })
 
     .then(() => {
-      // getting the remote config
-      const remote = configUtils.remotes.getRemote(remoteName);
-
-      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 found: ')
-      console.log(remote);
-
-      // constructing the remote folder
-      const remotePath = path.join(process.cwd(), 'remotes', remote.name);
-      const remoteSkeletonRootPath = path.join(__dirname, 'remotes', remote.euiVersion);
-      const remoteSkeletonPath = path.join(remoteSkeletonRootPath, 'base');
-      const remoteSkeletonFullPath = path.join(remoteSkeletonRootPath, 'full');
+      return tools.rimraf(remoteSrcPath);
+    })
 
+    .then(() => {
+      // copying default base sources
       tools.logInfo(`Copying base sources => ${remoteSkeletonPath} ==> ${remotePath}`);
-
       tools.copy(remoteSkeletonPath, remotePath);
 
       // adding the dependendies files
@@ -131,19 +135,81 @@ module.exports.generateVirtualRemote = (remoteName, cloneRemote = true) => {
 
       // initializing "full" remote sources
       if (remote.fullSkeletonSources) {
-        tools.logInfo(`copying full sources skeleton : ${remoteSkeletonFullPath} ==> ${remotePath}`);
-        tools.copy(remoteSkeletonFullPath, remotePath);
+        const fullCommonPath = path.join(remoteSkeletonRootPath, 'full', 'common');
+        const fullOptionsPath = path.join(remoteSkeletonRootPath, 'full', 'options');
+
+        const optionUserReducersPath = path.join(fullOptionsPath, 'user-reducers');
+        const optionParticipantPath = path.join(fullOptionsPath, 'participant');
+        const optionUserReducersDef = tools.getJsonFileContent(path.join(fullOptionsPath, 'definitions', 'user-reducers.json'));
+        const optionZipkinDef = tools.getJsonFileContent(path.join(fullOptionsPath, 'definitions', 'zipkin.json'));
+        const optionDynatraceDef = tools.getJsonFileContent(path.join(fullOptionsPath, 'definitions', 'dynatrace.json'));
+        const optionParticipantDef = tools.getJsonFileContent(path.join(fullOptionsPath, 'definitions', 'participant.json'));
+
+        tools.logInfo(`copying full sources skeleton : ${fullCommonPath} ==> ${remoteSrcPath}`);
+        tools.copy(fullCommonPath, remoteSrcPath);
+
+        // checking options
+        if (remote.skeletonConfig.options) {
+          let importsContent = [];
+          let definitionsContent = [];
+          let declarationsContent = [];
+          let providersContent = [];
+          let constructorDeclarationsContent = [];
+
+          const pushContent = (obj) => {
+            if (obj.imports) importsContent.push(obj.imports);
+            if (obj.definitions) definitionsContent.push(obj.definitions);
+            if (obj.declarations) declarationsContent.push(obj.declarations);
+            if (obj.providers) providersContent.push(obj.providers);
+            if (obj.constructorDeclarations) constructorDeclarationsContent.push(obj.constructorDeclarations);
+          }
+
+          // user-reducers specific sources
+          if (remote.skeletonConfig.options.userReducers) {
+            tools.copy(optionUserReducersPath, remoteSrcPath);
+            definitionsContent.push('StoreModule.forRoot(TOKEN)');
+            pushContent(optionUserReducersDef);
+          } else {
+            definitionsContent.push('StoreModule.forRoot(TOKEN, { metaReducers })');
+          }
+
+          // zipkin
+          if (remote.skeletonConfig.options.zipkin) {
+            pushContent(optionZipkinDef);
+          }
+
+          // dynatrace
+          if (remote.skeletonConfig.options.dynatrace) {
+            pushContent(optionDynatraceDef);
+          }
+
+          // participant
+          if (remote.skeletonConfig.options.participant) {
+            tools.copy(optionParticipantPath, remoteSrcPath);
+            pushContent(optionParticipantDef);
+          } else {
+            definitionsContent.push(`StoreRouterConnectingModule.forRoot({ stateKey: 'router', serializer: CustomSerializer })`);
+          }
+
+          // replace option in module.ts placeholders
+          const moduleTsPath = path.join(remoteSrcPath, 'app', 'module.ts');
+          tools.replaceInFileSync(moduleTsPath, '// IMPORTS', importsContent.join('\n'));
+          tools.replaceInFileSync(moduleTsPath, '// DEFINITIONS', definitionsContent.join(',\n'));
+          tools.replaceInFileSync(moduleTsPath, '// DECLARATIONS', declarationsContent.join('\n'));
+          tools.replaceInFileSync(moduleTsPath, '// PROVIDERS', providersContent.join(',\n'));
+          tools.replaceInFileSync(moduleTsPath, '// CONSTRUCTOR DECLARATIONS', constructorDeclarationsContent.join('\n'));
+        }
 
         tools.logInfo('Replacing skeleton config tokens');
-
-        const remoteSrcPath = path.join(remotePath, 'src');
-
         tools.replaceInPath(remoteSrcPath, '@remote.name@', remote.name);
         tools.replaceInPath(remoteSrcPath, '@base.url@', remote.skeletonConfig.baseUrl);
         tools.replaceInPath(remoteSrcPath, '@element.name@', remote.skeletonConfig.elementName);
         tools.replaceInPath(remoteSrcPath, '@store.name@', remote.skeletonConfig.storeName);
         tools.replaceInPath(remoteSrcPath, '@root.common.module@', remote.skeletonConfig.rootCommonModule);
         tools.replaceInPath(remoteSrcPath, '@root.npm.pkg@', remote.skeletonConfig.rootNpmPkg);
+        if (remote.skeletonConfig.options.participant) {
+          tools.replaceInPath(remoteSrcPath, '@block.container.name@', remote.skeletonConfig.blockContainerName);
+        }
 
         tools.logSuccess('OK => copy done - Tokens replaced');
       }

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

@@ -10,169 +10,83 @@ const configUtils = require('../../../csdr/config/config-utils');
 const preBuildUtils = require('../../pre-build/pre-build-utils');
 const remotesUtils = require('../../remotes/remotes-utils');
 
-let {
-  skipLint, skipTest, configuration, baseHref, watch, dryRun, maxSpaceSize, statsJson,
-  ci, sourceMap, build
-} = tools.getArgs();
+let { configuration, baseHref, dryRun, statsJson, sourceMap, build } = tools.getArgs();
 
 
 module.exports.build = (pkg, isMaster) => {
 
   const ng = path.resolve(pkg.paths.repoNodeModules, '@angular', 'cli', 'bin', 'ng');
-
   const remoteEuiVersion = configUtils.packages.getRemoteEuiVersion(pkg);
-
   const pkgName = pkg.name;
 
-  return Promise.resolve()
-
-  .then(() => {
-    tools.logTitle(`Building element : ${pkgName}...`);
-
-    // force skipLint and skipTest on element
-    skipLint = true;
-    skipTest = true;
-  })
-
-  .then(() => {
-    return preBuildUtils.elements.preBuild(pkg);
-  })
+  tools.logTitle(`Building element : ${pkgName}...`);
 
-  .then(() => {
-    if (!skipLint) {
-      tools.logInfo(`TS Linting element...`);
+  return Promise.resolve()
+    .then(() => {
+      return preBuildUtils.elements.preBuild(pkg);
+    })
 
-      const tslint = path.resolve(pkg.paths.repoNodeModules, 'tslint', 'bin', 'tslint');
+    .then(() => {
+      tools.logInfo(`Launching element build...`);
 
-      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}`);
+      // specific for element
+      const versionNumber = remoteEuiVersion.split('.')[0];
 
-      const args = [tslint, '-c', tsLintPath, '-p', tsConfigPath];
-      return execa('node', args, { cwd: pkg.paths.root, stdio: 'inherit' });
-    }
-  })
+      // checking configuration
+      if (!configuration) {
+        configuration = 'production';
+      }
 
+      let args;
 
-  .then(() => {
-    if (!skipLint) {
-      tools.logSuccess();
-    }
-    if (!skipLint) {
-      tools.logInfo(`Styles Linting element...`);
+      if (versionNumber <= 10) {
+        args = ['--max_old_space_size=8096', ng, 'build', pkgName, '--prod'];
+      } else {
+        args = ['--max_old_space_size=8096', ng, 'build', pkgName];
+      }
 
-      // return tools.runScript(`stylelint ${pkg.paths.root}/src/app/**/*.scss`);
-      const stylelint = path.resolve(pkg.paths.repoNodeModules, 'stylelint', 'bin', 'stylelint');
-      const args = [stylelint, `${pkg.paths.root}/src/app/**/*.scss`];
+      if (statsJson) {
+        args.push(`--stats-json`);
+      }
 
-      return execa('node', args, { cwd: pkg.paths.root, stdio: 'inherit' });
-    }
-  })
+      args.push(`--configuration=${configuration}`);
 
+      if (baseHref) {
+        args.push(`--base-href=${baseHref}`);
+      }
 
-  .then(() => {
-    if (!skipLint) {
-      tools.logSuccess();
-    }
-    if (!skipTest) {
-      tools.logInfo(`Launching element unit testing...`);
+      if (versionNumber <= 10) {
+        const webpackExtraFile = path.join(pkg.paths.root, 'webpack.extra.js');
+        if (tools.isFileExists(webpackExtraFile)) {
+          args.push(`--extra-webpack-config=${webpackExtraFile}`);
+        }
+        args.push(`--single-bundle=true`);
+      }
 
-      let args;
+      args.push(`--output-hashing=none`);
 
-      if (maxSpaceSize) {
-        args = ['--max_old_space_size=4096', ng, 'test', pkgName];
-      } else {
-        args = [ng, 'test', pkgName];
+      if (build) {
+        args.push('--progress=false');
       }
 
-      if (watch) {
-        args.push(`--watch=true`);
-      } else {
-        args.push(`--watch=false`);
+      if (sourceMap) {
+        args.push('--source-map');
       }
 
-      args.push('--code-coverage');
-
-      tools.logInfo(`ng test : watching = ${watch || false}`);
+      tools.logInfo(`ng build for configuration : ${configuration}`);
 
-      tools.logInfo(`running Angular TEST with args: ${args} on`);
+      tools.logInfo(`running Angular BUILD with args: ${args} on`);
       console.log(pkg.paths.root);
 
       if (!dryRun) {
         return execa('node', args, { cwd: pkg.paths.root, stdio: 'inherit' });
       }
-    }
-  })
-
-
-  .then(() => {
-    if (!skipTest) {
-      tools.logSuccess();
-    }
-    tools.logInfo(`Launching element build...`);
-
-    // specific for element
-    const versionNumber = remoteEuiVersion.split('.')[0];
-
-    // checking configuration
-    if (!configuration) {
-      configuration = 'production';
-    }
-
-    let args;
-
-    if (versionNumber <= 10) {
-      args = ['--max_old_space_size=8096', ng, 'build', pkgName, '--prod'];
-    } else {
-      args = ['--max_old_space_size=8096', ng, 'build', pkgName];
-    }
-
-    if (statsJson) {
-      args.push(`--stats-json`);
-    }
-
-    args.push(`--configuration=${configuration}`);
-
-    if (baseHref) {
-      args.push(`--base-href=${baseHref}`);
-    }
-
-    const webpackExtraFile = path.join(pkg.paths.root, 'webpack.extra.js');
-    if (tools.isFileExists(webpackExtraFile)) {
-      args.push(`--extra-webpack-config=${webpackExtraFile}`);
-    }
-
-    // specific for element
-
-    if (versionNumber <= 10) {
-      args.push(`--single-bundle=true`);
-    }
-
-    args.push(`--output-hashing=none`);
-
-    if (build) {
-      args.push('--progress=false');
-    }
-
-    if (sourceMap) {
-      args.push('--source-map');
-    }
-
-    tools.logInfo(`ng build for configuration : ${configuration}`);
-
-    tools.logInfo(`running Angular BUILD with args: ${args} on`);
-    console.log(pkg.paths.root);
-
-    if (!dryRun) {
-      return execa('node', args, { cwd: pkg.paths.root, stdio: 'inherit' });
-    }
-  })
+    })
 
 
-  .catch((e) => {
-    throw e;
-  });
+    .catch((e) => {
+      throw e;
+    });
 }
 
 

package/scripts/utils/tools.js

@@ -414,6 +414,19 @@ function replaceInFile(file, fromString, toString) {
   })
 }
 
+function replaceInFileSync(file, fromString, toString) {
+  const fromRegExp = new RegExp(fromString, 'g');
+
+  logInfo('replace in file: ' + file);
+
+  return replace.sync({
+    files: file,
+    from: fromRegExp,
+    to: toString,
+    disableGlobs: true,
+  });
+}
+
 function replaceInPath(rootPath, fromString, toString) {
   const fromRegExp = new RegExp(fromString, 'g');
 
@@ -814,6 +827,7 @@ module.exports.logDebugTrace = logDebugTrace;
 module.exports.logDebugResponse = logDebugResponse;
 
 module.exports.replaceInFile = replaceInFile;
+module.exports.replaceInFileSync = replaceInFileSync;
 module.exports.replaceInPath = replaceInPath;
 module.exports.sortArray = sortArray;
 module.exports.removeArrayDuplicates = removeArrayDuplicates;

package/scripts/csdr/init/remotes/15.x/full/src/app/dummy.spec.ts

@@ -1,6 +0,0 @@
-// Dummy test
-describe('Test', () => {
-    it('should work', () => {
-        expect(true).toBe(true);
-    });
-});