ngx-ode-ui 4.6.0-dev-produit.2 → 4.6.0-dev-integration.2

package/esm2015/lib/directives/drag-and-drop-files.directive.js

@@ -0,0 +1,126 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/directives/drag-and-drop-files.directive.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { Directive, EventEmitter, HostBinding, HostListener, Input, Output } from '@angular/core';
+import { InputFileService } from '../services/inputFile.service';
+export class DragAndDropFilesDirective {
+    /**
+     * @param {?} inputFileService
+     */
+    constructor(inputFileService) {
+        this.inputFileService = inputFileService;
+        this.allowedExtensions = [];
+        this.maxFilesNumber = 1;
+        this.dragAndDrop = new EventEmitter();
+        this.invalidDragAndDrop = new EventEmitter();
+        this.backgroundColor = '#fafafa';
+        this.borderColor = '#ddd';
+    }
+    /**
+     * @param {?} evt
+     * @return {?}
+     */
+    onDragOver(evt) {
+        if (!this.disabled) {
+            evt.preventDefault();
+            evt.stopPropagation();
+            this.highlightColors();
+        }
+    }
+    /**
+     * @param {?} evt
+     * @return {?}
+     */
+    onDragLeave(evt) {
+        if (!this.disabled) {
+            evt.preventDefault();
+            evt.stopPropagation();
+            this.resetColors();
+        }
+    }
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    onDrop(event) {
+        if (!this.disabled) {
+            event.preventDefault();
+            event.stopPropagation();
+            if (event.dataTransfer) {
+                this.inputFileService
+                    .validateFiles(event.dataTransfer.files, this.maxFilesNumber, this.allowedExtensions)
+                    .subscribe((/**
+                 * @param {?} files
+                 * @return {?}
+                 */
+                files => this.dragAndDrop.emit(files)), (/**
+                 * @param {?} error
+                 * @return {?}
+                 */
+                error => this.invalidDragAndDrop.emit(error)));
+            }
+            this.resetColors();
+        }
+    }
+    /**
+     * @private
+     * @return {?}
+     */
+    resetColors() {
+        this.backgroundColor = '#fafafa';
+        this.borderColor = '#ddd';
+    }
+    /**
+     * @private
+     * @return {?}
+     */
+    highlightColors() {
+        this.backgroundColor = '#ffd1b6';
+        this.borderColor = '#ff8352';
+    }
+}
+DragAndDropFilesDirective.decorators = [
+    { type: Directive, args: [{
+                selector: '[dragAndDropFiles]'
+            },] }
+];
+/** @nocollapse */
+DragAndDropFilesDirective.ctorParameters = () => [
+    { type: InputFileService }
+];
+DragAndDropFilesDirective.propDecorators = {
+    allowedExtensions: [{ type: Input }],
+    maxFilesNumber: [{ type: Input }],
+    disabled: [{ type: Input }],
+    dragAndDrop: [{ type: Output }],
+    invalidDragAndDrop: [{ type: Output }],
+    backgroundColor: [{ type: HostBinding, args: ['style.background',] }],
+    borderColor: [{ type: HostBinding, args: ['style.border-color',] }],
+    onDragOver: [{ type: HostListener, args: ['dragover', ['$event'],] }],
+    onDragLeave: [{ type: HostListener, args: ['dragleave', ['$event'],] }],
+    onDrop: [{ type: HostListener, args: ['drop', ['$event'],] }]
+};
+if (false) {
+    /** @type {?} */
+    DragAndDropFilesDirective.prototype.allowedExtensions;
+    /** @type {?} */
+    DragAndDropFilesDirective.prototype.maxFilesNumber;
+    /** @type {?} */
+    DragAndDropFilesDirective.prototype.disabled;
+    /** @type {?} */
+    DragAndDropFilesDirective.prototype.dragAndDrop;
+    /** @type {?} */
+    DragAndDropFilesDirective.prototype.invalidDragAndDrop;
+    /** @type {?} */
+    DragAndDropFilesDirective.prototype.backgroundColor;
+    /** @type {?} */
+    DragAndDropFilesDirective.prototype.borderColor;
+    /**
+     * @type {?}
+     * @private
+     */
+    DragAndDropFilesDirective.prototype.inputFileService;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/directives/dynamic-component/component-descriptor.model.js

@@ -0,0 +1,34 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/directives/dynamic-component/component-descriptor.model.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * Usefull to desccribe (type and input data) a component
+ * that will be dynamically instanciate
+ */
+export class ComponentDescriptor {
+    /**
+     * @param {?} type
+     * @param {?} data
+     */
+    constructor(type, data) {
+        this.type = type;
+        this.data = data;
+    }
+    /**
+     * @param {?} data
+     * @return {?}
+     */
+    assignData(data) {
+        Object.assign(this.data, data);
+        return this;
+    }
+}
+if (false) {
+    /** @type {?} */
+    ComponentDescriptor.prototype.type;
+    /** @type {?} */
+    ComponentDescriptor.prototype.data;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcG9uZW50LWRlc2NyaXB0b3IubW9kZWwuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9uZ3gtb2RlLXVpLyIsInNvdXJjZXMiOlsibGliL2RpcmVjdGl2ZXMvZHluYW1pYy1jb21wb25lbnQvY29tcG9uZW50LWRlc2NyaXB0b3IubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7O0FBTUEsTUFBTSxPQUFPLG1CQUFtQjs7Ozs7SUFDN0IsWUFDVyxJQUFlLEVBQ2YsSUFBUztRQURULFNBQUksR0FBSixJQUFJLENBQVc7UUFDZixTQUFJLEdBQUosSUFBSSxDQUFLO0lBQ2pCLENBQUM7Ozs7O0lBRUosVUFBVSxDQUFDLElBQVM7UUFDaEIsTUFBTSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsSUFBSSxFQUFFLElBQUksQ0FBQyxDQUFDO1FBQy9CLE9BQU8sSUFBSSxDQUFDO0lBQ2hCLENBQUM7Q0FDSDs7O0lBUk0sbUNBQXNCOztJQUN0QixtQ0FBZ0IiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge1R5cGV9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG4vKipcbiogVXNlZnVsbCB0byBkZXNjY3JpYmUgKHR5cGUgYW5kIGlucHV0IGRhdGEpIGEgY29tcG9uZW50XG4qIHRoYXQgd2lsbCBiZSBkeW5hbWljYWxseSBpbnN0YW5jaWF0ZVxuKi9cbmV4cG9ydCBjbGFzcyBDb21wb25lbnREZXNjcmlwdG9yIHtcbiAgIGNvbnN0cnVjdG9yKFxuICAgICAgIHB1YmxpYyB0eXBlOiBUeXBlPGFueT4sXG4gICAgICAgcHVibGljIGRhdGE6IGFueVxuICAgKSB7fVxuXG4gICBhc3NpZ25EYXRhKGRhdGE6IGFueSk6IENvbXBvbmVudERlc2NyaXB0b3Ige1xuICAgICAgIE9iamVjdC5hc3NpZ24odGhpcy5kYXRhLCBkYXRhKTtcbiAgICAgICByZXR1cm4gdGhpcztcbiAgIH1cbn1cbiJdfQ==

package/esm2015/lib/directives/dynamic-component/dynamic-component.directive.js

@@ -0,0 +1,100 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/directives/dynamic-component/dynamic-component.directive.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { ComponentFactoryResolver, Directive, Input, ViewContainerRef, } from '@angular/core';
+import { ComponentDescriptor } from './component-descriptor.model';
+/**
+ * Dynamically load the component describe with the \@input dynamic-component
+ */
+export class DynamicComponentDirective {
+    /**
+     * @param {?} viewContainerRef
+     * @param {?} componentFactoryResolver
+     */
+    constructor(viewContainerRef, componentFactoryResolver) {
+        this.viewContainerRef = viewContainerRef;
+        this.componentFactoryResolver = componentFactoryResolver;
+    }
+    /**
+     * @param {?=} data
+     * @return {?}
+     */
+    load(data) {
+        if (this.isLoaded()) {
+            return;
+        }
+        /** @type {?} */
+        const componentFactory = this.componentFactoryResolver.resolveComponentFactory(this.componentDesc.type);
+        this.viewContainerRef.clear();
+        this.componentRef = this.viewContainerRef.createComponent(componentFactory);
+        if (data != undefined) {
+            this.componentDesc.assignData(data);
+        }
+        for (const attribute in this.componentDesc.data) {
+            this.componentRef.instance[attribute] = this.componentDesc.data[attribute];
+            if (attribute == 'hideEvent') {
+                this.componentRef.instance.hideEvent.subscribe((/**
+                 * @param {?} e
+                 * @return {?}
+                 */
+                e => {
+                    this.destroy();
+                }));
+            }
+        }
+    }
+    /**
+     * @return {?}
+     */
+    isLoaded() {
+        if (this.componentRef == undefined) {
+            return false;
+        }
+        else {
+            return this.componentRef.instance != null;
+        }
+    }
+    /**
+     * @return {?}
+     */
+    destroy() {
+        if (this.componentRef.instance.hideEvent != undefined) {
+            this.componentRef.instance.hideEvent.unsubscribe();
+        }
+        // FIXME: this.componentRef.destroy(); => This one usually should work, better to use but do nothing...
+        delete this.componentRef;
+        this.viewContainerRef.clear();
+    }
+}
+DynamicComponentDirective.decorators = [
+    { type: Directive, args: [{
+                selector: '[dynamic-component]',
+            },] }
+];
+/** @nocollapse */
+DynamicComponentDirective.ctorParameters = () => [
+    { type: ViewContainerRef },
+    { type: ComponentFactoryResolver }
+];
+DynamicComponentDirective.propDecorators = {
+    componentDesc: [{ type: Input, args: ['dynamic-component',] }]
+};
+if (false) {
+    /** @type {?} */
+    DynamicComponentDirective.prototype.componentRef;
+    /** @type {?} */
+    DynamicComponentDirective.prototype.componentDesc;
+    /**
+     * @type {?}
+     * @private
+     */
+    DynamicComponentDirective.prototype.viewContainerRef;
+    /**
+     * @type {?}
+     * @private
+     */
+    DynamicComponentDirective.prototype.componentFactoryResolver;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/directives/dynamictemplate.directive.js

@@ -0,0 +1,159 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/directives/dynamictemplate.directive.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { Compiler, Component, Directive, ElementRef, Input, NgModule, Injector, ViewContainerRef } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { DynamicModuleImportsService } from '../services/dynamicModuleImports.service';
+export class DynamicTemplateDirective {
+    /**
+     * @param {?} elementRef
+     * @param {?} viewContainer
+     * @param {?} compiler
+     * @param {?} dynamicModuleImports
+     */
+    constructor(elementRef, viewContainer, compiler, dynamicModuleImports) {
+        this.elementRef = elementRef;
+        this.viewContainer = viewContainer;
+        this.compiler = compiler;
+        this.dynamicModuleImports = dynamicModuleImports;
+        this._html = '';
+        this._selector = 'dynamic-view';
+    }
+    /**
+     * @param {?} html
+     * @return {?}
+     */
+    set templateContents(html) {
+        if (html) {
+            this._html = html;
+            /** @type {?} */
+            const cmpType = this._createDynamicComponent();
+            /** @type {?} */
+            const moduleType = this._createDynamicModule(cmpType);
+            /** @type {?} */
+            const injector = Injector.create({
+                providers: [],
+                parent: this.viewContainer.parentInjector,
+            });
+            this.compiler.compileModuleAndAllComponentsAsync(moduleType)
+                .then((/**
+             * @param {?} factory
+             * @return {?}
+             */
+            factory => {
+                /** @type {?} */
+                let cmpFactory;
+                for (let i = factory.componentFactories.length - 1; i >= 0; i--) {
+                    if (factory.componentFactories[i].selector === this._selector) {
+                        cmpFactory = factory.componentFactories[i];
+                        break;
+                    }
+                }
+                return cmpFactory;
+            }))
+                .then((/**
+             * @param {?} cmpFactory
+             * @return {?}
+             */
+            cmpFactory => {
+                if (cmpFactory && this.viewContainer) {
+                    this.viewContainer.clear();
+                    this.viewContainer.createComponent(cmpFactory, 0, injector);
+                }
+            }));
+        }
+        else {
+            this._html = '';
+            this.viewContainer.clear();
+        }
+    }
+    /**
+     * @private
+     * @return {?}
+     */
+    _createDynamicComponent() {
+        /** @type {?} */
+        const metadata = {
+            selector: this._selector,
+            template: this._html,
+            inputs: ['template']
+        };
+        class _cmp_ {
+        }
+        _cmp_.prototype = this.context;
+        return Component(metadata)(_cmp_);
+    }
+    /**
+     * @private
+     * @param {?} componentType
+     * @return {?}
+     */
+    _createDynamicModule(componentType) {
+        class _mod_ {
+        }
+        return NgModule({
+            imports: [
+                CommonModule,
+                ...this.dynamicModuleImports.imports
+            ],
+            declarations: [componentType],
+            providers: []
+        })(_mod_);
+    }
+}
+DynamicTemplateDirective.decorators = [
+    { type: Directive, args: [{
+                selector: 'dynamic-template'
+            },] }
+];
+/** @nocollapse */
+DynamicTemplateDirective.ctorParameters = () => [
+    { type: ElementRef },
+    { type: ViewContainerRef },
+    { type: Compiler },
+    { type: DynamicModuleImportsService }
+];
+DynamicTemplateDirective.propDecorators = {
+    templateContents: [{ type: Input, args: ['template',] }],
+    context: [{ type: Input }]
+};
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    DynamicTemplateDirective.prototype._html;
+    /**
+     * @type {?}
+     * @private
+     */
+    DynamicTemplateDirective.prototype._selector;
+    /**
+     * @type {?}
+     * @private
+     */
+    DynamicTemplateDirective.prototype.context;
+    /**
+     * @type {?}
+     * @private
+     */
+    DynamicTemplateDirective.prototype.elementRef;
+    /**
+     * @type {?}
+     * @private
+     */
+    DynamicTemplateDirective.prototype.viewContainer;
+    /**
+     * @type {?}
+     * @private
+     */
+    DynamicTemplateDirective.prototype.compiler;
+    /**
+     * @type {?}
+     * @private
+     */
+    DynamicTemplateDirective.prototype.dynamicModuleImports;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/directives/object-url.directive.js

@@ -0,0 +1,53 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/directives/object-url.directive.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { Directive, ElementRef } from '@angular/core';
+/**
+ *
+ * see https://developer.mozilla.org/en-US/docs/Web/API/URL/createObjectURL
+ */
+export class ObjectURLDirective {
+    /**
+     * @param {?} elementRef
+     */
+    constructor(elementRef) {
+        this.elementRef = elementRef;
+    }
+    // TODO provide more specific method like createJSON, createCSV, createPDF
+    // to free directive consumer from using Blog API
+    /**
+     * @param {?} blob
+     * @param {?} filename
+     * @return {?}
+     */
+    create(blob, filename) {
+        if (this.objectURL !== null) {
+            window.URL.revokeObjectURL(this.objectURL);
+        }
+        this.objectURL = window.URL.createObjectURL(blob);
+        this.elementRef.nativeElement.href = this.objectURL;
+        this.elementRef.nativeElement.download = filename;
+    }
+}
+ObjectURLDirective.decorators = [
+    { type: Directive, args: [{ selector: '[object-url]' },] }
+];
+/** @nocollapse */
+ObjectURLDirective.ctorParameters = () => [
+    { type: ElementRef }
+];
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    ObjectURLDirective.prototype.objectURL;
+    /**
+     * @type {?}
+     * @private
+     */
+    ObjectURLDirective.prototype.elementRef;
+}
+//# sourceMappingURL=data:application/json;base64,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