@eui/tools 6.15.21 → 6.16.1

package/scripts/csdr/init/remotes/18.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/18.x/full/options/definitions/participant.json

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

package/scripts/csdr/init/remotes/18.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/18.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/18.x/full/options/participant/app/module.component.ts

@@ -0,0 +1,101 @@
+import { Component, OnInit, Inject, ElementRef, OnDestroy } from '@angular/core';
+
+import { Subscription } from 'rxjs';
+import { first } 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_PLACEHOLDER -->
+        </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;
+
+    private initSubscription: Subscription;
+
+    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.initSubscription?.unsubscribe();
+        this.elementLifeCycleService.cleanup();
+    }
+
+    private loadData() {
+        this.setStatus(ElementStatus.Loading);
+        try {
+            this.initSubscription?.unsubscribe();
+
+            this.initSubscription = this.elementSetupService
+                .init()
+                .pipe(first())
+                .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/18.x/full/options/participant/app/routing.module.ts

@@ -0,0 +1,21 @@
+import { NgModule } from '@angular/core';
+import { RouterModule, Routes } from '@angular/router';
+
+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),
+    ],
+    exports: [
+        RouterModule,
+    ],
+})
+export class RoutingModule {
+}

package/scripts/csdr/init/remotes/18.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/18.x/full/options/user-reducers/app/reducers/index.ts

@@ -0,0 +1,75 @@
+import { InjectionToken } from '@angular/core';
+import { ActionReducer, ActionReducerMap, MetaReducer, INIT, RuntimeChecks } from '@ngrx/store';
+import * as fromRouter from '@ngrx/router-store';
+import { storeFreeze } from 'ngrx-store-freeze';
+
+import { reducers as coreReducers, CoreState } from '@eui/core';
+import { ElementStorageService } from '@csdr/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 function hydrationFactory(config: any, elementStorage: ElementStorageService): MetaReducer<AppState> {
+    return (reducer: ActionReducer<AppState>): ActionReducer<any> => {
+        return (state, action) => {
+            const key = `NgRx store: ${config.global.elementName}`;
+            if (action.type === INIT && elementStorage.hasData(key)) {
+                const cachedState = elementStorage.getData(key);
+                const nextStateFromCache = reducer(cachedState as AppState, action);
+                elementStorage.setData(key, nextStateFromCache);
+                return nextStateFromCache;
+            }
+            const nextState = reducer(state, action);
+            elementStorage.setData(key, nextState);
+            return nextState;
+        };
+    };
+}
+
+export function metaReducers(config: any, elementStorage: ElementStorageService): MetaReducer<AppState>[] {
+    if (!environment.production) {
+        return [logger, storeFreeze, hydrationFactory(config, elementStorage)];
+    }
+    return [hydrationFactory(config, elementStorage)];
+}
+
+export const runtimeChecks: RuntimeChecks = {
+    strictStateSerializability: false,
+    strictActionSerializability: false,
+    strictStateImmutability: false,
+    strictActionImmutability: false,
+    strictActionWithinNgZone: false,
+    strictActionTypeUniqueness: false,
+};

package/scripts/csdr/init/resources/18.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/18.x/resolutions.json

@@ -0,0 +1,7 @@
+{
+    "fast-xml-parser": ">=4.2.4",
+    "socket.io-parser": ">=4.2.3",
+    "semver": ">=6.3.1",
+    "crypto-js": ">=4.2.0",
+    "@babel/traverse": ">=7.23.2"
+}