@tsi-developpement/tsi-shared-ui 0.0.1

package/esm2022/lib/tsi-base/components/app-base/app-base.component.mjs

@@ -0,0 +1,101 @@
+import { Component, inject } from '@angular/core';
+import { Segment } from '../../../end-points/baseuri';
+import { EntityConfigurationService } from '../../../services/configuration/entity-configuration.service';
+import { DynamicDialogConfig, DynamicDialogRef } from 'primeng/dynamicdialog';
+import * as i0 from "@angular/core";
+export class AppBaseComponent {
+    get formEndpoint() {
+        return this._formEndpoint;
+    }
+    ;
+    set formEndpoint(endpoint) {
+        this._formEndpoint = `${Segment.base}/${endpoint}`;
+    }
+    get businessClass() {
+        return this._businessClass;
+    }
+    set businessClass(value) {
+        this._businessClass = value;
+        this.getEntityInformation(this._businessClass);
+    }
+    async getEntityInformation(businessClass) {
+        try {
+            this.entityInfo = await this._entityConfigService.getEntityInfoFromCache(businessClass);
+        }
+        catch (error) {
+            console.error('error : ', error);
+        }
+    }
+    constructor(cdRef) {
+        this.cdRef = cdRef;
+        //#region properties
+        this.formName = '';
+        this._entityConfigService = inject(EntityConfigurationService);
+        //#endregion
+        //#region private properties
+        this._formEndpoint = '';
+        //#endregion
+        this.openedDialogRef = inject(DynamicDialogRef);
+        this.openedDialogConfig = inject(DynamicDialogConfig);
+        this._setFormName();
+        this.initModalData();
+    }
+    initModalData() {
+        console.log("from app Base custom Data => ", this.openedDialogConfig?.data?.customData);
+        console.log("from tsi-app-base : ", {
+            "_openedDialogRef": this.openedDialogRef,
+            "_openedDialogConfig": this.openedDialogConfig
+        });
+        if (this.openedDialogRef != null
+            && this.openedDialogRef != undefined
+            && this.openedDialogConfig != null
+            && this.openedDialogConfig != undefined) {
+            //check have _openedDialogConfig
+            if (this.openedDialogConfig.data != null && this.openedDialogConfig.data != undefined) {
+                let keys = Object.keys(this.openedDialogConfig.data);
+                keys.forEach(key => {
+                    if ( /*this.hasOwnProperty(key)true*/this.openedDialogConfig != null
+                        && this.openedDialogConfig != undefined) {
+                        // Solution 2: When the type of the object is not known
+                        //const temp = this[key as keyof typeof this]
+                        this[key] = this.openedDialogConfig.data[key];
+                    }
+                    else {
+                        throw new Error(`${this.constructor.name} doesn't contain property with name ${key}`);
+                    }
+                });
+            }
+        }
+    }
+    ngOnDestroy() {
+    }
+    ngOnInit() {
+    }
+    ngAfterContentChecked() {
+        if (this.cdRef != undefined) {
+            this.cdRef.detectChanges();
+        }
+    }
+    //#region private methods
+    _setFormName() {
+        // console.log('Object(this) : ',Object(this));
+        // console.log('typeof(this) : ',typeof(this));
+        // console.log('Object.getPrototypeOf : ',Object.getPrototypeOf(Object(this)));
+        // console.log('ɵcmp : ',(<any>this.constructor).ɵcmp);
+        // console.log('ɵcmp name : ',(<any>this.constructor).ɵcmp?.type.name);
+        // console.log('ctor ɵcmp selectors : ',(<any>this.constructor).ɵcmp?.selectors);
+        // console.log('ctor ɵcmp selector[0][0] : ',(<any>this.constructor).ɵcmp?.selectors[0]);
+        this.formName = this._myName();
+        console.log('my name is : ', this.formName);
+    }
+    _myName() {
+        return this.constructor.ɵcmp?.selectors[0][0];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AppBaseComponent, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: AppBaseComponent, selector: "app-app-base", ngImport: i0, template: "<p>app-base works!</p>\r\n", styles: [""] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AppBaseComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-app-base', template: "<p>app-base works!</p>\r\n" }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"app-base.component.js","sourceRoot":"","sources":["../../../../../../../projects/tsi-shared-ui/src/lib/tsi-base/components/app-base/app-base.component.ts","../../../../../../../projects/tsi-shared-ui/src/lib/tsi-base/components/app-base/app-base.component.html"],"names":[],"mappings":"AAAA,OAAO,EAA0C,SAAS,EAAE,MAAM,EAAqB,MAAM,eAAe,CAAC;AAC7G,OAAO,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAEtD,OAAO,EAAE,0BAA0B,EAAE,MAAM,8DAA8D,CAAC;AAC1G,OAAO,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;;AAO9E,MAAM,OAAgB,gBAAgB;IAOpC,IAAW,YAAY;QACrB,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;IAAA,CAAC;IACF,IAAc,YAAY,CAAC,QAAgB;QACzC,IAAI,CAAC,aAAa,GAAG,GAAG,OAAO,CAAC,IAAI,IAAI,QAAQ,EAAE,CAAC;IACrD,CAAC;IACD,IAAW,aAAa;QACtB,OAAO,IAAI,CAAC,cAAc,CAAC;IAC7B,CAAC;IAEA,IAAW,aAAa,CAAC,KAAa;QACrC,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC;QAC5B,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;IACjD,CAAC;IAED,KAAK,CAAC,oBAAoB,CAAC,aAAqB;QAC9C,IAAI,CAAC;YACH,IAAI,CAAC,UAAU,GAAG,MAAM,IAAI,CAAC,oBAAoB,CAAC,sBAAsB,CACtE,aAAa,CACd,CAAC;QACJ,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,KAAK,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;QACnC,CAAC;IACH,CAAC;IAYD,YAAsB,KAAyB;QAAzB,UAAK,GAAL,KAAK,CAAoB;QAvC/C,oBAAoB;QACb,aAAQ,GAAW,EAAE,CAAC;QAErB,yBAAoB,GAAG,MAAM,CAAC,0BAA0B,CAAC,CAAC;QA0BlE,YAAY;QAEZ,4BAA4B;QACpB,kBAAa,GAAY,EAAE,CAAC;QAEpC,YAAY;QAEA,oBAAe,GAAsB,MAAM,CAAC,gBAAgB,CAAC,CAAC;QAC9D,uBAAkB,GAAyB,MAAM,CAAC,mBAAmB,CAAC,CAAC;QAGjF,IAAI,CAAC,YAAY,EAAE,CAAC;QACpB,IAAI,CAAC,aAAa,EAAE,CAAA;IACtB,CAAC;IAES,aAAa;QACrB,OAAO,CAAC,GAAG,CAAC,+BAA+B,EAAE,IAAI,CAAC,kBAAkB,EAAE,IAAI,EAAE,UAAU,CAAC,CAAA;QACvF,OAAO,CAAC,GAAG,CAAC,sBAAsB,EAAE;YAClC,kBAAkB,EAAE,IAAI,CAAC,eAAe;YACxC,qBAAqB,EAAE,IAAI,CAAC,kBAAkB;SAC/C,CAAC,CAAA;QACF,IAAI,IAAI,CAAC,eAAe,IAAI,IAAI;eAC3B,IAAI,CAAC,eAAe,IAAI,SAAS;eACjC,IAAI,CAAC,kBAAkB,IAAI,IAAI;eAC/B,IAAI,CAAC,kBAAkB,IAAI,SAAS,EAAE,CAAC;YAC1C,gCAAgC;YAChC,IAAI,IAAI,CAAC,kBAAkB,CAAC,IAAI,IAAI,IAAI,IAAI,IAAI,CAAC,kBAAkB,CAAC,IAAI,IAAI,SAAS,EAAE,CAAC;gBACtF,IAAI,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAA;gBACpD,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE;oBACjB,KAAI,gCAAiC,IAAI,CAAC,kBAAkB,IAAI,IAAI;2BAC/D,IAAI,CAAC,kBAAkB,IAAI,SAAS,EAAE,CAAC;wBAE1C,uDAAuD;wBACvD,6CAA6C;wBAC7C,IAAI,CAAC,GAAwB,CAAC,GAAG,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;oBACrE,CAAC;yBACI,CAAC;wBACJ,MAAM,IAAI,KAAK,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,uCAAuC,GAAG,EAAE,CAAC,CAAC;oBACxF,CAAC;gBACH,CAAC,CAAC,CAAC;YACL,CAAC;QACH,CAAC;IACH,CAAC;IAED,WAAW;IACX,CAAC;IACD,QAAQ;IACR,CAAC;IAED,qBAAqB;QACnB,IAAG,IAAI,CAAC,KAAK,IAAI,SAAS,EAAC,CAAC;YAC5B,IAAI,CAAC,KAAK,CAAC,aAAa,EAAE,CAAC;QAC3B,CAAC;IACH,CAAC;IAED,yBAAyB;IAEjB,YAAY;QAClB,+CAA+C;QAC/C,+CAA+C;QAC/C,+EAA+E;QAC/E,uDAAuD;QACvD,uEAAuE;QACvE,iFAAiF;QACjF,yFAAyF;QACzF,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;QAC/B,OAAO,CAAC,GAAG,CAAC,eAAe,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC9C,CAAC;IAEM,OAAO;QACZ,OAAa,IAAI,CAAC,WAAY,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACvD,CAAC;+GAvGmB,gBAAgB;mGAAhB,gBAAgB,oDCXtC,4BACA;;4FDUsB,gBAAgB;kBALrC,SAAS;+BACE,cAAc","sourcesContent":["import { AfterContentChecked, ChangeDetectorRef, Component, inject, OnDestroy, OnInit } from '@angular/core';\r\nimport { Segment } from '../../../end-points/baseuri';\r\nimport { entityInfo } from '../../../models/entity-info/entity-info';\r\nimport { EntityConfigurationService } from '../../../services/configuration/entity-configuration.service';\r\nimport { DynamicDialogConfig, DynamicDialogRef } from 'primeng/dynamicdialog';\r\n\r\n@Component({\r\n  selector: 'app-app-base',\r\n  templateUrl: './app-base.component.html',\r\n  styleUrls: ['./app-base.component.scss']\r\n})\r\nexport abstract class AppBaseComponent  implements OnInit\r\n  , AfterContentChecked\r\n  , OnDestroy{\r\n  //#region properties\r\n  public formName: string = '';\r\n  entityInfo: entityInfo | undefined;\r\n  private _entityConfigService = inject(EntityConfigurationService);\r\n  public get formEndpoint() : string {\r\n    return this._formEndpoint;\r\n  };\r\n  protected set formEndpoint(endpoint: string) {\r\n    this._formEndpoint = `${Segment.base}/${endpoint}`;\r\n  }\r\n  public get businessClass(){\r\n    return this._businessClass;\r\n  }\r\n\r\n   public set businessClass(value: string) {\r\n    this._businessClass = value;\r\n    this.getEntityInformation(this._businessClass);\r\n  }\r\n\r\n  async getEntityInformation(businessClass: string) {\r\n    try {\r\n      this.entityInfo = await this._entityConfigService.getEntityInfoFromCache(\r\n        businessClass\r\n      );\r\n    } catch (error) {\r\n      console.error('error : ', error);\r\n    }\r\n  }\r\n\r\n  //#endregion\r\n\r\n  //#region private properties\r\n  private _formEndpoint : string = '';\r\n  public _businessClass!: string;\r\n  //#endregion\r\n\r\n    protected openedDialogRef?: DynamicDialogRef = inject(DynamicDialogRef);\r\n    protected openedDialogConfig?: DynamicDialogConfig = inject(DynamicDialogConfig);\r\n\r\n  constructor(protected cdRef?: ChangeDetectorRef) {\r\n    this._setFormName();\r\n    this.initModalData()\r\n  }\r\n\r\n  protected initModalData() {\r\n    console.log(\"from app Base custom Data => \", this.openedDialogConfig?.data?.customData)\r\n    console.log(\"from tsi-app-base : \", {\r\n      \"_openedDialogRef\": this.openedDialogRef,\r\n      \"_openedDialogConfig\": this.openedDialogConfig\r\n    })\r\n    if (this.openedDialogRef != null\r\n      && this.openedDialogRef != undefined\r\n      && this.openedDialogConfig != null\r\n      && this.openedDialogConfig != undefined) {\r\n      //check have _openedDialogConfig\r\n      if (this.openedDialogConfig.data != null && this.openedDialogConfig.data != undefined) {\r\n        let keys = Object.keys(this.openedDialogConfig.data)\r\n        keys.forEach(key => {\r\n          if (/*this.hasOwnProperty(key)true*/ this.openedDialogConfig != null\r\n            && this.openedDialogConfig != undefined) {\r\n\r\n            // Solution 2: When the type of the object is not known\r\n            //const temp = this[key as keyof typeof this]\r\n            this[key as keyof typeof this] = this.openedDialogConfig.data[key];\r\n          }\r\n          else {\r\n            throw new Error(`${this.constructor.name} doesn't contain property with name ${key}`);\r\n          }\r\n        });\r\n      }\r\n    }\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n  }\r\n  ngOnInit(): void {\r\n  }\r\n\r\n  ngAfterContentChecked(): void {\r\n    if(this.cdRef != undefined){\r\n    this.cdRef.detectChanges();\r\n    }\r\n  }\r\n\r\n  //#region private methods\r\n\r\n  private _setFormName(): void{\r\n    // console.log('Object(this) : ',Object(this));\r\n    // console.log('typeof(this) : ',typeof(this));\r\n    // console.log('Object.getPrototypeOf : ',Object.getPrototypeOf(Object(this)));\r\n    // console.log('ɵcmp : ',(<any>this.constructor).ɵcmp);\r\n    // console.log('ɵcmp name : ',(<any>this.constructor).ɵcmp?.type.name);\r\n    // console.log('ctor ɵcmp selectors : ',(<any>this.constructor).ɵcmp?.selectors);\r\n    // console.log('ctor ɵcmp selector[0][0] : ',(<any>this.constructor).ɵcmp?.selectors[0]);\r\n    this.formName = this._myName();\r\n    console.log('my name is : ', this.formName);\r\n  }\r\n\r\n  public _myName(): string{\r\n    return (<any>this.constructor).ɵcmp?.selectors[0][0];\r\n  }\r\n  //#endregion\r\n}","<p>app-base works!</p>\r\n"]}

package/esm2022/lib/tsi-base/components/tsi-base/tsi-base.component.mjs

@@ -0,0 +1,25 @@
+import { Component } from '@angular/core';
+import * as i0 from "@angular/core";
+export class TsiBaseComponent {
+    constructor(cdRef) {
+        this.cdRef = cdRef;
+        this.myStyleClass = 'p-0 tsi-component';
+    }
+    ngOnInit() {
+    }
+    ngAfterContentChecked() {
+        if (this.cdRef != undefined) {
+            this.cdRef.detectChanges();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TsiBaseComponent, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: TsiBaseComponent, selector: "app-tsi-base", ngImport: i0, template: '', isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TsiBaseComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'app-tsi-base',
+                    template: ''
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHNpLWJhc2UuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdHNpLXNoYXJlZC11aS9zcmMvbGliL3RzaS1iYXNlL2NvbXBvbmVudHMvdHNpLWJhc2UvdHNpLWJhc2UuY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBMEMsU0FBUyxFQUFrQixNQUFNLGVBQWUsQ0FBQzs7QUFNbEcsTUFBTSxPQUFPLGdCQUFnQjtJQUczQixZQUFzQixLQUF5QjtRQUF6QixVQUFLLEdBQUwsS0FBSyxDQUFvQjtRQUQvQyxpQkFBWSxHQUFXLG1CQUFtQixDQUFBO0lBQ1MsQ0FBQztJQUVwRCxRQUFRO0lBQ1IsQ0FBQztJQUVELHFCQUFxQjtRQUNuQixJQUFJLElBQUksQ0FBQyxLQUFLLElBQUksU0FBUyxFQUFFLENBQUM7WUFDNUIsSUFBSSxDQUFDLEtBQUssQ0FBQyxhQUFhLEVBQUUsQ0FBQztRQUM3QixDQUFDO0lBQ0gsQ0FBQzsrR0FaVSxnQkFBZ0I7bUdBQWhCLGdCQUFnQixvREFGakIsRUFBRTs7NEZBRUQsZ0JBQWdCO2tCQUo1QixTQUFTO21CQUFDO29CQUNULFFBQVEsRUFBRSxjQUFjO29CQUN4QixRQUFRLEVBQUUsRUFBRTtpQkFDYiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEFmdGVyQ29udGVudENoZWNrZWQsIENoYW5nZURldGVjdG9yUmVmLCBDb21wb25lbnQsIGluamVjdCwgT25Jbml0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcblxyXG5AQ29tcG9uZW50KHtcclxuICBzZWxlY3RvcjogJ2FwcC10c2ktYmFzZScsXHJcbiAgdGVtcGxhdGU6ICcnXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBUc2lCYXNlQ29tcG9uZW50IGltcGxlbWVudHMgT25Jbml0LCBBZnRlckNvbnRlbnRDaGVja2VkIHtcclxuXHJcbiAgbXlTdHlsZUNsYXNzOiBzdHJpbmcgPSAncC0wIHRzaS1jb21wb25lbnQnXHJcbiAgY29uc3RydWN0b3IocHJvdGVjdGVkIGNkUmVmPzogQ2hhbmdlRGV0ZWN0b3JSZWYpIHsgfVxyXG5cclxuICBuZ09uSW5pdCgpOiB2b2lkIHtcclxuICB9XHJcblxyXG4gIG5nQWZ0ZXJDb250ZW50Q2hlY2tlZCgpOiB2b2lkIHtcclxuICAgIGlmICh0aGlzLmNkUmVmICE9IHVuZGVmaW5lZCkge1xyXG4gICAgICB0aGlzLmNkUmVmLmRldGVjdENoYW5nZXMoKTtcclxuICAgIH1cclxuICB9XHJcbn0iXX0=