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

package/esm5/lib/components/table/pager.component.js

@@ -0,0 +1,113 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/components/table/pager.component.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+import { OdeComponent } from 'ngx-ode-core';
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, Injector } from '@angular/core';
+import { BundlesService } from 'ngx-ode-sijil';
+var PagerComponent = /** @class */ (function (_super) {
+    tslib_1.__extends(PagerComponent, _super);
+    function PagerComponent(injector, bundles) {
+        var _this = _super.call(this, injector) || this;
+        _this.bundles = bundles;
+        _this.offsetChange = new EventEmitter();
+        _this.translate = (/**
+         * @param {...?} args
+         * @return {?}
+         */
+        function () {
+            var _a;
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            return (_a = _this.bundles).translate.apply(_a, tslib_1.__spread(args));
+        });
+        return _this;
+    }
+    /**
+     * @return {?}
+     */
+    PagerComponent.prototype.ngOnInit = /**
+     * @return {?}
+     */
+    function () { };
+    /**
+     * @return {?}
+     */
+    PagerComponent.prototype.previousPage = /**
+     * @return {?}
+     */
+    function () {
+        if (this.offset - this.limit >= 0) {
+            this.offset = this.offset - this.limit;
+        }
+        else {
+            this.offset = 0;
+        }
+        this.offsetChange.emit(this.offset);
+    };
+    /**
+     * @return {?}
+     */
+    PagerComponent.prototype.nextPage = /**
+     * @return {?}
+     */
+    function () {
+        if (this.offset + this.limit <= this.total) {
+            this.offset = this.offset + this.limit;
+        }
+        this.offsetChange.emit(this.offset);
+    };
+    /**
+     * @return {?}
+     */
+    PagerComponent.prototype.offsetLimit = /**
+     * @return {?}
+     */
+    function () {
+        return this.offset + this.limit < this.total ?
+            this.offset + this.limit : this.total;
+    };
+    PagerComponent.decorators = [
+        { type: Component, args: [{
+                    selector: 'ode-pager',
+                    template: "<strong><s5l>pager.page</s5l></strong>\n<a class=\"button\" [ngClass]=\"{'is-hidden': offset - limit < 0}\" (click)=\"previousPage()\">\n  <i class=\"fa fa-chevron-left\"></i> <s5l>pager.page.previous</s5l>\n</a>\n<span>{{\"pager.position\" | translate : {offset : offset+1,  offsetLimit:offsetLimit(), total:total} }}</span>\n<a class=\"button\" [ngClass]=\"{'is-hidden': offset + limit  > total}\" (click)=\"nextPage()\">\n  <s5l>pager.page.next</s5l> <i class=\"fa fa-chevron-right\"></i>\n</a>\n",
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    styles: ["\n        i {cursor: pointer; padding: 0 2px;}\n    "]
+                }] }
+    ];
+    /** @nocollapse */
+    PagerComponent.ctorParameters = function () { return [
+        { type: Injector },
+        { type: BundlesService }
+    ]; };
+    PagerComponent.propDecorators = {
+        limit: [{ type: Input }],
+        offset: [{ type: Input }],
+        offsetChange: [{ type: Output }],
+        total: [{ type: Input }]
+    };
+    return PagerComponent;
+}(OdeComponent));
+export { PagerComponent };
+if (false) {
+    /** @type {?} */
+    PagerComponent.prototype.limit;
+    /** @type {?} */
+    PagerComponent.prototype.offset;
+    /** @type {?} */
+    PagerComponent.prototype.offsetChange;
+    /** @type {?} */
+    PagerComponent.prototype.total;
+    /** @type {?} */
+    PagerComponent.prototype.translate;
+    /**
+     * @type {?}
+     * @private
+     */
+    PagerComponent.prototype.bundles;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/components/tooltip/tooltip.component.js

@@ -0,0 +1,188 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/components/tooltip/tooltip.component.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+import { OdeComponent } from 'ngx-ode-core';
+import { Component, ElementRef, Input, Renderer2, Injector } from '@angular/core';
+var TooltipComponent = /** @class */ (function (_super) {
+    tslib_1.__extends(TooltipComponent, _super);
+    function TooltipComponent(injector, ref, renderer) {
+        var _this = _super.call(this, injector) || this;
+        _this.ref = ref;
+        _this.renderer = renderer;
+        _this.position = 'bottom';
+        _this.offset = 5;
+        _this.onTransitionEnd = (/**
+         * @return {?}
+         */
+        function () {
+            if (_this.tooltipElt && !_this.tooltipElt.classList.contains('shown')) {
+                _this.tooltipElt.parentNode.removeChild(_this.tooltipElt);
+                _this.tooltipElt = null;
+            }
+        });
+        return _this;
+    }
+    /**
+     * @return {?}
+     */
+    TooltipComponent.prototype.onMouseEnter = /**
+     * @return {?}
+     */
+    function () {
+        /** @type {?} */
+        var r = this.renderer;
+        if (!this.tooltipElt) {
+            this.tooltipElt = this.renderer.createElement('div');
+            /** @type {?} */
+            var tooltipText = this.renderer.createText(this.tooltipContents);
+            this.renderer.appendChild(this.tooltipElt, tooltipText);
+            this.renderer.addClass(this.tooltipElt, "tooltip");
+            this.renderer.appendChild(document.getElementsByTagName('body')[0], this.tooltipElt);
+        }
+        /** @type {?} */
+        var tip = this.tooltipElt;
+        /** @type {?} */
+        var pos = this.getPosition(this.ref.nativeElement, tip, this.position);
+        for (var prop in pos) {
+            this.renderer.setStyle(tip, prop, pos[prop] + 'px');
+        }
+        this.renderer.addClass(tip, 'shown');
+    };
+    /**
+     * @return {?}
+     */
+    TooltipComponent.prototype.onMouseLeave = /**
+     * @return {?}
+     */
+    function () {
+        /** @type {?} */
+        var wait = this.tooltipElt &&
+            parseFloat(window.getComputedStyle(this.tooltipElt)['transition-duration']);
+        this.renderer.removeClass(this.tooltipElt, 'shown');
+        setTimeout(this.onTransitionEnd, wait * 1000);
+    };
+    /**
+     * @private
+     * @param {?} elt
+     * @param {?} tip
+     * @param {?} pos
+     * @return {?}
+     */
+    TooltipComponent.prototype.getPosition = /**
+     * @private
+     * @param {?} elt
+     * @param {?} tip
+     * @param {?} pos
+     * @return {?}
+     */
+    function (elt, tip, pos) {
+        /** @type {?} */
+        var rect = {
+            top: elt.getBoundingClientRect().top + window.scrollY,
+            left: elt.getBoundingClientRect().left + window.scrollX
+        };
+        /** @type {?} */
+        var left;
+        /** @type {?} */
+        var top;
+        switch (pos) {
+            case 'top':
+                top = rect.top - tip.offsetHeight - this.offset;
+                left = rect.left + elt.offsetWidth / 2 - tip.offsetWidth / 2;
+                break;
+            case 'left':
+                top = rect.top + elt.offsetHeight / 2 - tip.offsetHeight / 2;
+                left = rect.left - tip.offsetWidth - this.offset;
+                break;
+            case 'right':
+                top = rect.top + elt.offsetHeight / 2 - tip.offsetHeight / 2;
+                left = rect.left + elt.offsetWidth + this.offset;
+                break;
+            case 'bottom':
+            default:
+                top = rect.top + elt.offsetHeight + this.offset;
+                left = rect.left + elt.offsetWidth / 2 - tip.offsetWidth / 2;
+        }
+        if (left < 0) {
+            left = rect.left + elt.offsetWidth + this.offset;
+        }
+        if (top < 0) {
+            top = rect.top + elt.offsetHeight + this.offset;
+        }
+        if (left + tip.offsetWidth >= window.pageXOffset + window.innerWidth) {
+            left = rect.left - tip.offsetWidth - this.offset;
+        }
+        if (top - tip.offsetHeight >= window.pageYOffset + window.innerHeight) {
+            top = rect.top - tip.offsetHeight - this.offset;
+        }
+        return {
+            top: top < 5 ? 5 : top,
+            left: left < 5 ? 5 : left
+        };
+    };
+    /**
+     * @return {?}
+     */
+    TooltipComponent.prototype.ngOnDestroy = /**
+     * @return {?}
+     */
+    function () {
+        if (this.tooltipElt) {
+            this.tooltipElt.parentNode.removeChild(this.tooltipElt);
+            this.tooltipElt = null;
+        }
+    };
+    TooltipComponent.decorators = [
+        { type: Component, args: [{
+                    selector: '[tooltip]',
+                    template: "<ng-content></ng-content>",
+                    host: {
+                        '(mouseenter)': 'onMouseEnter()',
+                        '(mouseleave)': 'onMouseLeave()'
+                    },
+                    styles: ["body>div.tooltip{position:absolute;z-index:100}"]
+                }] }
+    ];
+    /** @nocollapse */
+    TooltipComponent.ctorParameters = function () { return [
+        { type: Injector },
+        { type: ElementRef },
+        { type: Renderer2 }
+    ]; };
+    TooltipComponent.propDecorators = {
+        tooltipContents: [{ type: Input, args: ['tooltip',] }],
+        position: [{ type: Input }],
+        offset: [{ type: Input }]
+    };
+    return TooltipComponent;
+}(OdeComponent));
+export { TooltipComponent };
+if (false) {
+    /** @type {?} */
+    TooltipComponent.prototype.tooltipContents;
+    /** @type {?} */
+    TooltipComponent.prototype.position;
+    /** @type {?} */
+    TooltipComponent.prototype.offset;
+    /**
+     * @type {?}
+     * @private
+     */
+    TooltipComponent.prototype.tooltipElt;
+    /** @type {?} */
+    TooltipComponent.prototype.onTransitionEnd;
+    /**
+     * @type {?}
+     * @private
+     */
+    TooltipComponent.prototype.ref;
+    /**
+     * @type {?}
+     * @private
+     */
+    TooltipComponent.prototype.renderer;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tooltip.component.js","sourceRoot":"ng://ngx-ode-ui/","sources":["lib/components/tooltip/tooltip.component.ts"],"names":[],"mappings":";;;;;;AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAElF;IASsC,4CAAY;IAE9C,0BAAY,QAAkB,EACV,GAAe,EACf,QAAmB;QAFvC,YAGgB,kBAAM,QAAQ,CAAC,SAClB;QAHO,SAAG,GAAH,GAAG,CAAY;QACf,cAAQ,GAAR,QAAQ,CAAW;QAK9B,cAAQ,GAAwC,QAAQ,CAAC;QACzD,YAAM,GAAG,CAAC,CAAC;QA6BpB,qBAAe;;;QAAG;YACd,IAAI,KAAI,CAAC,UAAU,IAAI,CAAC,KAAI,CAAC,UAAU,CAAC,SAAS,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE;gBACjE,KAAI,CAAC,UAAU,CAAC,UAAU,CAAC,WAAW,CAAC,KAAI,CAAC,UAAU,CAAC,CAAC;gBACxD,KAAI,CAAC,UAAU,GAAG,IAAI,CAAC;aAC1B;QACL,CAAC,EAAA;;IAtCW,CAAC;;;;IAQb,uCAAY;;;IAAZ;;YACU,CAAC,GAAG,IAAI,CAAC,QAAQ;QAEvB,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE;YAClB,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;;gBACjD,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,eAAe,CAAC;YAChE,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,EAAE,WAAW,CAAC,CAAC;YACxD,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC;YACnD,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,QAAQ,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;SACxF;;YACK,GAAG,GAAG,IAAI,CAAC,UAAU;;YACrB,GAAG,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,aAAa,EAAE,GAAG,EAAE,IAAI,CAAC,QAAQ,CAAC;QACxE,KAAK,IAAM,IAAI,IAAI,GAAG,EAAE;YACpB,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,EAAE,IAAI,EAAE,GAAG,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;SACvD;QACD,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;IACzC,CAAC;;;;IAED,uCAAY;;;IAAZ;;YACU,IAAI,GAAG,IAAI,CAAC,UAAU;YACxB,UAAU,CAAC,MAAM,CAAC,gBAAgB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,qBAAqB,CAAC,CAAC;QAC/E,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;QACpD,UAAU,CAAC,IAAI,CAAC,eAAe,EAAE,IAAI,GAAG,IAAI,CAAC,CAAC;IAClD,CAAC;;;;;;;;IASO,sCAAW;;;;;;;IAAnB,UAAoB,GAAG,EAAE,GAAG,EAAE,GAAG;;YACvB,IAAI,GAAG;YACT,GAAG,EAAE,GAAG,CAAC,qBAAqB,EAAE,CAAC,GAAG,GAAG,MAAM,CAAC,OAAO;YACrD,IAAI,EAAE,GAAG,CAAC,qBAAqB,EAAE,CAAC,IAAI,GAAG,MAAM,CAAC,OAAO;SAC1D;;YACG,IAAI;;YAAE,GAAG;QAEb,QAAQ,GAAG,EAAE;YAET,KAAK,KAAK;gBACN,GAAG,GAAG,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC,YAAY,GAAG,IAAI,CAAC,MAAM,CAAC;gBAChD,IAAI,GAAG,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC,WAAW,GAAG,CAAC,GAAG,GAAG,CAAC,WAAW,GAAG,CAAC,CAAC;gBAC7D,MAAM;YACV,KAAK,MAAM;gBACP,GAAG,GAAG,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC,YAAY,GAAG,CAAC,GAAG,GAAG,CAAC,YAAY,GAAG,CAAC,CAAC;gBAC7D,IAAI,GAAG,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC,WAAW,GAAG,IAAI,CAAC,MAAM,CAAC;gBACjD,MAAM;YACV,KAAK,OAAO;gBACR,GAAG,GAAG,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC,YAAY,GAAG,CAAC,GAAG,GAAG,CAAC,YAAY,GAAG,CAAC,CAAC;gBAC7D,IAAI,GAAG,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC,WAAW,GAAG,IAAI,CAAC,MAAM,CAAC;gBACjD,MAAM;YACV,KAAK,QAAQ,CAAC;YACd;gBACI,GAAG,GAAG,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC,YAAY,GAAG,IAAI,CAAC,MAAM,CAAC;gBAChD,IAAI,GAAG,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC,WAAW,GAAG,CAAC,GAAG,GAAG,CAAC,WAAW,GAAG,CAAC,CAAC;SACpE;QAED,IAAI,IAAI,GAAG,CAAC,EAAG;YACX,IAAI,GAAG,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC,WAAW,GAAG,IAAI,CAAC,MAAM,CAAC;SACpD;QACD,IAAI,GAAG,GAAG,CAAC,EAAE;YACT,GAAG,GAAG,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC,YAAY,GAAG,IAAI,CAAC,MAAM,CAAC;SACnD;QACD,IAAI,IAAI,GAAG,GAAG,CAAC,WAAW,IAAI,MAAM,CAAC,WAAW,GAAG,MAAM,CAAC,UAAU,EAAE;YAClE,IAAI,GAAG,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC,WAAW,GAAG,IAAI,CAAC,MAAM,CAAC;SACpD;QACD,IAAI,GAAG,GAAG,GAAG,CAAC,YAAY,IAAI,MAAM,CAAC,WAAW,GAAG,MAAM,CAAC,WAAW,EAAE;YACnE,GAAG,GAAG,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC,YAAY,GAAG,IAAI,CAAC,MAAM,CAAC;SACnD;QAED,OAAO;YACH,GAAG,EAAE,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG;YACtB,IAAI,EAAE,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI;SAC5B,CAAC;IACN,CAAC;;;;IAED,sCAAW;;;IAAX;QACI,IAAI,IAAI,CAAC,UAAU,EAAE;YACjB,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YACxD,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;SAC1B;IACL,CAAC;;gBA1GJ,SAAS,SAAC;oBACP,QAAQ,EAAE,WAAW;oBACrB,QAAQ,EAAE,2BAA2B;oBAErC,IAAI,EAAE;wBACF,cAAc,EAAE,gBAAgB;wBAChC,cAAc,EAAE,gBAAgB;qBACnC;;iBACJ;;;;gBAViD,QAAQ;gBAAtC,UAAU;gBAAS,SAAS;;;kCAmB3C,KAAK,SAAC,SAAS;2BACf,KAAK;yBACL,KAAK;;IAyFV,uBAAC;CAAA,AA5GD,CASsC,YAAY,GAmGjD;SAnGY,gBAAgB;;;IAQzB,2CAA0C;;IAC1C,oCAAkE;;IAClE,kCAAoB;;;;;IAEpB,sCAAgC;;IA2BhC,2CAKC;;;;;IAzCW,+BAAuB;;;;;IACvB,oCAA2B","sourcesContent":["import { OdeComponent } from 'ngx-ode-core';\nimport { Component, ElementRef, Input, Renderer2, Injector } from '@angular/core';\n\n@Component({\n    selector: '[tooltip]',\n    template: `<ng-content></ng-content>`,\n    styleUrls: ['./tooltip.component.scss'],\n    host: {\n        '(mouseenter)': 'onMouseEnter()',\n        '(mouseleave)': 'onMouseLeave()'\n    }\n})\nexport class TooltipComponent extends OdeComponent {\n\n    constructor(injector: Injector,\n                private ref: ElementRef,\n                private renderer: Renderer2) {\n                    super(injector);\n                }\n\n    @Input('tooltip') tooltipContents: string;\n    @Input() position: 'top' | 'left' | 'right' | 'bottom' = 'bottom';\n    @Input() offset = 5;\n\n    private tooltipElt: HTMLElement;\n\n    onMouseEnter(): void {\n        const r = this.renderer;\n\n        if (!this.tooltipElt) {\n            this.tooltipElt = this.renderer.createElement('div');\n            let tooltipText = this.renderer.createText(this.tooltipContents);\n            this.renderer.appendChild(this.tooltipElt, tooltipText);\n            this.renderer.addClass(this.tooltipElt, \"tooltip\");\n            this.renderer.appendChild(document.getElementsByTagName('body')[0], this.tooltipElt);\n        }\n        const tip = this.tooltipElt;\n        const pos = this.getPosition(this.ref.nativeElement, tip, this.position);\n        for (const prop in pos) {\n            this.renderer.setStyle(tip, prop, pos[prop] + 'px');\n        }\n        this.renderer.addClass(tip, 'shown');\n    }\n\n    onMouseLeave(): void {\n        const wait = this.tooltipElt &&\n            parseFloat(window.getComputedStyle(this.tooltipElt)['transition-duration']);\n        this.renderer.removeClass(this.tooltipElt, 'shown');\n        setTimeout(this.onTransitionEnd, wait * 1000);\n    }\n\n    onTransitionEnd = () => {\n        if (this.tooltipElt && !this.tooltipElt.classList.contains('shown')) {\n            this.tooltipElt.parentNode.removeChild(this.tooltipElt);\n            this.tooltipElt = null;\n        }\n    }\n\n    private getPosition(elt, tip, pos) {\n        const rect = {\n            top: elt.getBoundingClientRect().top + window.scrollY,\n            left: elt.getBoundingClientRect().left + window.scrollX\n        };\n        let left, top;\n\n        switch (pos) {\n\n            case 'top':\n                top = rect.top - tip.offsetHeight - this.offset;\n                left = rect.left + elt.offsetWidth / 2 - tip.offsetWidth / 2;\n                break;\n            case 'left':\n                top = rect.top + elt.offsetHeight / 2 - tip.offsetHeight / 2;\n                left = rect.left - tip.offsetWidth - this.offset;\n                break;\n            case 'right':\n                top = rect.top + elt.offsetHeight / 2 - tip.offsetHeight / 2;\n                left = rect.left + elt.offsetWidth + this.offset;\n                break;\n            case 'bottom':\n            default:\n                top = rect.top + elt.offsetHeight + this.offset;\n                left = rect.left + elt.offsetWidth / 2 - tip.offsetWidth / 2;\n        }\n\n        if (left < 0 ) {\n            left = rect.left + elt.offsetWidth + this.offset;\n        }\n        if (top < 0) {\n            top = rect.top + elt.offsetHeight + this.offset;\n        }\n        if (left + tip.offsetWidth >= window.pageXOffset + window.innerWidth) {\n            left = rect.left - tip.offsetWidth - this.offset;\n        }\n        if (top - tip.offsetHeight >= window.pageYOffset + window.innerHeight) {\n            top = rect.top - tip.offsetHeight - this.offset;\n        }\n\n        return {\n            top: top < 5 ? 5 : top,\n            left: left < 5 ? 5 : left\n        };\n    }\n\n    ngOnDestroy(): void {\n        if (this.tooltipElt) {\n            this.tooltipElt.parentNode.removeChild(this.tooltipElt);\n            this.tooltipElt = null;\n        }\n    }\n\n}\n"]}

package/esm5/lib/components/upload-files/upload-files.component.js

@@ -0,0 +1,133 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/components/upload-files/upload-files.component.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+import { OdeComponent } from 'ngx-ode-core';
+import { Component, ElementRef, EventEmitter, Input, Output, ViewChild, Injector } from '@angular/core';
+import { InputFileService } from '../../services/inputFile.service';
+var UploadFilesComponent = /** @class */ (function (_super) {
+    tslib_1.__extends(UploadFilesComponent, _super);
+    function UploadFilesComponent(injector, inputFileService) {
+        var _this = _super.call(this, injector) || this;
+        _this.inputFileService = inputFileService;
+        _this.upload = new EventEmitter();
+        _this.invalidUpload = new EventEmitter();
+        return _this;
+    }
+    /**
+     * @return {?}
+     */
+    UploadFilesComponent.prototype.ngOnInit = /**
+     * @return {?}
+     */
+    function () {
+        _super.prototype.ngOnInit.call(this);
+        this.multiple = this.maxFilesNumber > 1;
+    };
+    /**
+     * @param {?} $event
+     * @return {?}
+     */
+    UploadFilesComponent.prototype.onChange = /**
+     * @param {?} $event
+     * @return {?}
+     */
+    function ($event) {
+        var _this = this;
+        if ($event.target) {
+            this.inputFileService
+                .validateFiles($event.target.files, this.maxFilesNumber, this.allowedExtensions)
+                .subscribe((/**
+             * @param {?} files
+             * @return {?}
+             */
+            function (files) { return _this.upload.emit(files); }), (/**
+             * @param {?} error
+             * @return {?}
+             */
+            function (error) { return _this.invalidUpload.emit(error); }));
+        }
+    };
+    /**
+     * @param {?} $event
+     * @return {?}
+     */
+    UploadFilesComponent.prototype.onClickDropzoneInput = /**
+     * @param {?} $event
+     * @return {?}
+     */
+    function ($event) {
+        $event.stopPropagation();
+        /** @type {?} */
+        var inputFileElement = this.inputFileRef.nativeElement;
+        inputFileElement.click();
+    };
+    /**
+     * @param {?} $event
+     * @return {?}
+     */
+    UploadFilesComponent.prototype.onDragAndDrop = /**
+     * @param {?} $event
+     * @return {?}
+     */
+    function ($event) {
+        this.upload.emit($event);
+    };
+    /**
+     * @param {?} $event
+     * @return {?}
+     */
+    UploadFilesComponent.prototype.onInvalidDragAndDrop = /**
+     * @param {?} $event
+     * @return {?}
+     */
+    function ($event) {
+        this.invalidUpload.emit($event);
+    };
+    UploadFilesComponent.decorators = [
+        { type: Component, args: [{
+                    selector: 'ode-upload-files',
+                    template: "<div class=\"upload-files-dropzone\"\n     dragAndDropFiles\n     [allowedExtensions]=\"allowedExtensions\"\n     [maxFilesNumber]=\"maxFilesNumber\"\n     [disabled]=\"disabled\"\n     (dragAndDrop)=\"onDragAndDrop($event)\"\n     (invalidDragAndDrop)=\"onInvalidDragAndDrop($event)\">\n  <div *ngIf=\"fileSrc\" class=\"upload-files-dropzone-image\">\n    <img src=\"{{ fileSrc }}\"\n         *ngIf=\"inputFileService.isSrcExternalUrl(fileSrc)\"\n         class=\"upload-files-dropzone-image__image\"/>\n    <img src=\"{{ fileSrc }}\"\n         *ngIf=\"inputFileService.isSrcWorkspace(fileSrc)\"\n         class=\"upload-files-dropzone-image__image\"/>\n    <i class=\"upload-files-dropzone-image__icon {{ fileSrc }}\"\n       *ngIf=\"!inputFileService.isSrcExternalUrl(fileSrc)\n                        && !inputFileService.isSrcWorkspace(fileSrc)\"></i>\n  </div>\n\n  <div class=\"upload-files-dropzone-input\" *ngIf=\"!disabled\">\n    <button class=\"confirm upload-files-dropzone-input__button\"\n            (click)=\"onClickDropzoneInput($event)\">\n      <s5l>ux.upload-files.button.label</s5l>\n    </button>\n    <i class=\"upload-files-dropzone-input__icon fa fa-cloud-upload fa-2x\">\n    </i>\n    <span class=\"upload-files-dropzone-input__help\">\n                    <s5l>ux.upload-files.button.help</s5l>\n                </span>\n    <input *ngIf=\"multiple === true else singleFileInput\"\n           class=\"upload-files-dropzone-input__input\"\n           type=\"file\"\n           (change)=\"onChange($event)\"\n           multiple\n           #inputFileRef>\n    <ng-template #singleFileInput>\n      <input class=\"upload-files-dropzone-input__input\"\n             type=\"file\"\n             (change)=\"onChange($event)\"\n             #inputFileRef>\n    </ng-template>\n  </div>\n</div>\n",
+                    styles: [".upload-files-dropzone{display:flex;align-items:center;justify-content:center;min-height:150px;margin:20px;padding:20px 10px;background-color:#fafafa;border:2px dashed #ddd;border-radius:5px}.upload-files-dropzone-image{display:flex;align-items:center;justify-content:center;width:120px;height:120px}.upload-files-dropzone-image__image{max-height:90%;max-width:90%}.upload-files-dropzone-image__icon{font-size:5em}.upload-files-dropzone-input{display:flex;align-items:center;background-color:#fff;border-radius:5px;box-shadow:1px 1px 5px rgba(0,0,0,.3);padding:10px;margin:0 40px 0 20px}.upload-files-dropzone-input__input{display:none}.upload-files-dropzone-input__icon{margin-left:10px}.upload-files-dropzone-input__help{margin-left:10px;font-style:italic}"]
+                }] }
+    ];
+    /** @nocollapse */
+    UploadFilesComponent.ctorParameters = function () { return [
+        { type: Injector },
+        { type: InputFileService }
+    ]; };
+    UploadFilesComponent.propDecorators = {
+        fileSrc: [{ type: Input }],
+        allowedExtensions: [{ type: Input }],
+        maxFilesNumber: [{ type: Input }],
+        disabled: [{ type: Input }],
+        upload: [{ type: Output }],
+        invalidUpload: [{ type: Output }],
+        inputFileRef: [{ type: ViewChild, args: ['inputFileRef', { static: false },] }]
+    };
+    return UploadFilesComponent;
+}(OdeComponent));
+export { UploadFilesComponent };
+if (false) {
+    /** @type {?} */
+    UploadFilesComponent.prototype.fileSrc;
+    /** @type {?} */
+    UploadFilesComponent.prototype.allowedExtensions;
+    /** @type {?} */
+    UploadFilesComponent.prototype.maxFilesNumber;
+    /** @type {?} */
+    UploadFilesComponent.prototype.disabled;
+    /** @type {?} */
+    UploadFilesComponent.prototype.upload;
+    /** @type {?} */
+    UploadFilesComponent.prototype.invalidUpload;
+    /** @type {?} */
+    UploadFilesComponent.prototype.inputFileRef;
+    /** @type {?} */
+    UploadFilesComponent.prototype.multiple;
+    /** @type {?} */
+    UploadFilesComponent.prototype.inputFileService;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/components/value-editable/simple-select.component.js

@@ -0,0 +1,59 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/components/value-editable/simple-select.component.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+import { OdeComponent } from 'ngx-ode-core';
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, Injector } from '@angular/core';
+/**
+ * @record
+ */
+export function Option() { }
+if (false) {
+    /** @type {?} */
+    Option.prototype.value;
+    /** @type {?} */
+    Option.prototype.label;
+}
+var SimpleSelectComponent = /** @class */ (function (_super) {
+    tslib_1.__extends(SimpleSelectComponent, _super);
+    function SimpleSelectComponent(injector) {
+        var _this = _super.call(this, injector) || this;
+        _this.selectChange = new EventEmitter();
+        return _this;
+    }
+    SimpleSelectComponent.decorators = [
+        { type: Component, args: [{
+                    selector: 'ode-simple-select',
+                    template: "<select [ngModel]=\"model[selected]\" (ngModelChange)=\"model[selected] = $event; selectChange.emit($event)\">\n\n<option *ngIf=\"ignoreOption.length > 0 \" [ngValue]=\"ignoreOption[0].value\">\n                                                                          {{ignoreOption[0].label}}\n</option>\n<option *ngFor=\"let option of options | orderBy: 'label'\" [ngValue]=\"option.value\">\n                                                                                  {{option.label}}\n</option>\n</select>\n",
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }] }
+    ];
+    /** @nocollapse */
+    SimpleSelectComponent.ctorParameters = function () { return [
+        { type: Injector }
+    ]; };
+    SimpleSelectComponent.propDecorators = {
+        selected: [{ type: Input }],
+        model: [{ type: Input }],
+        options: [{ type: Input }],
+        ignoreOption: [{ type: Input }],
+        selectChange: [{ type: Output }]
+    };
+    return SimpleSelectComponent;
+}(OdeComponent));
+export { SimpleSelectComponent };
+if (false) {
+    /** @type {?} */
+    SimpleSelectComponent.prototype.selected;
+    /** @type {?} */
+    SimpleSelectComponent.prototype.model;
+    /** @type {?} */
+    SimpleSelectComponent.prototype.options;
+    /** @type {?} */
+    SimpleSelectComponent.prototype.ignoreOption;
+    /** @type {?} */
+    SimpleSelectComponent.prototype.selectChange;
+}
+//# sourceMappingURL=data:application/json;base64,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