@gipisistemas/ng-core 1.1.0 → 1.1.1

package/esm5/shared/components/table-scrolled/table-scrolled.component.js

@@ -0,0 +1,107 @@
+import { __decorate, __metadata } from "tslib";
+import { Component, ElementRef, EventEmitter, HostListener, Input, OnChanges, OnInit, Output, SimpleChanges } from '@angular/core';
+import { throttle } from '../../api/throttle';
+var ScrollDirection;
+(function (ScrollDirection) {
+    ScrollDirection["UP"] = "up";
+    ScrollDirection["DOWN"] = "down";
+})(ScrollDirection || (ScrollDirection = {}));
+var ScrollListener;
+(function (ScrollListener) {
+    ScrollListener["HOST"] = "scroll";
+    ScrollListener["WINDOW"] = "window:scroll";
+})(ScrollListener || (ScrollListener = {}));
+var TableScrolledComponent = /** @class */ (function () {
+    function TableScrolledComponent(_elementRef) {
+        this._elementRef = _elementRef;
+        this.scrollTop = 0;
+        this.more = true;
+        this.scrollDelay = 500;
+        this.scrollOffset = 1000;
+        this.scrolled = new EventEmitter();
+        this._element = this._elementRef.nativeElement;
+        this._window = document.documentElement;
+    }
+    TableScrolledComponent.prototype.ngOnInit = function () {
+        this.setThrottle();
+    };
+    TableScrolledComponent.prototype.ngOnChanges = function (changes) {
+        if (changes.scrollDelay) {
+            this.setThrottle();
+        }
+    };
+    TableScrolledComponent.prototype.setThrottle = function () {
+        this._scroll = this._windowScroll = throttle(this.handleScroll, this.scrollDelay);
+    };
+    TableScrolledComponent.prototype.getListener = function () {
+        if (this._elementRef.nativeElement.clientHeight === this._elementRef.nativeElement.scrollHeight) {
+            return ScrollListener.WINDOW;
+        }
+        else {
+            return ScrollListener.HOST;
+        }
+    };
+    TableScrolledComponent.prototype.roundTo = function (from, to) {
+        if (to === void 0) { to = this.scrollOffset; }
+        return (Math.floor(from / to) * to);
+    };
+    TableScrolledComponent.prototype.getScrollDirection = function (st) {
+        if (this.scrollTop <= st) {
+            return ScrollDirection.DOWN;
+        }
+        else {
+            return ScrollDirection.UP;
+        }
+    };
+    TableScrolledComponent.prototype.canScroll = function (element) {
+        var scrolled = this.more && (this.getScrollDirection(element.scrollTop) === ScrollDirection.DOWN) && (this.roundTo(element.clientHeight) === this.roundTo(element.scrollHeight - element.scrollTop));
+        this.scrollTop = element.scrollTop;
+        return scrolled;
+    };
+    TableScrolledComponent.prototype.handleScroll = function () {
+        if (this.getListener() === ScrollListener.HOST) {
+            this.scrolled.emit(this.canScroll(this._element));
+        }
+        else {
+            this.scrolled.emit(this.canScroll(this._window));
+        }
+    };
+    TableScrolledComponent.ctorParameters = function () { return [
+        { type: ElementRef }
+    ]; };
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], TableScrolledComponent.prototype, "more", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Number)
+    ], TableScrolledComponent.prototype, "scrollDelay", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Number)
+    ], TableScrolledComponent.prototype, "scrollOffset", void 0);
+    __decorate([
+        Output(),
+        __metadata("design:type", EventEmitter)
+    ], TableScrolledComponent.prototype, "scrolled", void 0);
+    __decorate([
+        HostListener(ScrollListener.HOST),
+        __metadata("design:type", Function)
+    ], TableScrolledComponent.prototype, "_scroll", void 0);
+    __decorate([
+        HostListener(ScrollListener.WINDOW),
+        __metadata("design:type", Function)
+    ], TableScrolledComponent.prototype, "_windowScroll", void 0);
+    TableScrolledComponent = __decorate([
+        Component({
+            selector: 'itss-table-scrolled',
+            template: "<ng-content> </ng-content>",
+            styles: [":host{overflow-y:auto;position:relative}"]
+        }),
+        __metadata("design:paramtypes", [ElementRef])
+    ], TableScrolledComponent);
+    return TableScrolledComponent;
+}());
+export { TableScrolledComponent };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/shared/components/textarea/textarea.component.js

@@ -0,0 +1,174 @@
+import { __decorate, __metadata } from "tslib";
+import { coerceCssPixelValue } from '@angular/cdk/coercion';
+import { Component, ElementRef, forwardRef, Input, ViewChild } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+var TextareaComponent = /** @class */ (function () {
+    function TextareaComponent() {
+        this.maxlength = 250;
+        this.rows = 2;
+        this.appearance = 'outline';
+        this.upperCase = false;
+        this.mentionConfiguration = {};
+        this._minHeight = '60px';
+        this._height = '60px';
+        this._maxHeight = 'auto';
+        this.onChange = function () { };
+        this.onTouch = function () { };
+    }
+    TextareaComponent_1 = TextareaComponent;
+    Object.defineProperty(TextareaComponent.prototype, "value", {
+        get: function () {
+            return this.val;
+        },
+        set: function (val) {
+            this.val = this.checkUppercase(val);
+            this.onChange(this.val);
+            this.onTouch();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TextareaComponent.prototype, "minHeight", {
+        get: function () {
+            return this._minHeight;
+        },
+        set: function (value) {
+            if (value.trim().toUpperCase() === 'AUTO') {
+                this._minHeight = 'auto';
+            }
+            else {
+                this._minHeight = coerceCssPixelValue(value);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TextareaComponent.prototype, "height", {
+        get: function () {
+            return this._height;
+        },
+        set: function (value) {
+            if (value.trim().toUpperCase() === 'AUTO') {
+                this._height = 'auto';
+            }
+            else {
+                this._height = coerceCssPixelValue(value);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TextareaComponent.prototype, "maxHeight", {
+        get: function () {
+            return this._maxHeight;
+        },
+        set: function (value) {
+            if (value.trim().toUpperCase() === 'AUTO') {
+                this._maxHeight = 'auto';
+            }
+            else {
+                this._maxHeight = coerceCssPixelValue(value);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    TextareaComponent.prototype.ngOnInit = function () { };
+    TextareaComponent.prototype.registerOnChange = function (fn) {
+        this.onChange = fn;
+    };
+    TextareaComponent.prototype.registerOnTouched = function (fn) {
+        this.onTouch = fn;
+    };
+    TextareaComponent.prototype.writeValue = function (value) {
+        this.value = this.checkUppercase(value);
+    };
+    TextareaComponent.prototype.checkUppercase = function (value) {
+        if (this.upperCase && value) {
+            return value.toUpperCase();
+        }
+        return value;
+    };
+    var TextareaComponent_1;
+    __decorate([
+        ViewChild('input', { static: false, read: ElementRef }),
+        __metadata("design:type", ElementRef)
+    ], TextareaComponent.prototype, "_elementRef", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], TextareaComponent.prototype, "name", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], TextareaComponent.prototype, "label", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], TextareaComponent.prototype, "placeholder", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], TextareaComponent.prototype, "disabled", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], TextareaComponent.prototype, "required", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object)
+    ], TextareaComponent.prototype, "maxlength", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object)
+    ], TextareaComponent.prototype, "rows", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object)
+    ], TextareaComponent.prototype, "appearance", void 0);
+    __decorate([
+        Input('value'),
+        __metadata("design:type", Object)
+    ], TextareaComponent.prototype, "val", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object)
+    ], TextareaComponent.prototype, "upperCase", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object)
+    ], TextareaComponent.prototype, "mentionConfiguration", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String),
+        __metadata("design:paramtypes", [String])
+    ], TextareaComponent.prototype, "minHeight", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", String),
+        __metadata("design:paramtypes", [String])
+    ], TextareaComponent.prototype, "height", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", String),
+        __metadata("design:paramtypes", [String])
+    ], TextareaComponent.prototype, "maxHeight", null);
+    TextareaComponent = TextareaComponent_1 = __decorate([
+        Component({
+            selector: 'itss-textarea',
+            template: "<div fxLayout=\"column\">\n    <mat-label *ngIf=\"label\">\n        {{ label }}\n        <span *ngIf=\"required && label\">*</span>\n    </mat-label>\n    <mat-form-field [appearance]=\"appearance\">\n        <textarea matInput\n                  #input\n                  upperCase\n                  autocomplete=\"off\"\n                  [style.min-height.px]=\"height\"\n                  [style.height.px]=\"height\"\n                  [style.max-height.px]=\"height\"\n                  [name]=\"name\"\n                  [placeholder]=\"placeholder\"\n                  [required]=\"required\"\n                  [disabled]=\"disabled\"\n                  [(ngModel)]=\"value\"\n                  [maxlength]=\"maxlength\"\n                  [enabledUpperCase]=\"upperCase\"\n                  [rows]=\"rows\"\n                  [mentionConfig]=\"mentionConfiguration\"\n                  (blur)=\"onTouch()\">\n        </textarea>\n    </mat-form-field>\n</div>",
+            providers: [
+                {
+                    provide: NG_VALUE_ACCESSOR,
+                    useExisting: forwardRef(function () { return TextareaComponent_1; }),
+                    multi: true
+                }
+            ],
+            styles: ["mat-label span{color:#f44336!important}"]
+        }),
+        __metadata("design:paramtypes", [])
+    ], TextareaComponent);
+    return TextareaComponent;
+}());
+export { TextareaComponent };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGV4dGFyZWEuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6Im5nOi8vQGdpcGlzaXN0ZW1hcy9uZy1jb3JlLyIsInNvdXJjZXMiOlsic2hhcmVkL2NvbXBvbmVudHMvdGV4dGFyZWEvdGV4dGFyZWEuY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUM1RCxPQUFPLEVBQUUsU0FBUyxFQUFFLFVBQVUsRUFBRSxVQUFVLEVBQUUsS0FBSyxFQUFVLFNBQVMsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUM1RixPQUFPLEVBQXdCLGlCQUFpQixFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFjekU7SUFzRUk7UUF4RFMsY0FBUyxHQUFHLEdBQUcsQ0FBQztRQUVoQixTQUFJLEdBQUcsQ0FBQyxDQUFDO1FBRVQsZUFBVSxHQUFHLFNBQVMsQ0FBQztRQVl2QixjQUFTLEdBQUcsS0FBSyxDQUFDO1FBRWxCLHlCQUFvQixHQUFHLEVBQUUsQ0FBQztRQUUzQixlQUFVLEdBQVcsTUFBTSxDQUFDO1FBWTVCLFlBQU8sR0FBVyxNQUFNLENBQUM7UUFZekIsZUFBVSxHQUFXLE1BQU0sQ0FBQztRQWdCcEMsYUFBUSxHQUFRLGNBQVEsQ0FBQyxDQUFDO1FBRTFCLFlBQU8sR0FBUSxjQUFRLENBQUMsQ0FBQztJQU5ULENBQUM7MEJBdEVSLGlCQUFpQjtJQXFCMUIsc0JBQUksb0NBQUs7YUFBVDtZQUNJLE9BQU8sSUFBSSxDQUFDLEdBQUcsQ0FBQztRQUNwQixDQUFDO2FBQ0QsVUFBVSxHQUFHO1lBQ1QsSUFBSSxDQUFDLEdBQUcsR0FBRyxJQUFJLENBQUMsY0FBYyxDQUFDLEdBQUcsQ0FBQyxDQUFDO1lBQ3BDLElBQUksQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDO1lBQ3hCLElBQUksQ0FBQyxPQUFPLEVBQUUsQ0FBQztRQUNuQixDQUFDOzs7T0FMQTtJQVlRLHNCQUFJLHdDQUFTO2FBQWI7WUFDTCxPQUFPLElBQUksQ0FBQyxVQUFVLENBQUM7UUFDM0IsQ0FBQzthQUNELFVBQWMsS0FBYTtZQUN2QixJQUFJLEtBQUssQ0FBQyxJQUFJLEVBQUUsQ0FBQyxXQUFXLEVBQUUsS0FBSyxNQUFNLEVBQUU7Z0JBQ3ZDLElBQUksQ0FBQyxVQUFVLEdBQUcsTUFBTSxDQUFDO2FBQzVCO2lCQUFNO2dCQUNILElBQUksQ0FBQyxVQUFVLEdBQUcsbUJBQW1CLENBQUMsS0FBSyxDQUFDLENBQUM7YUFDaEQ7UUFDTCxDQUFDOzs7T0FQQTtJQVVRLHNCQUFJLHFDQUFNO2FBQVY7WUFDTCxPQUFPLElBQUksQ0FBQyxPQUFPLENBQUM7UUFDeEIsQ0FBQzthQUNELFVBQVcsS0FBYTtZQUNwQixJQUFJLEtBQUssQ0FBQyxJQUFJLEVBQUUsQ0FBQyxXQUFXLEVBQUUsS0FBSyxNQUFNLEVBQUU7Z0JBQ3ZDLElBQUksQ0FBQyxPQUFPLEdBQUcsTUFBTSxDQUFDO2FBQ3pCO2lCQUFNO2dCQUNILElBQUksQ0FBQyxPQUFPLEdBQUcsbUJBQW1CLENBQUMsS0FBSyxDQUFDLENBQUM7YUFDN0M7UUFDTCxDQUFDOzs7T0FQQTtJQVVRLHNCQUFJLHdDQUFTO2FBQWI7WUFDTCxPQUFPLElBQUksQ0FBQyxVQUFVLENBQUM7UUFDM0IsQ0FBQzthQUNELFVBQWMsS0FBYTtZQUN2QixJQUFJLEtBQUssQ0FBQyxJQUFJLEVBQUUsQ0FBQyxXQUFXLEVBQUUsS0FBSyxNQUFNLEVBQUU7Z0JBQ3ZDLElBQUksQ0FBQyxVQUFVLEdBQUcsTUFBTSxDQUFDO2FBQzVCO2lCQUFNO2dCQUNILElBQUksQ0FBQyxVQUFVLEdBQUcsbUJBQW1CLENBQUMsS0FBSyxDQUFDLENBQUM7YUFDaEQ7UUFDTCxDQUFDOzs7T0FQQTtJQVdELG9DQUFRLEdBQVIsY0FBbUIsQ0FBQztJQU1wQiw0Q0FBZ0IsR0FBaEIsVUFBaUIsRUFBTztRQUNwQixJQUFJLENBQUMsUUFBUSxHQUFHLEVBQUUsQ0FBQztJQUN2QixDQUFDO0lBRUQsNkNBQWlCLEdBQWpCLFVBQWtCLEVBQU87UUFDckIsSUFBSSxDQUFDLE9BQU8sR0FBRyxFQUFFLENBQUM7SUFDdEIsQ0FBQztJQUVELHNDQUFVLEdBQVYsVUFBVyxLQUFVO1FBQ2pCLElBQUksQ0FBQyxLQUFLLEdBQUcsSUFBSSxDQUFDLGNBQWMsQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUM1QyxDQUFDO0lBRUQsMENBQWMsR0FBZCxVQUFlLEtBQVU7UUFDckIsSUFBSSxJQUFJLENBQUMsU0FBUyxJQUFJLEtBQUssRUFBRTtZQUN6QixPQUFPLEtBQUssQ0FBQyxXQUFXLEVBQUUsQ0FBQztTQUM5QjtRQUNELE9BQU8sS0FBSyxDQUFDO0lBQ2pCLENBQUM7O0lBN0Z3RDtRQUF4RCxTQUFTLENBQUMsT0FBTyxFQUFFLEVBQUUsTUFBTSxFQUFFLEtBQUssRUFBRSxJQUFJLEVBQUUsVUFBVSxFQUFFLENBQUM7a0NBQWMsVUFBVTswREFBQztJQUV4RTtRQUFSLEtBQUssRUFBRTs7bURBQWM7SUFFYjtRQUFSLEtBQUssRUFBRTs7b0RBQWU7SUFFZDtRQUFSLEtBQUssRUFBRTs7MERBQXFCO0lBRXBCO1FBQVIsS0FBSyxFQUFFOzt1REFBbUI7SUFFbEI7UUFBUixLQUFLLEVBQUU7O3VEQUFtQjtJQUVsQjtRQUFSLEtBQUssRUFBRTs7d0RBQWlCO0lBRWhCO1FBQVIsS0FBSyxFQUFFOzttREFBVTtJQUVUO1FBQVIsS0FBSyxFQUFFOzt5REFBd0I7SUFFaEI7UUFBZixLQUFLLENBQUMsT0FBTyxDQUFDOztrREFBVTtJQVVoQjtRQUFSLEtBQUssRUFBRTs7d0RBQW1CO0lBRWxCO1FBQVIsS0FBSyxFQUFFOzttRUFBMkI7SUFHMUI7UUFBUixLQUFLLEVBQUU7OztzREFFUDtJQVVRO1FBQVIsS0FBSyxFQUFFOzs7bURBRVA7SUFVUTtRQUFSLEtBQUssRUFBRTs7O3NEQUVQO0lBN0RRLGlCQUFpQjtRQVo3QixTQUFTLENBQUM7WUFDUCxRQUFRLEVBQUUsZUFBZTtZQUN6QixzOUJBQXdDO1lBRXhDLFNBQVMsRUFBRTtnQkFDUDtvQkFDSSxPQUFPLEVBQUUsaUJBQWlCO29CQUMxQixXQUFXLEVBQUUsVUFBVSxDQUFDLGNBQU0sT0FBQSxtQkFBaUIsRUFBakIsQ0FBaUIsQ0FBQztvQkFDaEQsS0FBSyxFQUFFLElBQUk7aUJBQ2Q7YUFDSjs7U0FDSixDQUFDOztPQUNXLGlCQUFpQixDQWlHN0I7SUFBRCx3QkFBQztDQUFBLEFBakdELElBaUdDO1NBakdZLGlCQUFpQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGNvZXJjZUNzc1BpeGVsVmFsdWUgfSBmcm9tICdAYW5ndWxhci9jZGsvY29lcmNpb24nO1xuaW1wb3J0IHsgQ29tcG9uZW50LCBFbGVtZW50UmVmLCBmb3J3YXJkUmVmLCBJbnB1dCwgT25Jbml0LCBWaWV3Q2hpbGQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IENvbnRyb2xWYWx1ZUFjY2Vzc29yLCBOR19WQUxVRV9BQ0NFU1NPUiB9IGZyb20gJ0Bhbmd1bGFyL2Zvcm1zJztcblxuQENvbXBvbmVudCh7XG4gICAgc2VsZWN0b3I6ICdpdHNzLXRleHRhcmVhJyxcbiAgICB0ZW1wbGF0ZVVybDogJy4vdGV4dGFyZWEuY29tcG9uZW50Lmh0bWwnLFxuICAgIHN0eWxlVXJsczogWycuL3RleHRhcmVhLmNvbXBvbmVudC5zY3NzJ10sXG4gICAgcHJvdmlkZXJzOiBbXG4gICAgICAgIHtcbiAgICAgICAgICAgIHByb3ZpZGU6IE5HX1ZBTFVFX0FDQ0VTU09SLFxuICAgICAgICAgICAgdXNlRXhpc3Rpbmc6IGZvcndhcmRSZWYoKCkgPT4gVGV4dGFyZWFDb21wb25lbnQpLFxuICAgICAgICAgICAgbXVsdGk6IHRydWVcbiAgICAgICAgfVxuICAgIF1cbn0pXG5leHBvcnQgY2xhc3MgVGV4dGFyZWFDb21wb25lbnQgaW1wbGVtZW50cyBDb250cm9sVmFsdWVBY2Nlc3NvciwgT25Jbml0IHtcblxuICAgIEBWaWV3Q2hpbGQoJ2lucHV0JywgeyBzdGF0aWM6IGZhbHNlLCByZWFkOiBFbGVtZW50UmVmIH0pIF9lbGVtZW50UmVmOiBFbGVtZW50UmVmO1xuXG4gICAgQElucHV0KCkgbmFtZTogc3RyaW5nO1xuXG4gICAgQElucHV0KCkgbGFiZWw6IHN0cmluZztcblxuICAgIEBJbnB1dCgpIHBsYWNlaG9sZGVyOiBzdHJpbmc7XG5cbiAgICBASW5wdXQoKSBkaXNhYmxlZDogYm9vbGVhbjtcblxuICAgIEBJbnB1dCgpIHJlcXVpcmVkOiBib29sZWFuO1xuXG4gICAgQElucHV0KCkgbWF4bGVuZ3RoID0gMjUwO1xuXG4gICAgQElucHV0KCkgcm93cyA9IDI7XG5cbiAgICBASW5wdXQoKSBhcHBlYXJhbmNlID0gJ291dGxpbmUnO1xuXG4gICAgQElucHV0KCd2YWx1ZScpIHZhbDogYW55O1xuICAgIGdldCB2YWx1ZSgpIHtcbiAgICAgICAgcmV0dXJuIHRoaXMudmFsO1xuICAgIH1cbiAgICBzZXQgdmFsdWUodmFsKSB7XG4gICAgICAgIHRoaXMudmFsID0gdGhpcy5jaGVja1VwcGVyY2FzZSh2YWwpO1xuICAgICAgICB0aGlzLm9uQ2hhbmdlKHRoaXMudmFsKTtcbiAgICAgICAgdGhpcy5vblRvdWNoKCk7XG4gICAgfVxuXG4gICAgQElucHV0KCkgdXBwZXJDYXNlID0gZmFsc2U7XG5cbiAgICBASW5wdXQoKSBtZW50aW9uQ29uZmlndXJhdGlvbiA9IHt9O1xuXG4gICAgcHJpdmF0ZSBfbWluSGVpZ2h0OiBzdHJpbmcgPSAnNjBweCc7XG4gICAgQElucHV0KCkgZ2V0IG1pbkhlaWdodCgpOiBzdHJpbmcge1xuICAgICAgICByZXR1cm4gdGhpcy5fbWluSGVpZ2h0O1xuICAgIH1cbiAgICBzZXQgbWluSGVpZ2h0KHZhbHVlOiBzdHJpbmcpIHtcbiAgICAgICAgaWYgKHZhbHVlLnRyaW0oKS50b1VwcGVyQ2FzZSgpID09PSAnQVVUTycpIHtcbiAgICAgICAgICAgIHRoaXMuX21pbkhlaWdodCA9ICdhdXRvJztcbiAgICAgICAgfSBlbHNlIHtcbiAgICAgICAgICAgIHRoaXMuX21pbkhlaWdodCA9IGNvZXJjZUNzc1BpeGVsVmFsdWUodmFsdWUpO1xuICAgICAgICB9XG4gICAgfVxuXG4gICAgcHJpdmF0ZSBfaGVpZ2h0OiBzdHJpbmcgPSAnNjBweCc7XG4gICAgQElucHV0KCkgZ2V0IGhlaWdodCgpOiBzdHJpbmcge1xuICAgICAgICByZXR1cm4gdGhpcy5faGVpZ2h0O1xuICAgIH1cbiAgICBzZXQgaGVpZ2h0KHZhbHVlOiBzdHJpbmcpIHtcbiAgICAgICAgaWYgKHZhbHVlLnRyaW0oKS50b1VwcGVyQ2FzZSgpID09PSAnQVVUTycpIHtcbiAgICAgICAgICAgIHRoaXMuX2hlaWdodCA9ICdhdXRvJztcbiAgICAgICAgfSBlbHNlIHtcbiAgICAgICAgICAgIHRoaXMuX2hlaWdodCA9IGNvZXJjZUNzc1BpeGVsVmFsdWUodmFsdWUpO1xuICAgICAgICB9XG4gICAgfVxuXG4gICAgcHJpdmF0ZSBfbWF4SGVpZ2h0OiBzdHJpbmcgPSAnYXV0byc7XG4gICAgQElucHV0KCkgZ2V0IG1heEhlaWdodCgpOiBzdHJpbmcge1xuICAgICAgICByZXR1cm4gdGhpcy5fbWF4SGVpZ2h0O1xuICAgIH1cbiAgICBzZXQgbWF4SGVpZ2h0KHZhbHVlOiBzdHJpbmcpIHtcbiAgICAgICAgaWYgKHZhbHVlLnRyaW0oKS50b1VwcGVyQ2FzZSgpID09PSAnQVVUTycpIHtcbiAgICAgICAgICAgIHRoaXMuX21heEhlaWdodCA9ICdhdXRvJztcbiAgICAgICAgfSBlbHNlIHtcbiAgICAgICAgICAgIHRoaXMuX21heEhlaWdodCA9IGNvZXJjZUNzc1BpeGVsVmFsdWUodmFsdWUpO1xuICAgICAgICB9XG4gICAgfVxuXG4gICAgY29uc3RydWN0b3IoKSB7IH1cblxuICAgIG5nT25Jbml0KCk6IHZvaWQgeyB9XG5cbiAgICBvbkNoYW5nZTogYW55ID0gKCkgPT4geyB9O1xuXG4gICAgb25Ub3VjaDogYW55ID0gKCkgPT4geyB9O1xuXG4gICAgcmVnaXN0ZXJPbkNoYW5nZShmbjogYW55KTogdm9pZCB7XG4gICAgICAgIHRoaXMub25DaGFuZ2UgPSBmbjtcbiAgICB9XG5cbiAgICByZWdpc3Rlck9uVG91Y2hlZChmbjogYW55KTogdm9pZCB7XG4gICAgICAgIHRoaXMub25Ub3VjaCA9IGZuO1xuICAgIH1cblxuICAgIHdyaXRlVmFsdWUodmFsdWU6IGFueSk6IHZvaWQge1xuICAgICAgICB0aGlzLnZhbHVlID0gdGhpcy5jaGVja1VwcGVyY2FzZSh2YWx1ZSk7XG4gICAgfVxuXG4gICAgY2hlY2tVcHBlcmNhc2UodmFsdWU6IGFueSk6IGFueSB7XG4gICAgICAgIGlmICh0aGlzLnVwcGVyQ2FzZSAmJiB2YWx1ZSkge1xuICAgICAgICAgICAgcmV0dXJuIHZhbHVlLnRvVXBwZXJDYXNlKCk7XG4gICAgICAgIH1cbiAgICAgICAgcmV0dXJuIHZhbHVlO1xuICAgIH1cblxufVxuIl19

package/esm5/shared/directives/dynamic-tab.directive.js

@@ -0,0 +1,19 @@
+import { __decorate, __metadata } from "tslib";
+import { Directive, ViewContainerRef } from '@angular/core';
+var DynamicTabDirective = /** @class */ (function () {
+    function DynamicTabDirective(viewContainer) {
+        this.viewContainer = viewContainer;
+    }
+    DynamicTabDirective.ctorParameters = function () { return [
+        { type: ViewContainerRef }
+    ]; };
+    DynamicTabDirective = __decorate([
+        Directive({
+            selector: '[dynamicTab]'
+        }),
+        __metadata("design:paramtypes", [ViewContainerRef])
+    ], DynamicTabDirective);
+    return DynamicTabDirective;
+}());
+export { DynamicTabDirective };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHluYW1pYy10YWIuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQGdpcGlzaXN0ZW1hcy9uZy1jb3JlLyIsInNvdXJjZXMiOlsic2hhcmVkL2RpcmVjdGl2ZXMvZHluYW1pYy10YWIuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPLEVBQUMsU0FBUyxFQUFFLGdCQUFnQixFQUFDLE1BQU0sZUFBZSxDQUFDO0FBSzFEO0lBRUUsNkJBQW1CLGFBQStCO1FBQS9CLGtCQUFhLEdBQWIsYUFBYSxDQUFrQjtJQUNsRCxDQUFDOztnQkFEaUMsZ0JBQWdCOztJQUZ2QyxtQkFBbUI7UUFIL0IsU0FBUyxDQUFDO1lBQ1QsUUFBUSxFQUFFLGNBQWM7U0FDekIsQ0FBQzt5Q0FHa0MsZ0JBQWdCO09BRnZDLG1CQUFtQixDQUsvQjtJQUFELDBCQUFDO0NBQUEsQUFMRCxJQUtDO1NBTFksbUJBQW1CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtEaXJlY3RpdmUsIFZpZXdDb250YWluZXJSZWZ9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5ARGlyZWN0aXZlKHtcbiAgc2VsZWN0b3I6ICdbZHluYW1pY1RhYl0nXG59KVxuZXhwb3J0IGNsYXNzIER5bmFtaWNUYWJEaXJlY3RpdmUge1xuXG4gIGNvbnN0cnVjdG9yKHB1YmxpYyB2aWV3Q29udGFpbmVyOiBWaWV3Q29udGFpbmVyUmVmKSB7XG4gIH1cblxufVxuIl19

package/esm5/shared/directives/generic-template.directive.js

@@ -0,0 +1,31 @@
+import { __decorate, __metadata } from "tslib";
+import { Directive, Input, TemplateRef } from '@angular/core';
+var ItssTemplate = /** @class */ (function () {
+    function ItssTemplate(template) {
+        this.template = template;
+    }
+    ItssTemplate.prototype.getType = function () {
+        return this.name;
+    };
+    ItssTemplate.ctorParameters = function () { return [
+        { type: TemplateRef }
+    ]; };
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], ItssTemplate.prototype, "type", void 0);
+    __decorate([
+        Input('pTemplate'),
+        __metadata("design:type", String)
+    ], ItssTemplate.prototype, "name", void 0);
+    ItssTemplate = __decorate([
+        Directive({
+            selector: '[pTemplate]',
+            host: {}
+        }),
+        __metadata("design:paramtypes", [TemplateRef])
+    ], ItssTemplate);
+    return ItssTemplate;
+}());
+export { ItssTemplate };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2VuZXJpYy10ZW1wbGF0ZS5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AZ2lwaXNpc3RlbWFzL25nLWNvcmUvIiwic291cmNlcyI6WyJzaGFyZWQvZGlyZWN0aXZlcy9nZW5lcmljLXRlbXBsYXRlLmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxLQUFLLEVBQUUsV0FBVyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBTTlEO0lBTUksc0JBQW1CLFFBQTBCO1FBQTFCLGFBQVEsR0FBUixRQUFRLENBQWtCO0lBQUksQ0FBQztJQUVsRCw4QkFBTyxHQUFQO1FBQ0ksT0FBTyxJQUFJLENBQUMsSUFBSSxDQUFDO0lBQ3JCLENBQUM7O2dCQUo0QixXQUFXOztJQUovQjtRQUFSLEtBQUssRUFBRTs7OENBQWM7SUFFRjtRQUFuQixLQUFLLENBQUMsV0FBVyxDQUFDOzs4Q0FBYztJQUp4QixZQUFZO1FBSnhCLFNBQVMsQ0FBQztZQUNQLFFBQVEsRUFBRSxhQUFhO1lBQ3ZCLElBQUksRUFBRSxFQUFFO1NBQ1gsQ0FBQzt5Q0FPK0IsV0FBVztPQU4vQixZQUFZLENBV3hCO0lBQUQsbUJBQUM7Q0FBQSxBQVhELElBV0M7U0FYWSxZQUFZIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGlyZWN0aXZlLCBJbnB1dCwgVGVtcGxhdGVSZWYgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQERpcmVjdGl2ZSh7XG4gICAgc2VsZWN0b3I6ICdbcFRlbXBsYXRlXScsXG4gICAgaG9zdDoge31cbn0pXG5leHBvcnQgY2xhc3MgSXRzc1RlbXBsYXRlIHtcblxuICAgIEBJbnB1dCgpIHR5cGU6IHN0cmluZztcblxuICAgIEBJbnB1dCgncFRlbXBsYXRlJykgbmFtZTogc3RyaW5nO1xuXG4gICAgY29uc3RydWN0b3IocHVibGljIHRlbXBsYXRlOiBUZW1wbGF0ZVJlZjxhbnk+KSB7IH1cblxuICAgIGdldFR5cGUoKTogc3RyaW5nIHtcbiAgICAgICAgcmV0dXJuIHRoaXMubmFtZTtcbiAgICB9XG59XG4iXX0=

package/esm5/shared/directives/input-select-infinite-scroll.directive.js

@@ -0,0 +1,113 @@
+import { __decorate, __metadata } from "tslib";
+import { AfterViewInit, Directive, EventEmitter, Input, NgZone, OnDestroy, OnInit, Output } from '@angular/core';
+import { MatSelect } from '@angular/material/select';
+import { fromEvent, Subject } from 'rxjs';
+import { debounceTime, takeUntil, tap } from 'rxjs/operators';
+/** A altura dos itens selecionados em unidades `em`. */
+var SELECT_ITEM_HEIGHT_EM = 3;
+/**
+ * Esta diretiva foi reescrita utilizando se do projeto a seguir
+ * https://github.com/HaidarZ/ng-mat-select-infinite-scroll
+ */
+var InputSelectInfiniteScrollDirective = /** @class */ (function () {
+    function InputSelectInfiniteScrollDirective(matSelect, ngZone) {
+        this.matSelect = matSelect;
+        this.ngZone = ngZone;
+        /**
+         * A distância limite da parte inferior da lista de opções para chamar o evento
+         * infiniteScroll quando rolado. O valor limite pode ser em porcentagem ou em
+         * pixels. Por exemplo, use o valor de 10%para que o infiniteScrollevento de saída
+         * seja chamado quando o usuário precisar de 10% para chegar ao fundo.
+         */
+        this.threshold = '15%';
+        /** O tempo limite antes de disparar o evento infiniteScroll */
+        this.debounceTime = 100;
+        /** Emitido quando o scroller dentro do mat-select atinge a distância necessária */
+        this.infiniteScroll = new EventEmitter();
+        this._thrPx = 0;
+        this._thrPc = 0;
+        this._singleOptionHeight = SELECT_ITEM_HEIGHT_EM;
+        this._destroyed$ = new Subject();
+    }
+    InputSelectInfiniteScrollDirective.prototype.ngOnInit = function () {
+        this.evaluateThreshold();
+    };
+    InputSelectInfiniteScrollDirective.prototype.ngAfterViewInit = function () {
+        var _this = this;
+        this.matSelect.openedChange.pipe(takeUntil(this._destroyed$)).subscribe(function (opened) {
+            if (opened) {
+                _this._panel = _this.matSelect.panel.nativeElement;
+                _this._singleOptionHeight = _this.getSelectItemHeightPx();
+                _this.registerScrollListener();
+            }
+        });
+    };
+    InputSelectInfiniteScrollDirective.prototype.ngOnDestroy = function () {
+        this._destroyed$.next(true);
+        this._destroyed$.complete();
+    };
+    InputSelectInfiniteScrollDirective.prototype.evaluateThreshold = function () {
+        if (this.threshold.lastIndexOf('%') > -1) {
+            this._thrPx = 0;
+            this._thrPc = (parseFloat(this.threshold) / 100);
+        }
+        else {
+            this._thrPx = parseFloat(this.threshold);
+            this._thrPc = 0;
+        }
+    };
+    InputSelectInfiniteScrollDirective.prototype.registerScrollListener = function () {
+        var _this = this;
+        fromEvent(this._panel, 'scroll').pipe(takeUntil(this._destroyed$), debounceTime(this.debounceTime), tap(function (event) {
+            _this.handleScrollEvent(event);
+        })).subscribe();
+    };
+    InputSelectInfiniteScrollDirective.prototype.handleScrollEvent = function (event) {
+        var _this = this;
+        this.ngZone.runOutsideAngular(function () {
+            if (_this.complete) {
+                return;
+            }
+            var countOfRenderedOptions = _this.matSelect.options.length;
+            var infiniteScrollDistance = _this._singleOptionHeight * countOfRenderedOptions;
+            var threshold = _this._thrPc !== 0 ? (infiniteScrollDistance * _this._thrPc) : _this._thrPx;
+            var scrolledDistance = _this._panel.clientHeight + event.target.scrollTop;
+            if ((scrolledDistance + threshold) >= infiniteScrollDistance) {
+                _this.ngZone.run(function () { return _this.infiniteScroll.emit(); });
+            }
+        });
+    };
+    InputSelectInfiniteScrollDirective.prototype.getSelectItemHeightPx = function () {
+        return parseFloat(getComputedStyle(this._panel).fontSize) * SELECT_ITEM_HEIGHT_EM;
+    };
+    InputSelectInfiniteScrollDirective.ctorParameters = function () { return [
+        { type: MatSelect },
+        { type: NgZone }
+    ]; };
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], InputSelectInfiniteScrollDirective.prototype, "threshold", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Number)
+    ], InputSelectInfiniteScrollDirective.prototype, "debounceTime", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], InputSelectInfiniteScrollDirective.prototype, "complete", void 0);
+    __decorate([
+        Output(),
+        __metadata("design:type", EventEmitter)
+    ], InputSelectInfiniteScrollDirective.prototype, "infiniteScroll", void 0);
+    InputSelectInfiniteScrollDirective = __decorate([
+        Directive({
+            selector: '[itssInfiniteScroll]'
+        }),
+        __metadata("design:paramtypes", [MatSelect,
+            NgZone])
+    ], InputSelectInfiniteScrollDirective);
+    return InputSelectInfiniteScrollDirective;
+}());
+export { InputSelectInfiniteScrollDirective };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"input-select-infinite-scroll.directive.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["shared/directives/input-select-infinite-scroll.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { AfterViewInit, Directive, EventEmitter, Input, NgZone, OnDestroy, OnInit, Output } from '@angular/core';\nimport { MatSelect } from '@angular/material/select';\nimport { fromEvent, Subject } from 'rxjs';\nimport { debounceTime, takeUntil, tap } from 'rxjs/operators';\n\n/** A altura dos itens selecionados em unidades `em`. */\nconst SELECT_ITEM_HEIGHT_EM = 3;\n\n/**\n * Esta diretiva foi reescrita utilizando se do projeto a seguir\n * https://github.com/HaidarZ/ng-mat-select-infinite-scroll\n */\n@Directive({\n    selector: '[itssInfiniteScroll]'\n})\nexport class InputSelectInfiniteScrollDirective implements OnInit, OnDestroy, AfterViewInit {\n\n    /**\n     * A distância limite da parte inferior da lista de opções para chamar o evento\n     * infiniteScroll quando rolado. O valor limite pode ser em porcentagem ou em\n     * pixels. Por exemplo, use o valor de 10%para que o infiniteScrollevento de saída\n     * seja chamado quando o usuário precisar de 10% para chegar ao fundo.\n     */\n    @Input() threshold: string = '15%';\n\n    /** O tempo limite antes de disparar o evento infiniteScroll */\n    @Input() debounceTime: number = 100;\n\n    /* Se true, a infiniteScroll não será mais acionada */\n    @Input() complete!: boolean;\n\n    /** Emitido quando o scroller dentro do mat-select atinge a distância necessária */\n    @Output() infiniteScroll: EventEmitter<void> = new EventEmitter<void>();\n\n    private _panel!: Element;\n\n    private _thrPx: number = 0;\n\n    private _thrPc: number = 0;\n\n    private _singleOptionHeight: number = SELECT_ITEM_HEIGHT_EM;\n\n    private _destroyed$: Subject<boolean> = new Subject<boolean>();\n\n    constructor(\n        private matSelect: MatSelect,\n        private ngZone: NgZone\n    ) { }\n\n    ngOnInit(): void {\n        this.evaluateThreshold();\n    }\n\n    ngAfterViewInit(): void {\n        this.matSelect.openedChange.pipe(\n            takeUntil(this._destroyed$)\n        ).subscribe((opened: boolean): void => {\n            if (opened) {\n                this._panel = this.matSelect.panel.nativeElement;\n                this._singleOptionHeight = this.getSelectItemHeightPx();\n                this.registerScrollListener();\n            }\n        });\n    }\n\n    ngOnDestroy(): void {\n        this._destroyed$.next(true);\n        this._destroyed$.complete();\n    }\n\n    evaluateThreshold(): void {\n        if (this.threshold.lastIndexOf('%') > -1) {\n            this._thrPx = 0;\n            this._thrPc = (parseFloat(this.threshold) / 100);\n\n        } else {\n            this._thrPx = parseFloat(this.threshold);\n            this._thrPc = 0;\n        }\n    }\n\n    registerScrollListener(): void {\n        fromEvent(this._panel, 'scroll').pipe(\n            takeUntil(this._destroyed$),\n            debounceTime(this.debounceTime),\n            tap((event: Event): void => {\n                this.handleScrollEvent(event);\n            })\n        ).subscribe();\n    }\n\n    handleScrollEvent(event: any): void {\n        this.ngZone.runOutsideAngular((): void => {\n            if (this.complete) {\n                return;\n            }\n            const countOfRenderedOptions: number = this.matSelect.options.length;\n            const infiniteScrollDistance: number = this._singleOptionHeight * countOfRenderedOptions;\n            const threshold: number = this._thrPc !== 0 ? (infiniteScrollDistance * this._thrPc) : this._thrPx;\n\n            const scrolledDistance: number = this._panel.clientHeight + event.target.scrollTop;\n\n            if ((scrolledDistance + threshold) >= infiniteScrollDistance) {\n                this.ngZone.run((): void => this.infiniteScroll.emit());\n            }\n        });\n    }\n\n    getSelectItemHeightPx(): number {\n        return parseFloat(getComputedStyle(this._panel).fontSize) * SELECT_ITEM_HEIGHT_EM;\n    }\n\n}\n"]}

package/esm5/shared/directives/lower-case.directive.js

@@ -0,0 +1,48 @@
+import { __decorate, __metadata } from "tslib";
+import { Directive, HostListener, Input } from '@angular/core';
+import { NgControl } from '@angular/forms';
+var LowerCaseDirective = /** @class */ (function () {
+    function LowerCaseDirective(ngControl) {
+        this.ngControl = ngControl;
+        this.enabledLowerCase = false;
+    }
+    LowerCaseDirective.prototype.ngModelChange = function (event) {
+        this.onInputChange(event);
+    };
+    LowerCaseDirective.prototype.keydown = function (event) {
+        this.onInputChange(event.target.value);
+    };
+    LowerCaseDirective.prototype.onInputChange = function (event) {
+        if (this.enabledLowerCase) {
+            this.ngControl.valueAccessor.writeValue(event.toLowerCase());
+        }
+    };
+    LowerCaseDirective.ctorParameters = function () { return [
+        { type: NgControl }
+    ]; };
+    __decorate([
+        Input(),
+        __metadata("design:type", Object)
+    ], LowerCaseDirective.prototype, "enabledLowerCase", void 0);
+    __decorate([
+        HostListener('ngModelChange', ['$event']),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", void 0)
+    ], LowerCaseDirective.prototype, "ngModelChange", null);
+    __decorate([
+        HostListener('keydown', ['$event']),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", void 0)
+    ], LowerCaseDirective.prototype, "keydown", null);
+    LowerCaseDirective = __decorate([
+        Directive({
+            selector: '[lowerCase]',
+        }),
+        __metadata("design:paramtypes", [NgControl])
+    ], LowerCaseDirective);
+    return LowerCaseDirective;
+}());
+export { LowerCaseDirective };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/shared/directives/phone-mask.directive.js

@@ -0,0 +1,61 @@
+import { __decorate, __metadata } from "tslib";
+import { Directive, HostListener } from '@angular/core';
+import { NgControl } from '@angular/forms';
+var PhoneMaskDirective = /** @class */ (function () {
+    function PhoneMaskDirective(ngControl) {
+        this.ngControl = ngControl;
+    }
+    PhoneMaskDirective.prototype.onModelChange = function (event) {
+        this.onInputChange(event, false);
+    };
+    PhoneMaskDirective.prototype.keydownBackspace = function (event) {
+        this.onInputChange(event.target.value, true);
+    };
+    PhoneMaskDirective.prototype.onInputChange = function (event, backspace) {
+        var newVal = event.replace(/\D/g, '');
+        if (backspace && newVal.length <= 6) {
+            newVal = newVal.substring(0, newVal.length - 1);
+        }
+        if (newVal.length === 0) {
+            newVal = '';
+        }
+        else if (newVal.length <= 3) {
+            newVal = newVal.replace(/^(\d{0,2})/, '($1)');
+        }
+        else if (newVal.length <= 6) {
+            newVal = newVal.replace(/^(\d{0,2})(\d{0,4})/, '($1) $2');
+        }
+        else if (newVal.length <= 10) {
+            newVal = newVal.replace(/^(\d{0,2})(\d{0,4})(\d{0,4})/, '($1) $2-$3');
+        }
+        else {
+            newVal = newVal.substring(0, 11);
+            newVal = newVal.replace(/^(\d{0,2})(\d{0,5})(\d{0,4})/, '($1) $2-$3');
+        }
+        this.ngControl.valueAccessor.writeValue(newVal);
+    };
+    PhoneMaskDirective.ctorParameters = function () { return [
+        { type: NgControl }
+    ]; };
+    __decorate([
+        HostListener('ngModelChange', ['$event']),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", void 0)
+    ], PhoneMaskDirective.prototype, "onModelChange", null);
+    __decorate([
+        HostListener('keydown.backspace', ['$event']),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", void 0)
+    ], PhoneMaskDirective.prototype, "keydownBackspace", null);
+    PhoneMaskDirective = __decorate([
+        Directive({
+            selector: '[phoneMask]',
+        }),
+        __metadata("design:paramtypes", [NgControl])
+    ], PhoneMaskDirective);
+    return PhoneMaskDirective;
+}());
+export { PhoneMaskDirective };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGhvbmUtbWFzay5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AZ2lwaXNpc3RlbWFzL25nLWNvcmUvIiwic291cmNlcyI6WyJzaGFyZWQvZGlyZWN0aXZlcy9waG9uZS1tYXNrLmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsT0FBTyxFQUFDLFNBQVMsRUFBRSxZQUFZLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFDdEQsT0FBTyxFQUFDLFNBQVMsRUFBQyxNQUFNLGdCQUFnQixDQUFDO0FBS3pDO0lBRUUsNEJBQW1CLFNBQW9CO1FBQXBCLGNBQVMsR0FBVCxTQUFTLENBQVc7SUFDdkMsQ0FBQztJQUdELDBDQUFhLEdBQWIsVUFBYyxLQUFLO1FBQ2pCLElBQUksQ0FBQyxhQUFhLENBQUMsS0FBSyxFQUFFLEtBQUssQ0FBQyxDQUFDO0lBQ25DLENBQUM7SUFHRCw2Q0FBZ0IsR0FBaEIsVUFBaUIsS0FBSztRQUNwQixJQUFJLENBQUMsYUFBYSxDQUFDLEtBQUssQ0FBQyxNQUFNLENBQUMsS0FBSyxFQUFFLElBQUksQ0FBQyxDQUFDO0lBQy9DLENBQUM7SUFHRCwwQ0FBYSxHQUFiLFVBQWMsS0FBSyxFQUFFLFNBQVM7UUFDNUIsSUFBSSxNQUFNLEdBQUcsS0FBSyxDQUFDLE9BQU8sQ0FBQyxLQUFLLEVBQUUsRUFBRSxDQUFDLENBQUM7UUFDdEMsSUFBSSxTQUFTLElBQUksTUFBTSxDQUFDLE1BQU0sSUFBSSxDQUFDLEVBQUU7WUFDbkMsTUFBTSxHQUFHLE1BQU0sQ0FBQyxTQUFTLENBQUMsQ0FBQyxFQUFFLE1BQU0sQ0FBQyxNQUFNLEdBQUcsQ0FBQyxDQUFDLENBQUM7U0FDakQ7UUFDRCxJQUFJLE1BQU0sQ0FBQyxNQUFNLEtBQUssQ0FBQyxFQUFFO1lBQ3ZCLE1BQU0sR0FBRyxFQUFFLENBQUM7U0FDYjthQUFNLElBQUksTUFBTSxDQUFDLE1BQU0sSUFBSSxDQUFDLEVBQUU7WUFDN0IsTUFBTSxHQUFHLE1BQU0sQ0FBQyxPQUFPLENBQUMsWUFBWSxFQUFFLE1BQU0sQ0FBQyxDQUFDO1NBQy9DO2FBQU0sSUFBSSxNQUFNLENBQUMsTUFBTSxJQUFJLENBQUMsRUFBRTtZQUM3QixNQUFNLEdBQUcsTUFBTSxDQUFDLE9BQU8sQ0FBQyxxQkFBcUIsRUFBRSxTQUFTLENBQUMsQ0FBQztTQUMzRDthQUFNLElBQUksTUFBTSxDQUFDLE1BQU0sSUFBSSxFQUFFLEVBQUU7WUFDOUIsTUFBTSxHQUFHLE1BQU0sQ0FBQyxPQUFPLENBQUMsOEJBQThCLEVBQUUsWUFBWSxDQUFDLENBQUM7U0FDdkU7YUFBTTtZQUNMLE1BQU0sR0FBRyxNQUFNLENBQUMsU0FBUyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQztZQUNqQyxNQUFNLEdBQUcsTUFBTSxDQUFDLE9BQU8sQ0FBQyw4QkFBOEIsRUFBRSxZQUFZLENBQUMsQ0FBQztTQUN2RTtRQUNELElBQUksQ0FBQyxTQUFTLENBQUMsYUFBYSxDQUFDLFVBQVUsQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUNsRCxDQUFDOztnQkFoQzZCLFNBQVM7O0lBSXZDO1FBREMsWUFBWSxDQUFDLGVBQWUsRUFBRSxDQUFDLFFBQVEsQ0FBQyxDQUFDOzs7OzJEQUd6QztJQUdEO1FBREMsWUFBWSxDQUFDLG1CQUFtQixFQUFFLENBQUMsUUFBUSxDQUFDLENBQUM7Ozs7OERBRzdDO0lBYlUsa0JBQWtCO1FBSDlCLFNBQVMsQ0FBQztZQUNULFFBQVEsRUFBRSxhQUFhO1NBQ3hCLENBQUM7eUNBRzhCLFNBQVM7T0FGNUIsa0JBQWtCLENBbUM5QjtJQUFELHlCQUFDO0NBQUEsQUFuQ0QsSUFtQ0M7U0FuQ1ksa0JBQWtCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtEaXJlY3RpdmUsIEhvc3RMaXN0ZW5lcn0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge05nQ29udHJvbH0gZnJvbSAnQGFuZ3VsYXIvZm9ybXMnO1xuXG5ARGlyZWN0aXZlKHtcbiAgc2VsZWN0b3I6ICdbcGhvbmVNYXNrXScsXG59KVxuZXhwb3J0IGNsYXNzIFBob25lTWFza0RpcmVjdGl2ZSB7XG5cbiAgY29uc3RydWN0b3IocHVibGljIG5nQ29udHJvbDogTmdDb250cm9sKSB7XG4gIH1cblxuICBASG9zdExpc3RlbmVyKCduZ01vZGVsQ2hhbmdlJywgWyckZXZlbnQnXSlcbiAgb25Nb2RlbENoYW5nZShldmVudCkge1xuICAgIHRoaXMub25JbnB1dENoYW5nZShldmVudCwgZmFsc2UpO1xuICB9XG5cbiAgQEhvc3RMaXN0ZW5lcigna2V5ZG93bi5iYWNrc3BhY2UnLCBbJyRldmVudCddKVxuICBrZXlkb3duQmFja3NwYWNlKGV2ZW50KSB7XG4gICAgdGhpcy5vbklucHV0Q2hhbmdlKGV2ZW50LnRhcmdldC52YWx1ZSwgdHJ1ZSk7XG4gIH1cblxuXG4gIG9uSW5wdXRDaGFuZ2UoZXZlbnQsIGJhY2tzcGFjZSkge1xuICAgIGxldCBuZXdWYWwgPSBldmVudC5yZXBsYWNlKC9cXEQvZywgJycpO1xuICAgIGlmIChiYWNrc3BhY2UgJiYgbmV3VmFsLmxlbmd0aCA8PSA2KSB7XG4gICAgICBuZXdWYWwgPSBuZXdWYWwuc3Vic3RyaW5nKDAsIG5ld1ZhbC5sZW5ndGggLSAxKTtcbiAgICB9XG4gICAgaWYgKG5ld1ZhbC5sZW5ndGggPT09IDApIHtcbiAgICAgIG5ld1ZhbCA9ICcnO1xuICAgIH0gZWxzZSBpZiAobmV3VmFsLmxlbmd0aCA8PSAzKSB7XG4gICAgICBuZXdWYWwgPSBuZXdWYWwucmVwbGFjZSgvXihcXGR7MCwyfSkvLCAnKCQxKScpO1xuICAgIH0gZWxzZSBpZiAobmV3VmFsLmxlbmd0aCA8PSA2KSB7XG4gICAgICBuZXdWYWwgPSBuZXdWYWwucmVwbGFjZSgvXihcXGR7MCwyfSkoXFxkezAsNH0pLywgJygkMSkgJDInKTtcbiAgICB9IGVsc2UgaWYgKG5ld1ZhbC5sZW5ndGggPD0gMTApIHtcbiAgICAgIG5ld1ZhbCA9IG5ld1ZhbC5yZXBsYWNlKC9eKFxcZHswLDJ9KShcXGR7MCw0fSkoXFxkezAsNH0pLywgJygkMSkgJDItJDMnKTtcbiAgICB9IGVsc2Uge1xuICAgICAgbmV3VmFsID0gbmV3VmFsLnN1YnN0cmluZygwLCAxMSk7XG4gICAgICBuZXdWYWwgPSBuZXdWYWwucmVwbGFjZSgvXihcXGR7MCwyfSkoXFxkezAsNX0pKFxcZHswLDR9KS8sICcoJDEpICQyLSQzJyk7XG4gICAgfVxuICAgIHRoaXMubmdDb250cm9sLnZhbHVlQWNjZXNzb3Iud3JpdGVWYWx1ZShuZXdWYWwpO1xuICB9XG59XG4iXX0=