@pepperi-addons/ngx-composite-lib 0.0.10-beta.4 → 0.0.10-beta.42

package/esm2015/core/common/directives/reset-configuration-field.directive.js

@@ -0,0 +1,153 @@
+import { __awaiter } from "tslib";
+import { Directive, EventEmitter, Input } from '@angular/core';
+import { pepIconDeviceResponsive } from '@pepperi-addons/ngx-lib/icon';
+import * as i0 from "@angular/core";
+import * as i1 from "@pepperi-addons/ngx-lib/icon";
+import * as i2 from "@ngx-translate/core";
+export class PepResetConfigurationFieldDirective {
+    constructor(renderer, element, pepIconService, translate) {
+        this.renderer = renderer;
+        this.element = element;
+        this.pepIconService = pepIconService;
+        this.translate = translate;
+        this.resetFieldKey = '';
+        this.resetHostEvents = new EventEmitter();
+        this._disabled = false;
+        this._hideReset = false;
+        this._dir = 'ltr';
+        // styleType: PepStyleType = 'weak';
+        // styleStateType: PepStyleStateType = 'system';
+        this.sizeType = 'sm';
+        this.resetPosition = 'bottom-end';
+        // Create the buton container.
+        this.buttonContainer = this.renderer.createElement('div');
+        this.translate.get('GENERAL.RESET_HINT').toPromise().then(hint => {
+            this.renderer.setAttribute(this.buttonContainer, 'title', hint);
+        });
+    }
+    set disabled(value) {
+        this._disabled = value;
+        this.renderer.setStyle(this.buttonContainer, 'visibility', this.getVisibility());
+    }
+    get disabled() {
+        return this._disabled;
+    }
+    set hideReset(value) {
+        this._hideReset = value;
+        this.renderer.setStyle(this.buttonContainer, 'visibility', this.getVisibility());
+    }
+    get hideReset() {
+        return this._hideReset;
+    }
+    set dir(value) {
+        this._dir = value;
+        this.renderer.setStyle(this.buttonContainer, 'float', this.getFloat());
+    }
+    get dir() {
+        return this._dir;
+    }
+    getVisibility() {
+        return this.disabled || this.hideReset ? 'hidden' : 'visible';
+    }
+    getFloat() {
+        return this.dir === 'rtl' ? 'left' : 'right';
+    }
+    setButtonContainerStyle() {
+        let css = `
+            display: flex;
+            justify-content: flex-end;
+            float: ${this.getFloat()};
+            margin-bottom: 1rem;
+        `;
+        this.buttonContainer.setAttribute("style", css);
+    }
+    setButtonStyle(button) {
+        let css = `
+            display: flex !important;
+            align-items: center !important;
+            height: 1rem !important;
+            line-height: unset !important;
+            padding: unset !important;
+            background: unset !important;
+            font-size: var(--pep-button-2xs-font-size) !important;
+            visibility: ${this.getVisibility()};
+        `;
+        button.setAttribute("style", css);
+    }
+    setSvgStyle(svg) {
+        let css = `
+            transform: rotate(270deg);
+            width: 0.75rem;
+        `;
+        svg.setAttribute('style', css);
+    }
+    getResetElement() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.setButtonContainerStyle();
+            this.renderer.addClass(this.buttonContainer, 'pep-reset-configuration-field-container');
+            // Append button
+            const button = this.renderer.createElement('button');
+            yield this.translate.get('ACTIONS.RESET').toPromise().then(resetText => {
+                const buttonText = this.renderer.createText(resetText);
+                this.renderer.appendChild(button, buttonText);
+            });
+            this.renderer.addClass(button, 'pep-button');
+            // this.renderer.addClass(button, this.styleType);
+            // this.renderer.addClass(button, this.styleStateType);
+            this.renderer.addClass(button, 'color-link');
+            this.renderer.addClass(button, this.sizeType);
+            this.setButtonStyle(button);
+            // this.renderer.addClass(button, 'reset-configuration-field-button');
+            this.unlistener = this.renderer.listen(button, 'click', () => this.onResetClicked());
+            this.renderer.appendChild(this.buttonContainer, button);
+            // Append svg
+            const svgIcon = this.pepIconService.getSvgIcon(pepIconDeviceResponsive.name);
+            this.setSvgStyle(svgIcon);
+            this.renderer.appendChild(this.buttonContainer, svgIcon);
+            return this.buttonContainer;
+        });
+    }
+    ngAfterViewInit() {
+        this.getResetElement().then(element => {
+            var _a;
+            if (this.resetPosition === 'top-end' && ((_a = this.element.nativeElement.children) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+                this.renderer.insertBefore(this.element.nativeElement, element, this.element.nativeElement.children[0]);
+            }
+            else {
+                this.renderer.appendChild(this.element.nativeElement, element);
+            }
+        });
+    }
+    ngOnDestroy() {
+        if (this.unlistener) {
+            this.unlistener();
+        }
+    }
+    onResetClicked() {
+        this.resetHostEvents.emit({
+            action: 'set-configuration-field',
+            key: this.resetFieldKey,
+            value: undefined
+        });
+    }
+}
+PepResetConfigurationFieldDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.0.5", ngImport: i0, type: PepResetConfigurationFieldDirective, deps: [{ token: i0.Renderer2 }, { token: i0.ElementRef }, { token: i1.PepIconService }, { token: i2.TranslateService }], target: i0.ɵɵFactoryTarget.Directive });
+PepResetConfigurationFieldDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.0.5", type: PepResetConfigurationFieldDirective, selector: "[pepResetConfigurationField]", inputs: { resetFieldKey: ["pepResetConfigurationField", "resetFieldKey"], resetHostEvents: "resetHostEvents", disabled: "disabled", hideReset: "hideReset", dir: "dir" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.0.5", ngImport: i0, type: PepResetConfigurationFieldDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[pepResetConfigurationField]',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Renderer2 }, { type: i0.ElementRef }, { type: i1.PepIconService }, { type: i2.TranslateService }]; }, propDecorators: { resetFieldKey: [{
+                type: Input,
+                args: ['pepResetConfigurationField']
+            }], resetHostEvents: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], hideReset: [{
+                type: Input
+            }], dir: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"reset-configuration-field.directive.js","sourceRoot":"","sources":["../../../../../../projects/ngx-composite-lib/src/core/common/directives/reset-configuration-field.directive.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,SAAS,EAA6F,YAAY,EAAE,KAAK,EAAa,MAAM,eAAe,CAAC;AAGrK,OAAO,EAAkB,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;;;;AAMvF,MAAM,OAAO,mCAAmC;IA0C5C,YACY,QAAkB,EAClB,OAAmB,EACnB,cAA8B,EAC9B,SAA2B;QAH3B,aAAQ,GAAR,QAAQ,CAAU;QAClB,YAAO,GAAP,OAAO,CAAY;QACnB,mBAAc,GAAd,cAAc,CAAgB;QAC9B,cAAS,GAAT,SAAS,CAAkB;QA7CF,kBAAa,GAAG,EAAE,CAAC;QAC/C,oBAAe,GAAsB,IAAI,YAAY,EAAE,CAAC;QAEzD,cAAS,GAAG,KAAK,CAAC;QAUlB,eAAU,GAAG,KAAK,CAAC;QAUnB,SAAI,GAAkB,KAAK,CAAC;QAUpC,oCAAoC;QACpC,gDAAgD;QAChD,aAAQ,GAAgB,IAAI,CAAC;QAC7B,kBAAa,GAAG,YAAY,CAAC;QAUzB,8BAA8B;QAC9B,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QAE1D,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,oBAAoB,CAAC,CAAC,SAAS,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;YAC7D,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,IAAI,CAAC,eAAe,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC;QACpE,CAAC,CAAC,CAAC;IACP,CAAC;IAhDD,IACI,QAAQ,CAAC,KAAc;QACvB,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;QACvB,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,eAAe,EAAE,YAAY,EAAE,IAAI,CAAC,aAAa,EAAE,CAAC,CAAC;IACrF,CAAC;IACD,IAAI,QAAQ;QACR,OAAO,IAAI,CAAC,SAAS,CAAC;IAC1B,CAAC;IAGD,IACI,SAAS,CAAC,KAAc;QACxB,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;QACxB,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,eAAe,EAAE,YAAY,EAAE,IAAI,CAAC,aAAa,EAAE,CAAC,CAAC;IACrF,CAAC;IACD,IAAI,SAAS;QACT,OAAO,IAAI,CAAC,UAAU,CAAC;IAC3B,CAAC;IAGD,IACI,GAAG,CAAC,KAAoB;QACxB,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC;QAClB,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,eAAe,EAAE,OAAO,EAAE,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC;IAC3E,CAAC;IACD,IAAI,GAAG;QACH,OAAO,IAAI,CAAC,IAAI,CAAC;IACrB,CAAC;IAuBO,aAAa;QACjB,OAAO,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC;IAClE,CAAC;IAEO,QAAQ;QACZ,OAAO,IAAI,CAAC,GAAG,KAAK,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC;IACjD,CAAC;IAEO,uBAAuB;QAC3B,IAAI,GAAG,GAAG;;;qBAGG,IAAI,CAAC,QAAQ,EAAE;;SAE3B,CAAC;QAEF,IAAI,CAAC,eAAe,CAAC,YAAY,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;IACpD,CAAC;IAEO,cAAc,CAAC,MAAyB;QAC5C,IAAI,GAAG,GAAG;;;;;;;;0BAQQ,IAAI,CAAC,aAAa,EAAE;SACrC,CAAC;QAEF,MAAM,CAAC,YAAY,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;IACtC,CAAC;IAEO,WAAW,CAAC,GAAe;QAC/B,IAAI,GAAG,GAAG;;;SAGT,CAAC;QACF,GAAG,CAAC,YAAY,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;IACnC,CAAC;IAEa,eAAe;;YACzB,IAAI,CAAC,uBAAuB,EAAE,CAAC;YAC/B,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,eAAe,EAAE,yCAAyC,CAAC,CAAC;YAExF,gBAAgB;YAChB,MAAM,MAAM,GAAsB,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;YACxE,MAAM,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC,SAAS,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE;gBACnE,MAAM,UAAU,GAAG,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;gBACvD,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;YAClD,CAAC,CAAC,CAAC;YAEH,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;YAC7C,kDAAkD;YAClD,uDAAuD;YACvD,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;YAC7C,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;YAC9C,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;YAC5B,sEAAsE;YAEtE,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC,CAAC;YAErF,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,eAAe,EAAE,MAAM,CAAC,CAAC;YAExD,aAAa;YACb,MAAM,OAAO,GAAG,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,uBAAuB,CAAC,IAAI,CAAC,CAAC;YAC7E,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;YAC1B,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,eAAe,EAAE,OAAO,CAAC,CAAC;YAGzD,OAAO,IAAI,CAAC,eAAe,CAAC;QAChC,CAAC;KAAA;IAGD,eAAe;QACX,IAAI,CAAC,eAAe,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE;;YAClC,IAAI,IAAI,CAAC,aAAa,KAAK,SAAS,IAAI,CAAA,MAAA,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,QAAQ,0CAAE,MAAM,IAAG,CAAC,EAAE;gBACrF,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;aAC3G;iBAAM;gBACH,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC;aAClE;QACL,CAAC,CAAC,CAAC;IACP,CAAC;IAED,WAAW;QACP,IAAI,IAAI,CAAC,UAAU,EAAE;YACjB,IAAI,CAAC,UAAU,EAAE,CAAC;SACrB;IACL,CAAC;IAED,cAAc;QACV,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC;YACtB,MAAM,EAAE,yBAAyB;YACjC,GAAG,EAAE,IAAI,CAAC,aAAa;YACvB,KAAK,EAAE,SAAS;SACnB,CAAC,CAAC;IACP,CAAC;;gIAxJQ,mCAAmC;oHAAnC,mCAAmC;2FAAnC,mCAAmC;kBAH/C,SAAS;mBAAC;oBACP,QAAQ,EAAE,8BAA8B;iBAC3C;qLAEwC,aAAa;sBAAjD,KAAK;uBAAC,4BAA4B;gBAC1B,eAAe;sBAAvB,KAAK;gBAIF,QAAQ;sBADX,KAAK;gBAWF,SAAS;sBADZ,KAAK;gBAWF,GAAG;sBADN,KAAK","sourcesContent":["import { Directive, HostListener, ElementRef, AfterViewInit, TemplateRef, ViewContainerRef, Renderer2, Output, EventEmitter, Input, OnDestroy } from '@angular/core';\r\nimport { TranslateService } from '@ngx-translate/core';\r\nimport { PepSizeType, PepStyleStateType, PepStyleType } from '@pepperi-addons/ngx-lib';\r\nimport { PepIconService, pepIconDeviceResponsive } from '@pepperi-addons/ngx-lib/icon';\r\n\r\n\r\n@Directive({\r\n    selector: '[pepResetConfigurationField]',\r\n})\r\nexport class PepResetConfigurationFieldDirective implements AfterViewInit, OnDestroy {\r\n    @Input('pepResetConfigurationField') resetFieldKey = '';\r\n    @Input() resetHostEvents: EventEmitter<any> = new EventEmitter();\r\n    \r\n    private _disabled = false;\r\n    @Input() \r\n    set disabled(value: boolean) {\r\n        this._disabled = value;\r\n        this.renderer.setStyle(this.buttonContainer, 'visibility', this.getVisibility());\r\n    }\r\n    get disabled(): boolean {\r\n        return this._disabled;\r\n    }\r\n\r\n    private _hideReset = false;\r\n    @Input() \r\n    set hideReset(value: boolean) {\r\n        this._hideReset = value;\r\n        this.renderer.setStyle(this.buttonContainer, 'visibility', this.getVisibility());\r\n    }\r\n    get hideReset(): boolean {\r\n        return this._hideReset;\r\n    }\r\n\r\n    private _dir: 'rtl' | 'ltr' = 'ltr';\r\n    @Input() \r\n    set dir(value: 'rtl' | 'ltr') {\r\n        this._dir = value;\r\n        this.renderer.setStyle(this.buttonContainer, 'float', this.getFloat());\r\n    }\r\n    get dir(): 'rtl' | 'ltr' {\r\n        return this._dir;\r\n    }\r\n\r\n    // styleType: PepStyleType = 'weak';\r\n    // styleStateType: PepStyleStateType = 'system';\r\n    sizeType: PepSizeType = 'sm';\r\n    resetPosition = 'bottom-end';\r\n    \r\n    private unlistener: (() => void) | undefined;\r\n    private buttonContainer!: HTMLDivElement;\r\n\r\n    constructor(\r\n        private renderer:Renderer2,\r\n        private element: ElementRef,\r\n        private pepIconService: PepIconService,\r\n        private translate: TranslateService) {\r\n        // Create the buton container.\r\n        this.buttonContainer = this.renderer.createElement('div');\r\n\r\n        this.translate.get('GENERAL.RESET_HINT').toPromise().then(hint => {\r\n            this.renderer.setAttribute(this.buttonContainer, 'title', hint);\r\n        });\r\n    }\r\n\r\n    private getVisibility() {\r\n        return this.disabled || this.hideReset ? 'hidden' : 'visible';\r\n    }\r\n\r\n    private getFloat() {\r\n        return this.dir === 'rtl' ? 'left' : 'right';\r\n    }\r\n\r\n    private setButtonContainerStyle() {\r\n        let css = `\r\n            display: flex;\r\n            justify-content: flex-end;\r\n            float: ${this.getFloat()};\r\n            margin-bottom: 1rem;\r\n        `;\r\n\r\n        this.buttonContainer.setAttribute(\"style\", css);\r\n    }\r\n\r\n    private setButtonStyle(button: HTMLButtonElement) {\r\n        let css = `\r\n            display: flex !important;\r\n            align-items: center !important;\r\n            height: 1rem !important;\r\n            line-height: unset !important;\r\n            padding: unset !important;\r\n            background: unset !important;\r\n            font-size: var(--pep-button-2xs-font-size) !important;\r\n            visibility: ${this.getVisibility()};\r\n        `;\r\n\r\n        button.setAttribute(\"style\", css);\r\n    }\r\n\r\n    private setSvgStyle(svg: SVGElement) {\r\n        let css = `\r\n            transform: rotate(270deg);\r\n            width: 0.75rem;\r\n        `;\r\n        svg.setAttribute('style', css);\r\n    }\r\n\r\n    private async getResetElement(): Promise<HTMLElement> {\r\n        this.setButtonContainerStyle();\r\n        this.renderer.addClass(this.buttonContainer, 'pep-reset-configuration-field-container');\r\n\r\n        // Append button\r\n        const button: HTMLButtonElement = this.renderer.createElement('button');\r\n        await this.translate.get('ACTIONS.RESET').toPromise().then(resetText => {\r\n            const buttonText = this.renderer.createText(resetText);\r\n            this.renderer.appendChild(button, buttonText);\r\n        });\r\n        \r\n        this.renderer.addClass(button, 'pep-button');\r\n        // this.renderer.addClass(button, this.styleType);\r\n        // this.renderer.addClass(button, this.styleStateType);\r\n        this.renderer.addClass(button, 'color-link');\r\n        this.renderer.addClass(button, this.sizeType);\r\n        this.setButtonStyle(button);\r\n        // this.renderer.addClass(button, 'reset-configuration-field-button');\r\n        \r\n        this.unlistener = this.renderer.listen(button, 'click', () => this.onResetClicked());\r\n        \r\n        this.renderer.appendChild(this.buttonContainer, button);\r\n\r\n        // Append svg\r\n        const svgIcon = this.pepIconService.getSvgIcon(pepIconDeviceResponsive.name);\r\n        this.setSvgStyle(svgIcon);\r\n        this.renderer.appendChild(this.buttonContainer, svgIcon);\r\n\r\n\r\n        return this.buttonContainer;\r\n    }\r\n\r\n    \r\n    ngAfterViewInit(): void {\r\n        this.getResetElement().then(element => {\r\n            if (this.resetPosition === 'top-end' && this.element.nativeElement.children?.length > 0) {\r\n                this.renderer.insertBefore(this.element.nativeElement, element, this.element.nativeElement.children[0]);\r\n            } else {\r\n                this.renderer.appendChild(this.element.nativeElement, element);\r\n            }\r\n        });\r\n    }\r\n\r\n    ngOnDestroy() {\r\n        if (this.unlistener) {\r\n            this.unlistener();\r\n        }\r\n    }\r\n\r\n    onResetClicked() {\r\n        this.resetHostEvents.emit({\r\n            action: 'set-configuration-field',\r\n            key: this.resetFieldKey,\r\n            value: undefined\r\n        });\r\n    }\r\n}\r\n"]}

package/esm2015/core/common/index.js

@@ -0,0 +1,5 @@
+/*
+ * export from ngx-composite-lib/core/common
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtY29tcG9zaXRlLWxpYi9zcmMvY29yZS9jb21tb24vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFDSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBleHBvcnQgZnJvbSBuZ3gtY29tcG9zaXRlLWxpYi9jb3JlL2NvbW1vblxuICovXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19

package/esm2015/core/common/public-api.js

@@ -0,0 +1,6 @@
+/*
+ * Public API Surface of ngx-composite-lib/core/common
+ */
+export * from './services/index';
+export * from './directives/index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1jb21wb3NpdGUtbGliL3NyYy9jb3JlL2NvbW1vbi9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLG9CQUFvQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIFB1YmxpYyBBUEkgU3VyZmFjZSBvZiBuZ3gtY29tcG9zaXRlLWxpYi9jb3JlL2NvbW1vblxuICovXG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2VzL2luZGV4JztcbmV4cG9ydCAqIGZyb20gJy4vZGlyZWN0aXZlcy9pbmRleCc7XG4iXX0=

package/esm2015/core/common/services/index.js

@@ -0,0 +1,5 @@
+/*
+ * export from ngx-composite-lib/core/common/services
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtY29tcG9zaXRlLWxpYi9zcmMvY29yZS9jb21tb24vc2VydmljZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFDSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBleHBvcnQgZnJvbSBuZ3gtY29tcG9zaXRlLWxpYi9jb3JlL2NvbW1vbi9zZXJ2aWNlc1xuICovXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19

package/esm2015/core/common/services/public-api.js

@@ -0,0 +1,5 @@
+/*
+ * Public API Surface of ngx-composite-lib/core/common/services
+ */
+export * from './utilities.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1jb21wb3NpdGUtbGliL3NyYy9jb3JlL2NvbW1vbi9zZXJ2aWNlcy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsY0FBYyxxQkFBcUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBQdWJsaWMgQVBJIFN1cmZhY2Ugb2Ygbmd4LWNvbXBvc2l0ZS1saWIvY29yZS9jb21tb24vc2VydmljZXNcbiAqL1xuZXhwb3J0ICogZnJvbSAnLi91dGlsaXRpZXMuc2VydmljZSc7XG4iXX0=

package/esm2015/core/common/services/utilities.service.js

@@ -0,0 +1,19 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/*
+    This service is for utillity usege.
+*/
+export class PepCompositeLibUtilitiesService {
+    constructor() {
+        //
+    }
+}
+PepCompositeLibUtilitiesService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.0.5", ngImport: i0, type: PepCompositeLibUtilitiesService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+PepCompositeLibUtilitiesService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.0.5", ngImport: i0, type: PepCompositeLibUtilitiesService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.0.5", ngImport: i0, type: PepCompositeLibUtilitiesService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbGl0aWVzLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtY29tcG9zaXRlLWxpYi9zcmMvY29yZS9jb21tb24vc2VydmljZXMvdXRpbGl0aWVzLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFFM0M7O0VBRUU7QUFJRixNQUFNLE9BQU8sK0JBQStCO0lBQ3hDO1FBS0ksRUFBRTtJQUNOLENBQUM7OzRIQVBRLCtCQUErQjtnSUFBL0IsK0JBQStCLGNBRjVCLE1BQU07MkZBRVQsK0JBQStCO2tCQUgzQyxVQUFVO21CQUFDO29CQUNSLFVBQVUsRUFBRSxNQUFNO2lCQUNyQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuXHJcbi8qXHJcbiAgICBUaGlzIHNlcnZpY2UgaXMgZm9yIHV0aWxsaXR5IHVzZWdlLlxyXG4qL1xyXG5ASW5qZWN0YWJsZSh7XHJcbiAgICBwcm92aWRlZEluOiAncm9vdCcsXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBQZXBDb21wb3NpdGVMaWJVdGlsaXRpZXNTZXJ2aWNlIHtcclxuICAgIGNvbnN0cnVjdG9yKFxyXG4gICAgICAgIC8vIHByaXZhdGUgc2Vzc2lvblNlcnZpY2U6IFBlcFNlc3Npb25TZXJ2aWNlLFxyXG4gICAgICAgIC8vIHByaXZhdGUgaHR0cFNlcnZpY2U6IFBlcEh0dHBTZXJ2aWNlLFxyXG4gICAgICAgIC8vIHByaXZhdGUgbG9hZGVyU2VydmljZTogUGVwTG9hZGVyU2VydmljZVxyXG4gICAgKSB7XHJcbiAgICAgICAgLy9cclxuICAgIH1cclxufVxyXG4iXX0=

package/esm2015/core/index.js

@@ -0,0 +1,5 @@
+/*
+ * export from ngx-composite-lib/core
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtY29tcG9zaXRlLWxpYi9zcmMvY29yZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUNILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIGV4cG9ydCBmcm9tIG5neC1jb21wb3NpdGUtbGliL2NvcmVcbiAqL1xuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2015/core/public-api.js

@@ -0,0 +1,5 @@
+/*
+ * Public API Surface of ngx-composite-lib/core
+ */
+export * from './common/index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1jb21wb3NpdGUtbGliL3NyYy9jb3JlL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFDSCxjQUFjLGdCQUFnQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIFB1YmxpYyBBUEkgU3VyZmFjZSBvZiBuZ3gtY29tcG9zaXRlLWxpYi9jb3JlXG4gKi9cbmV4cG9ydCAqIGZyb20gJy4vY29tbW9uL2luZGV4JzsiXX0=

package/esm2015/dimx-export/dimx.component.js

@@ -0,0 +1,241 @@
+import { __awaiter } from "tslib";
+import { Component, Input, ViewChild } from '@angular/core';
+import { saveAs } from 'file-saver';
+import { PepGuid } from '@pepperi-addons/ngx-lib';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+import * as i2 from "./dimx.service";
+import * as i3 from "@pepperi-addons/ngx-composite-lib/file-status-panel";
+import * as i4 from "@angular/common";
+export class DIMXComponent {
+    constructor(translate, addonService) {
+        this.translate = translate;
+        this.addonService = addonService;
+        this.iFileID = 0;
+        this.iFileArray = [];
+        this.toBase64 = (file) => new Promise((resolve, reject) => {
+            const reader = new FileReader();
+            reader.readAsDataURL(file);
+            reader.onload = () => resolve(reader.result);
+            reader.onerror = error => reject(error);
+        });
+    }
+    ngOnInit() {
+        // Get the first translation for load all translations.
+        this.translate.get('SHADOW_SETTINGS.INTENSITY_SOFT').toPromise().then((typeSoft) => {
+            console.log("something");
+        });
+    }
+    getDIMXExportPOSTBody(value) {
+        return {
+            "Format": value.DIMXExportFormat,
+            "IncludeDeleted": value.DIMXExportIncludeDeleted,
+            "Where": value.DIMXExportWhere,
+            "Fields": value.DIMXExportFields,
+            "Delimiter": value.DIMXExportDelimiter
+        };
+    }
+    printHello() {
+        console.log("hello");
+    }
+    pollDIMXResult(pollingURL, ifile) {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log(`polling audit with the executionUUID: ${pollingURL}`);
+            const delay = (ms) => new Promise(res => setTimeout(res, ms));
+            let seconds = 0;
+            const waitingTime = 1000; //in ms
+            try {
+                let result;
+                while (true) {
+                    result = yield this.addonService.papiClient.get(`/audit_logs/${pollingURL}`);
+                    console.log(`result from auditlog get is: ${result}`);
+                    if (!result || result["Status"]["ID"] === 2 || result["Status"]["ID"] === 4) {
+                        console.log(`waited for ${seconds++} seconds`);
+                        yield delay(waitingTime);
+                    }
+                    else {
+                        break;
+                    }
+                }
+                switch (result["Status"]["ID"]) {
+                    case 0:
+                        ifile.status = "failed";
+                        throw new Error(result["AuditInfo"]["ErrorMessage"]);
+                    case 1:
+                        console.log(`polling result: ${result["AuditInfo"]["ResultObject"]}`);
+                        return JSON.parse(result["AuditInfo"]["ResultObject"]);
+                    default:
+                        ifile.status = "failed";
+                        throw new Error(`pollDIMXResult: unknown audit log type: ${result["Status"]}`);
+                }
+            }
+            catch (ex) {
+                console.log(`pollDIMXResult: ${ex}`);
+                ifile.status = "failed";
+                throw new Error(ex.message);
+            }
+        });
+    }
+    getNewFileName(value) {
+        let extension;
+        switch (value.DIMXExportFormat.toLowerCase()) {
+            case "json":
+                extension = ".json";
+                break;
+            case "csv":
+                extension = '.csv';
+                break;
+            default:
+                extension = "";
+        }
+        const filename = value.DIMXExportFileName;
+        return filename + extension;
+    }
+    createNewIFile(fileName, status) {
+        return {
+            "key": this.iFileID++,
+            "name": fileName,
+            "status": status
+        };
+    }
+    removeIfileWithDelay(iFile, delay = 2000) {
+        return __awaiter(this, void 0, void 0, function* () {
+            window.setTimeout(() => {
+                const index = this.iFileArray.findIndex(element => element === iFile);
+                if (index >= 0) {
+                    this.iFileArray.splice(index, 1);
+                }
+            }, delay);
+        });
+    }
+    uploadf(e) {
+        const files = e.target.files;
+        const fileListAsArray = Array.from(files);
+        fileListAsArray.forEach((file, i) => {
+            const filex = file;
+        });
+    }
+    uploadFile(event, options) {
+        this.dimxImportOptions = options;
+        const elem = document.getElementById("fileuploader");
+        if (elem && document.createEvent) {
+            const evt = document.createEvent("MouseEvents");
+            evt.initEvent("click", true, false);
+            elem.dispatchEvent(evt);
+        }
+        // this.fileField?.nativeElement.click();
+    }
+    dimximportrun(e) {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log("Enter DIMXImportRun");
+            const files = e.target.files;
+            const fileListAsArray = Array.from(files);
+            fileListAsArray.forEach((file, i) => __awaiter(this, void 0, void 0, function* () {
+                const filex = file;
+                const dimx_import_relativeURL = `/addons/api/44c97115-6d14-4626-91dc-83f176e9a0fc/api/file_import_upload`;
+                const str = (yield this.toBase64(filex)); //???
+                const ext = filex.name.split('.')[1];
+                const value = { fileStr: str, fileExt: ext };
+                const dimxUploadObject = Object.assign(Object.assign(Object.assign({}, this.getPFSUploadObject(value)), this.dimxImportOptions), { Resource: this.DIMXResource, AddonUUID: this.DIMXAddonUUID });
+                const iFile = this.createNewIFile(filex.name, "uploading");
+                console.log(`created new iFile: ${iFile}`);
+                this.iFileArray.push(iFile);
+                console.log(`added iFile to iFileArray`);
+                try {
+                    console.log("posting to dimx import_upload now");
+                    const res = yield this.addonService.papiClient.post(dimx_import_relativeURL, dimxUploadObject, { "X-Pepperi-OwnerID": dimxUploadObject.OwnerID, "X-Pepperi-ActionID": dimxUploadObject.ActionID });
+                    console.log("Got reply from dimx, calling poll with the result:");
+                    console.log(res);
+                    const poll_result = yield this.pollDIMXResult(res['ExecutionUUID'], iFile);
+                    console.log(`done polling, got result: ${JSON.stringify(poll_result)}`);
+                    iFile.status = "done";
+                    console.log("Imported the file");
+                    yield this.removeIfileWithDelay(iFile);
+                }
+                catch (ex) {
+                    console.log(`DIMXImportRun: ${ex}`);
+                    iFile.status = "failed";
+                    yield this.removeIfileWithDelay(iFile, 2000);
+                    throw new Error(ex.message);
+                }
+            }));
+        });
+    }
+    getNewPFSUploadKey(fileExt) {
+        const uuid = PepGuid.newGuid();
+        const folder = 'DIMX_import';
+        const pfsKey = `/${folder}/${uuid}.${fileExt}`;
+        return pfsKey;
+    }
+    getPFSUploadObject(value) {
+        const fileStrArr = value.fileStr.split(';');
+        const mime = fileStrArr[0].split(':')[1];
+        const pfsKey = this.getNewPFSUploadKey(value.fileExt);
+        const pfsUploadObject = {
+            "Key": pfsKey,
+            "MIME": mime,
+            "URI": value.fileStr
+        };
+        return pfsUploadObject;
+    }
+    DIMXExportRun(value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!value) {
+                value = {};
+            }
+            if (!value.DIMXExportFormat) {
+                value.DIMXExportFormat = 'json';
+            }
+            if (!value.DIMXExportIncludeDeleted) {
+                value.DIMXExportIncludeDeleted = false;
+            }
+            if (!value.DIMXExportFileName) {
+                value.DIMXExportFileName = 'export';
+            }
+            const bod = this.getDIMXExportPOSTBody(value ? value : {});
+            const fileName = this.getNewFileName(value);
+            const iFile = this.createNewIFile(fileName, "downloading");
+            console.log(`created new iFile: ${iFile}`);
+            this.iFileArray.push(iFile);
+            console.log(`added iFile to iFileArray`);
+            try {
+                console.log("posting to dimx export now");
+                const res = yield this.addonService.papiClient.post(`/addons/data/export/file/${this.DIMXAddonUUID}/${this.DIMXResource}`, bod, { "X-Pepperi-ActionID": value.ActionID });
+                console.log("Got reply from dimx, calling poll with the result:");
+                console.log(res);
+                const url = (yield this.pollDIMXResult(res['ExecutionUUID'], iFile))["DownloadURL"];
+                console.log("attempting to download the file");
+                console.log(`url is: ${url}`);
+                const blob = yield fetch(url).then(r => r.blob());
+                saveAs(blob, fileName);
+                iFile.status = "done";
+                console.log("downloaded the file");
+                yield this.removeIfileWithDelay(iFile);
+            }
+            catch (ex) {
+                iFile.status = "failed";
+                yield this.removeIfileWithDelay(iFile);
+                console.log(`buttonClick: ${ex}`);
+                throw new Error(ex.message);
+            }
+        });
+    }
+}
+DIMXComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.0.5", ngImport: i0, type: DIMXComponent, deps: [{ token: i1.TranslateService }, { token: i2.DIMXService }], target: i0.ɵɵFactoryTarget.Component });
+DIMXComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.0.5", type: DIMXComponent, selector: "pep-dimx", inputs: { DIMXAddonUUID: "DIMXAddonUUID", DIMXResource: "DIMXResource" }, viewQueries: [{ propertyName: "fileField", first: true, predicate: ["fileField"], descendants: true }], ngImport: i0, template: "<pep-file-status-panel [title]=\"'File Imports/Exports'\" *ngIf=\"iFileArray?.length\" [filesList]=\"iFileArray\"></pep-file-status-panel>\n<input type=\"file\" multiple=\"multiple\" name=\"avatars\" id=\"fileuploader\" #fileField (change)=\"dimximportrun($event)\">\n<!-- <pep-button\n  value=\"export\"\n  styleType=\"strong\"\n  styleStateType=\"success\"\n  sizeType=\"sm\"\n  classNames=\"hahah\"\n  iconName=\"system_doc\"\n  (buttonClick)=\"buttonClick($event)\"\n></pep-button> -->", styles: ["#fileuploader{display:none}:host{width:100%}:host .shadow-size-group,:host .shadow-type-group{display:block;margin-bottom:var(--pep-form-spacing, 1rem)}\n"], components: [{ type: i3.FileStatusPanelComponent, selector: "pep-file-status-panel", inputs: ["title", "filesList"] }], directives: [{ type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.0.5", ngImport: i0, type: DIMXComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'pep-dimx',
+                    templateUrl: './dimx.component.html',
+                    styleUrls: ['./dimx.component.scss']
+                }]
+        }], ctorParameters: function () { return [{ type: i1.TranslateService }, { type: i2.DIMXService }]; }, propDecorators: { fileField: [{
+                type: ViewChild,
+                args: ['fileField']
+            }], DIMXAddonUUID: [{
+                type: Input
+            }], DIMXResource: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dimx.component.js","sourceRoot":"","sources":["../../../../projects/ngx-composite-lib/dimx-export/dimx.component.ts","../../../../projects/ngx-composite-lib/dimx-export/dimx.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, ElementRef, EventEmitter, Input, OnInit, Output, ViewChild } from '@angular/core';\nimport { TranslateService } from '@ngx-translate/core';\nimport { IFile } from './dimx.model';\nimport { DIMXService } from './dimx.service';\nimport { saveAs } from 'file-saver';\nimport { PepGuid } from '@pepperi-addons/ngx-lib';\n\n@Component({\n    selector: 'pep-dimx',\n    templateUrl: './dimx.component.html',\n    styleUrls: ['./dimx.component.scss']\n})\nexport class DIMXComponent implements OnInit {\n    @ViewChild('fileField') fileField:ElementRef | undefined;\n    @Input() DIMXAddonUUID!: string;\n    @Input() DIMXResource!: string;\n    dimxImportOptions: { OverwriteOBject?: boolean | undefined; Delimiter?: string | undefined; OwnerID?: string | undefined; ActionID?: string | undefined} | undefined;\n    constructor(\n        private translate: TranslateService,\n        public addonService: DIMXService\n    ) {\n\n    }\n\n\n    ngOnInit(): void { \n        // Get the first translation for load all translations.\n        this.translate.get('SHADOW_SETTINGS.INTENSITY_SOFT').toPromise().then((typeSoft) => { console.log(\"something\");\n        });\n    }\n\n    getDIMXExportPOSTBody(value:{\n        DIMXExportFormat?:string,\n        DIMXExportIncludeDeleted?: boolean,\n        DIMXExportFileName?: string,\n        DIMXExportWhere?: string,\n        DIMXExportFields?: string,\n        DIMXExportDelimiter?:string\n    }){\n        return {\n            \"Format\":value.DIMXExportFormat,\n            \"IncludeDeleted\":value.DIMXExportIncludeDeleted,\n            \"Where\":value.DIMXExportWhere,\n            \"Fields\":value.DIMXExportFields,\n            \"Delimiter\":value.DIMXExportDelimiter\n        }\n    }\n\n    printHello(){\n        console.log(\"hello\");\n    }\n\n    async pollDIMXResult(pollingURL:string, ifile:IFile){\n        console.log(`polling audit with the executionUUID: ${pollingURL}`);\n        const delay = (ms: number) => new Promise(res => setTimeout(res, ms));\n        let seconds = 0;\n        const waitingTime = 1000; //in ms\n        try{\n            let result;\n            while(true){\n                result = await this.addonService.papiClient.get(`/audit_logs/${pollingURL}`);\n        \n                console.log(`result from auditlog get is: ${result}`);\n                if( !result || result[\"Status\"][\"ID\"] === 2 || result[\"Status\"][\"ID\"] === 4){\n                    console.log(`waited for ${seconds++} seconds`);\n                    await delay(waitingTime);\n                }\n                else{\n                    break;\n                }\n            }\n            switch(result[\"Status\"][\"ID\"]){\n                case 0:\n                    ifile.status = \"failed\";\n                    throw new Error(result[\"AuditInfo\"][\"ErrorMessage\"]);\n                case 1:\n                    console.log(`polling result: ${result[\"AuditInfo\"][\"ResultObject\"]}`);\n                    return JSON.parse(result[\"AuditInfo\"][\"ResultObject\"]);\n                default:\n                    ifile.status = \"failed\";\n                    throw new Error(`pollDIMXResult: unknown audit log type: ${result[\"Status\"]}`);\n            }\n        }\n        catch(ex){\n            console.log(`pollDIMXResult: ${ex}`);\n            ifile.status = \"failed\";\n            throw new Error((ex as {message:string}).message);\n        }\n    }\n\n    getNewFileName(value:{\n        DIMXExportFormat:string,\n        DIMXExportFileName: string,\n    }){\n        let extension;\n        switch (value.DIMXExportFormat.toLowerCase()){\n            case \"json\":\n                extension = \".json\";\n                break;\n            case \"csv\":\n                extension = '.csv';\n                break;\n            default:\n                extension = \"\";\n        }\n        const filename = value.DIMXExportFileName;\n        return filename+extension;\n    }\n    \n    iFileID = 0;\n    iFileArray:IFile[] = [];\n    createNewIFile(fileName:string , status:\"downloading\"|\"uploading\"):IFile{\n        return {\n            \"key\":this.iFileID++,\n            \"name\":fileName,\n            \"status\":status};\n    }\n\n    async removeIfileWithDelay(iFile:IFile, delay = 2000) {\n        window.setTimeout(() => {\n            const index = this.iFileArray.findIndex(element => element === iFile);\n            if (index >= 0){\n                this.iFileArray.splice(index,1);\n            }\n        }, delay)\n    }\n\n\n    uploadf(e:any){\n        const files = e.target.files;\n        const fileListAsArray = Array.from(files);\n       \n        fileListAsArray.forEach((file, i) => {\n\n        const filex = (file as HTMLInputElement);\n        \n\n\n\n});\n    }\n\n    uploadFile(event:any, options?:{OverwriteOBject?:boolean, Delimiter?:string, OwnerID?:string, ActionID?:string}){\n        this.dimxImportOptions = options;\n        const elem = document.getElementById(\"fileuploader\");\n   if(elem && document.createEvent) {\n      const evt = document.createEvent(\"MouseEvents\");\n      evt.initEvent(\"click\", true, false);\n      elem.dispatchEvent(evt);\n   }\n        // this.fileField?.nativeElement.click();\n    }   \n\n\n    async dimximportrun(e:any) {\n        console.log(\"Enter DIMXImportRun\");\n        const files = e.target.files;\n        const fileListAsArray = Array.from(files);\n        fileListAsArray.forEach(async (file, i) => {\n\n        const filex = (file as HTMLInputElement);\n        const dimx_import_relativeURL = `/addons/api/44c97115-6d14-4626-91dc-83f176e9a0fc/api/file_import_upload`;\n        const str = (await this.toBase64(filex)) as string; //???\n        const ext = filex.name.split('.')[1];\n        const value = {fileStr:str, fileExt:ext}\n        const dimxUploadObject = {...this.getPFSUploadObject(value), ...this.dimxImportOptions, Resource:this.DIMXResource, AddonUUID:this.DIMXAddonUUID};\n        const iFile:IFile = this.createNewIFile(filex.name, \"uploading\");\n        console.log(`created new iFile: ${iFile}`);\n        this.iFileArray.push(iFile);\n        console.log(`added iFile to iFileArray`);\n        \n        try{\n\n            console.log(\"posting to dimx import_upload now\");\n            const res = await this.addonService.papiClient.post(dimx_import_relativeURL, dimxUploadObject, {\"X-Pepperi-OwnerID\":dimxUploadObject.OwnerID, \"X-Pepperi-ActionID\":dimxUploadObject.ActionID});\n            console.log(\"Got reply from dimx, calling poll with the result:\");\n            console.log(res);\n\n            const poll_result = await this.pollDIMXResult(res['ExecutionUUID'], iFile);\n\n            console.log(`done polling, got result: ${JSON.stringify(poll_result)}`);\n            iFile.status = \"done\";\n            console.log(\"Imported the file\");\n            await this.removeIfileWithDelay(iFile);\n\n        }\n        catch(ex){\n            console.log(`DIMXImportRun: ${ex}`);\n            iFile.status = \"failed\";\n            await this.removeIfileWithDelay(iFile, 2000);\n            throw new Error((ex as {message:string}).message);\n        }\n        \n        \n        \n        });\n    }\n    getNewPFSUploadKey(fileExt:string){\n        const uuid = PepGuid.newGuid();\n        const folder = 'DIMX_import';\n        const pfsKey = `/${folder}/${uuid}.${fileExt}`;\n        return pfsKey;\n    }\n    getPFSUploadObject(value:{fileStr:string, fileExt:string}){\n        const fileStrArr = value.fileStr.split(';');\n        const mime = fileStrArr[0].split(':')[1];\n        const pfsKey = this.getNewPFSUploadKey(value.fileExt);\n        const pfsUploadObject = {\n            \"Key\": pfsKey,\n            \"MIME\": mime,\n            \"URI\":value.fileStr\n        }\n        return pfsUploadObject;\n    }\n\n    toBase64 = (file:any) => new Promise((resolve, reject) => {\n\n        const reader = new FileReader();\n        \n        reader.readAsDataURL(file);\n        \n        reader.onload = () => resolve(reader.result);\n        \n        reader.onerror = error => reject(error);\n        \n        });\n\n    async DIMXExportRun(value: {\n        DIMXExportFormat?:string,\n        DIMXExportIncludeDeleted?: boolean,\n        DIMXExportFileName?: string,\n        DIMXExportWhere?: string,\n        DIMXExportFields?: string,\n        DIMXExportDelimiter?:string,\n        ActionID?:string\n    }) {\n        if (!value){\n            value = {};\n        }\n        if (!value.DIMXExportFormat){\n            value.DIMXExportFormat = 'json';\n        }\n        if (!value.DIMXExportIncludeDeleted){\n            value.DIMXExportIncludeDeleted = false;\n        }\n        if (!value.DIMXExportFileName){\n            value.DIMXExportFileName = 'export';\n        }\n        const bod = this.getDIMXExportPOSTBody(value ? value : {});\n        const fileName = this.getNewFileName(value as {DIMXExportFormat:string, DIMXExportFileName:string});\n        const iFile:IFile = this.createNewIFile(fileName, \"downloading\");\n        console.log(`created new iFile: ${iFile}`);\n        this.iFileArray.push(iFile);\n        console.log(`added iFile to iFileArray`);\n     \n        try{\n\n            console.log(\"posting to dimx export now\");\n            const res = await this.addonService.papiClient.post(`/addons/data/export/file/${this.DIMXAddonUUID}/${this.DIMXResource}`, bod, {\"X-Pepperi-ActionID\":value.ActionID});\n            console.log(\"Got reply from dimx, calling poll with the result:\");\n            console.log(res);\n\n            const url = (await this.pollDIMXResult(res['ExecutionUUID'], iFile))[\"DownloadURL\"];\n\n            console.log(\"attempting to download the file\");\n            console.log(`url is: ${url}`);\n            const blob = await fetch(url).then(r => r.blob());\n            saveAs(blob, fileName);\n            iFile.status = \"done\";\n            console.log(\"downloaded the file\");\n            await this.removeIfileWithDelay(iFile);\n        }\n        catch(ex){\n            iFile.status= \"failed\";\n            await this.removeIfileWithDelay(iFile);\n            console.log(`buttonClick: ${ex}`);\n            throw new Error((ex as {message:string}).message);\n        }\n        \n    }\n\n   \n\n   \n}\n","<pep-file-status-panel [title]=\"'File Imports/Exports'\" *ngIf=\"iFileArray?.length\" [filesList]=\"iFileArray\"></pep-file-status-panel>\n<input type=\"file\" multiple=\"multiple\" name=\"avatars\" id=\"fileuploader\" #fileField (change)=\"dimximportrun($event)\">\n<!-- <pep-button\n  value=\"export\"\n  styleType=\"strong\"\n  styleStateType=\"success\"\n  sizeType=\"sm\"\n  classNames=\"hahah\"\n  iconName=\"system_doc\"\n  (buttonClick)=\"buttonClick($event)\"\n></pep-button> -->"]}

package/esm2015/dimx-export/dimx.model.js

@@ -0,0 +1,8 @@
+export class IFile {
+    constructor() {
+        this.key = 0;
+        this.name = '';
+        this.status = 'downloading';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGlteC5tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1jb21wb3NpdGUtbGliL2RpbXgtZXhwb3J0L2RpbXgubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsTUFBTSxPQUFPLEtBQUs7SUFBbEI7UUFDSSxRQUFHLEdBQUcsQ0FBQyxDQUFDO1FBQ1IsU0FBSSxHQUFHLEVBQUUsQ0FBQztRQUNWLFdBQU0sR0FBZSxhQUFhLENBQUM7SUFDbkMsQ0FBQztDQUFBIiwic291cmNlc0NvbnRlbnQiOlsidHlwZSBmaWxlU3RhdHVzID0gJ3VwbG9hZGluZyd8J2Rvd25sb2FkaW5nJ3wnZG9uZSd8J2ZhaWxlZCd8J2hpZGRlbic7XG5leHBvcnQgY2xhc3MgSUZpbGUge1xuICAgIGtleSA9IDA7XG4gICAgbmFtZSA9ICcnO1xuICAgIHN0YXR1czogZmlsZVN0YXR1cyA9ICdkb3dubG9hZGluZyc7XG4gICAgfSJdfQ==

package/esm2015/dimx-export/dimx.module.js

@@ -0,0 +1,49 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { PepNgxLibModule } from '@pepperi-addons/ngx-lib';
+import { DIMXComponent } from './dimx.component';
+import { pepIconSystemDoc } from '@pepperi-addons/ngx-lib/icon';
+import { PepButtonModule } from '@pepperi-addons/ngx-lib/button';
+import { PepIconModule } from '@pepperi-addons/ngx-lib/icon';
+import { PepFileStatusPanelModule } from '@pepperi-addons/ngx-composite-lib/file-status-panel';
+import * as i0 from "@angular/core";
+import * as i1 from "@pepperi-addons/ngx-lib/icon";
+const pepIcons = [
+    pepIconSystemDoc,
+];
+export class PepDIMXModule {
+    constructor(pepIconRegistry) {
+        this.pepIconRegistry = pepIconRegistry;
+        this.pepIconRegistry.registerIcons(pepIcons);
+    }
+}
+PepDIMXModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.0.5", ngImport: i0, type: PepDIMXModule, deps: [{ token: i1.PepIconRegistry }], target: i0.ɵɵFactoryTarget.NgModule });
+PepDIMXModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.0.5", ngImport: i0, type: PepDIMXModule, declarations: [DIMXComponent], imports: [CommonModule,
+        PepNgxLibModule,
+        PepButtonModule,
+        PepIconModule,
+        PepFileStatusPanelModule], exports: [DIMXComponent] });
+PepDIMXModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.0.5", ngImport: i0, type: PepDIMXModule, imports: [[
+            CommonModule,
+            PepNgxLibModule,
+            PepButtonModule,
+            PepIconModule,
+            PepFileStatusPanelModule,
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.0.5", ngImport: i0, type: PepDIMXModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        DIMXComponent
+                    ],
+                    imports: [
+                        CommonModule,
+                        PepNgxLibModule,
+                        PepButtonModule,
+                        PepIconModule,
+                        PepFileStatusPanelModule,
+                    ],
+                    exports: [DIMXComponent]
+                }]
+        }], ctorParameters: function () { return [{ type: i1.PepIconRegistry }]; } });
+//# sourceMappingURL=data:application/json;base64,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