@gipisistemas/ng-core 1.1.3 → 1.1.4

package/esm5/shared/gipi-components/tabs/tab-group/tab-group.component.js

@@ -0,0 +1,131 @@
+import { __decorate, __metadata, __read, __spread } from "tslib";
+import { AfterContentInit, Component, ComponentFactory, ComponentFactoryResolver, ComponentRef, ContentChildren, ElementRef, OnInit, QueryList, TemplateRef, ViewChild, ViewContainerRef } from '@angular/core';
+import { GIPIDynamicTabDirective } from '../shared/dynamic-tab.directive';
+import { TabModel } from '../shared/tab.model';
+import { GIPITabComponent } from '../tab/tab.component';
+var GIPITabGroupComponent = /** @class */ (function () {
+    function GIPITabGroupComponent(elementRef, _componentFactoryResolver) {
+        this.elementRef = elementRef;
+        this._componentFactoryResolver = _componentFactoryResolver;
+        this.dynamicTabs = [];
+    }
+    GIPITabGroupComponent.prototype.ngOnInit = function () { };
+    GIPITabGroupComponent.prototype.ngAfterContentInit = function () {
+        var activeTabs = this.tabQueryList.filter(function (tab) { return tab.active; });
+        if (activeTabs.length === 0 && this.tabQueryList.length > 0) {
+            this.selectTab(this.tabQueryList.first);
+        }
+    };
+    GIPITabGroupComponent.prototype.openTab = function (label, template, data, closeable, disabled, action) {
+        if (closeable === void 0) { closeable = false; }
+        if (disabled === void 0) { disabled = false; }
+        var tab = new TabModel();
+        tab.label = label;
+        tab.template = template;
+        tab.data = data;
+        tab.closeable = closeable;
+        tab.disabled = disabled;
+        tab.action = action;
+        this._openTabs(Array(tab));
+    };
+    GIPITabGroupComponent.prototype._openTabs = function (tabList) {
+        var _a;
+        var _this = this;
+        var tabsComponent = tabList.map(function (tab) { return _this._getTabComponent(tab.label, tab.template, tab.data, tab.closeable, tab.disabled, tab.action); });
+        (_a = this.dynamicTabs).push.apply(_a, __spread(tabsComponent));
+        this.selectTab(this.dynamicTabs[0]);
+    };
+    GIPITabGroupComponent.prototype._getTabComponent = function (label, template, data, closeable, disabled, action) {
+        if (closeable === void 0) { closeable = false; }
+        if (disabled === void 0) { disabled = false; }
+        var componentFactory = this._componentFactoryResolver.resolveComponentFactory(GIPITabComponent);
+        var componentRef = this.dynamicTabPlaceholder.viewContainer.createComponent(componentFactory);
+        var instance = componentRef.instance;
+        instance.label = label;
+        instance.template = template;
+        instance.data = data;
+        instance.closeable = closeable;
+        instance.disabled = disabled;
+        instance.action = action;
+        return componentRef.instance;
+    };
+    GIPITabGroupComponent.prototype.selectTab = function (tab) {
+        this.tabQueryList.toArray().forEach(function (t) { return (t.active = false); });
+        this.dynamicTabs.forEach(function (t) { return (t.active = false); });
+        tab.active = true;
+        tab.selectionChange.emit();
+        if (tab.action) {
+            tab.action(tab.data);
+        }
+    };
+    GIPITabGroupComponent.prototype.closeTab = function (tab) {
+        var index = this.dynamicTabs.indexOf(tab);
+        this.dynamicTabs.splice(index, 1);
+        var viewContainerRef = this.dynamicTabPlaceholder.viewContainer;
+        viewContainerRef.remove(index);
+        if (this.tabQueryList.length > 0) {
+            this.selectTab(this.tabQueryList.first);
+        }
+    };
+    GIPITabGroupComponent.prototype.closeActiveTab = function () {
+        var activeTabs = this.dynamicTabs.filter(function (tab) { return tab.active; });
+        if (activeTabs.length > 0) {
+            this.closeTab(activeTabs[0]);
+        }
+    };
+    GIPITabGroupComponent.prototype.closeAllTabs = function () {
+        var _this = this;
+        var tabs = Object.assign([], this.dynamicTabs);
+        if (tabs.length > 0) {
+            tabs.forEach(function (tab) { return _this.closeTab(tab); });
+        }
+    };
+    GIPITabGroupComponent.prototype.nextTab = function () {
+        var currentTab = this.tabQueryList.toArray().find(function (tab) { return tab.active; });
+        var nextTab = this.tabQueryList.toArray()[this.tabQueryList.toArray().indexOf(currentTab) + 1];
+        if (nextTab != null) {
+            this.tabQueryList.toArray().forEach(function (t) { return (t.active = false); });
+            this.dynamicTabs.forEach(function (t) { return (t.active = false); });
+            nextTab.active = true;
+            nextTab.selectionChange.emit();
+        }
+    };
+    GIPITabGroupComponent.prototype.previousTab = function () {
+        var currentTab = this.tabQueryList.toArray().find(function (tab) { return tab.active; });
+        var previousTab = this.tabQueryList.toArray()[this.tabQueryList.toArray().indexOf(currentTab) - 1];
+        if (previousTab != null) {
+            this.tabQueryList.toArray().forEach(function (t) { return (t.active = false); });
+            this.dynamicTabs.forEach(function (t) { return (t.active = false); });
+            previousTab.active = true;
+            previousTab.selectionChange.emit();
+        }
+    };
+    GIPITabGroupComponent.ctorParameters = function () { return [
+        { type: ElementRef },
+        { type: ComponentFactoryResolver }
+    ]; };
+    __decorate([
+        ContentChildren(GIPITabComponent),
+        __metadata("design:type", QueryList)
+    ], GIPITabGroupComponent.prototype, "tabQueryList", void 0);
+    __decorate([
+        ViewChild(GIPIDynamicTabDirective, { static: false }),
+        __metadata("design:type", GIPIDynamicTabDirective)
+    ], GIPITabGroupComponent.prototype, "dynamicTabPlaceholder", void 0);
+    GIPITabGroupComponent = __decorate([
+        Component({
+            selector: 'gipi-tab-group',
+            exportAs: 'gipiTabGroup',
+            template: "<nav mat-tab-nav-bar>\n    <a mat-tab-link\n       *ngFor=\"let tab of tabQueryList\"\n       (click)=\"selectTab(tab)\"\n       [class.active]=\"tab.active\"\n       [disabled]=\"tab.disabled\">\n        <mat-icon *ngIf=\"tab.icon || tab.svgIcon\"\n                  [svgIcon]=\"tab.svgIcon ? tab.svgIcon : ''\">\n            {{ !tab.svgIcon && tab.icon ? tab.icon : '' }}\n        </mat-icon>\n\n        {{ tab.label }}\n    </a>\n\n    <a mat-tab-link\n       *ngFor=\"let tab of dynamicTabs\"\n       (click)=\"selectTab(tab)\"\n       [class.active]=\"tab.active\"\n       [disabled]=\"tab.disabled\">\n        <mat-icon *ngIf=\"tab.icon || tab.svgIcon\"\n                  [svgIcon]=\"tab.svgIcon ? tab.svgIcon : ''\">\n            {{ !tab.svgIcon && tab.icon ? tab.icon : '' }}\n        </mat-icon>\n\n        {{ tab.label }}\n    </a>\n</nav>\n\n<ng-content> </ng-content>\n<ng-template dynamicTab\n             #container>\n</ng-template>",
+            host: {
+                'class': 'gipi-tab-group',
+            },
+            styles: [":host{display:block;flex:1;width:100%;box-shadow:0 4px 6px -1px rgba(0,0,0,.1),0 2px 4px -2px rgba(0,0,0,.1)}:host ::ng-deep .mat-tab-nav-bar{background:#f5f5f6;border:none;border-radius:.4rem;padding:.4rem;box-shadow:0 1px 3px 0 rgba(0,0,0,.1),0 1px 2px -1px rgba(0,0,0,.1)}:host ::ng-deep .mat-tab-links{display:flex;gap:1rem}:host ::ng-deep .mat-tab-link{height:auto!important;padding:1rem!important;opacity:1!important;border:none!important;border-radius:4px!important;transition:.2s!important;color:#595959!important;gap:1rem}:host ::ng-deep .mat-tab-link>mat-icon{width:2rem!important;height:2rem!important;font-size:2rem!important;color:#595959!important}:host ::ng-deep .mat-tab-link>mat-icon svg,:host ::ng-deep .mat-tab-link>mat-icon svg g path,:host ::ng-deep .mat-tab-link>mat-icon svg path{color:#595959!important;fill:#595959!important}:host ::ng-deep .mat-tab-link:not(.active):hover{background:#e0e1e2!important}:host ::ng-deep .mat-tab-link.active{background:#e0313e!important;color:#fff!important}:host ::ng-deep .mat-tab-link.active>mat-icon{color:#fff!important}:host ::ng-deep .mat-tab-link.active>mat-icon svg,:host ::ng-deep .mat-tab-link.active>mat-icon svg g path,:host ::ng-deep .mat-tab-link.active>mat-icon svg path{color:#fff!important;fill:#fff!important}:host ::ng-deep .mat-tab-link:disabled,:host ::ng-deep .mat-tab-link:disabled>mat-icon{color:#9a9da2!important;fill:#9a9da2!important}:host ::ng-deep .mat-tab-link:disabled svg,:host ::ng-deep .mat-tab-link:disabled svg g path,:host ::ng-deep .mat-tab-link:disabled svg path,:host ::ng-deep .mat-tab-link:disabled>mat-icon svg,:host ::ng-deep .mat-tab-link:disabled>mat-icon svg g path,:host ::ng-deep .mat-tab-link:disabled>mat-icon svg path{color:#9a9da2!important;fill:#9a9da2!important}:host ::ng-deep .mat-ink-bar{display:none!important}"]
+        }),
+        __metadata("design:paramtypes", [ElementRef,
+            ComponentFactoryResolver])
+    ], GIPITabGroupComponent);
+    return GIPITabGroupComponent;
+}());
+export { GIPITabGroupComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tab-group.component.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["shared/gipi-components/tabs/tab-group/tab-group.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { AfterContentInit, Component, ComponentFactory, ComponentFactoryResolver, ComponentRef, ContentChildren, ElementRef, OnInit, QueryList, TemplateRef, ViewChild, ViewContainerRef } from '@angular/core';\n\nimport { GIPIDynamicTabDirective } from '../shared/dynamic-tab.directive';\nimport { TabModel } from '../shared/tab.model';\nimport { GIPITabComponent } from '../tab/tab.component';\n\n@Component({\n    selector: 'gipi-tab-group',\n    exportAs: 'gipiTabGroup',\n    templateUrl: './tab-group.component.html',\n    styleUrls: ['./tab-group.component.scss'],\n    host: {\n        'class': 'gipi-tab-group',\n    },\n})\nexport class GIPITabGroupComponent implements AfterContentInit, OnInit {\n\n    @ContentChildren(GIPITabComponent) tabQueryList: QueryList<GIPITabComponent>;\n    @ViewChild(GIPIDynamicTabDirective, { static: false }) dynamicTabPlaceholder: GIPIDynamicTabDirective;\n\n    public dynamicTabs: GIPITabComponent[] = [];\n\n    constructor(\n        public elementRef: ElementRef,\n        private _componentFactoryResolver: ComponentFactoryResolver\n    ) { }\n\n    ngOnInit(): void { }\n\n    ngAfterContentInit() {\n        const activeTabs: GIPITabComponent[] = this.tabQueryList.filter(tab => tab.active);\n        if (activeTabs.length === 0 && this.tabQueryList.length > 0) {\n            this.selectTab(this.tabQueryList.first);\n        }\n    }\n\n    public openTab(label: string, template?: TemplateRef<any>, data?: any, closeable: boolean = false, disabled: boolean = false, action?: (obj: any) => void): void {\n        const tab: TabModel = new TabModel();\n        tab.label = label;\n        tab.template = template;\n        tab.data = data;\n        tab.closeable = closeable;\n        tab.disabled = disabled;\n        tab.action = action;\n        this._openTabs(Array(tab));\n    }\n\n    private _openTabs(tabList: TabModel[]): void {\n        const tabsComponent: GIPITabComponent[] = tabList.map(tab => this._getTabComponent(tab.label, tab.template, tab.data, tab.closeable, tab.disabled, tab.action));\n        this.dynamicTabs.push(...tabsComponent);\n        this.selectTab(this.dynamicTabs[0]);\n    }\n\n    private _getTabComponent(label: string, template?: TemplateRef<any>, data?: any, closeable: boolean = false, disabled: boolean = false, action?: (obj: any) => void): GIPITabComponent {\n        const componentFactory: ComponentFactory<GIPITabComponent> = this._componentFactoryResolver.resolveComponentFactory(GIPITabComponent);\n        const componentRef: ComponentRef<GIPITabComponent> = this.dynamicTabPlaceholder.viewContainer.createComponent(componentFactory);\n\n        const instance = componentRef.instance;\n        instance.label = label;\n        instance.template = template;\n        instance.data = data;\n        instance.closeable = closeable;\n        instance.disabled = disabled;\n        instance.action = action;\n\n        return componentRef.instance;\n    }\n\n    public selectTab(tab: GIPITabComponent): void {\n        this.tabQueryList.toArray().forEach(t => (t.active = false));\n        this.dynamicTabs.forEach(t => (t.active = false));\n        tab.active = true;\n        tab.selectionChange.emit();\n\n        if (tab.action) {\n            tab.action(tab.data);\n        }\n    }\n\n    public closeTab(tab: GIPITabComponent): void {\n        const index: number = this.dynamicTabs.indexOf(tab);\n        this.dynamicTabs.splice(index, 1);\n\n        const viewContainerRef: ViewContainerRef = this.dynamicTabPlaceholder.viewContainer;\n        viewContainerRef.remove(index);\n\n        if (this.tabQueryList.length > 0) {\n            this.selectTab(this.tabQueryList.first);\n        }\n    }\n\n    public closeActiveTab(): void {\n        const activeTabs = this.dynamicTabs.filter(tab => tab.active);\n        if (activeTabs.length > 0) {\n            this.closeTab(activeTabs[0]);\n        }\n    }\n\n    public closeAllTabs(): void {\n        const tabs = Object.assign([], this.dynamicTabs);\n        if (tabs.length > 0) {\n            tabs.forEach(tab => this.closeTab(tab));\n        }\n    }\n\n    public nextTab(): void {\n        const currentTab: GIPITabComponent = this.tabQueryList.toArray().find(tab => tab.active);\n        const nextTab: GIPITabComponent = this.tabQueryList.toArray()[this.tabQueryList.toArray().indexOf(currentTab) + 1];\n        if (nextTab != null) {\n            this.tabQueryList.toArray().forEach(t => (t.active = false));\n            this.dynamicTabs.forEach(t => (t.active = false));\n            nextTab.active = true;\n            nextTab.selectionChange.emit();\n        }\n    }\n\n    public previousTab(): void {\n        const currentTab: GIPITabComponent = this.tabQueryList.toArray().find(tab => tab.active);\n        const previousTab: GIPITabComponent = this.tabQueryList.toArray()[this.tabQueryList.toArray().indexOf(currentTab) - 1];\n        if (previousTab != null) {\n            this.tabQueryList.toArray().forEach(t => (t.active = false));\n            this.dynamicTabs.forEach(t => (t.active = false));\n            previousTab.active = true;\n            previousTab.selectionChange.emit();\n        }\n    }\n\n}\n\n"]}

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

@@ -0,0 +1,352 @@
+import { __decorate, __metadata } from "tslib";
+import { coerceBooleanProperty, coerceCssPixelValue } from '@angular/cdk/coercion';
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, forwardRef, Input, OnInit } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+var nextUniqueId = 0;
+var GIPITextareaComponent = /** @class */ (function () {
+    function GIPITextareaComponent(elementRef, _changeDetectorRef) {
+        this.elementRef = elementRef;
+        this._changeDetectorRef = _changeDetectorRef;
+        this._name = "gipi-textarea-" + nextUniqueId++;
+        this.id = this._name;
+        this.name = this._name;
+        this.label = '';
+        this.placeholder = '';
+        this.cols = 20;
+        this.rows = 4;
+        this.help = '';
+        this.maxlength = 254;
+        this.minlength = 0;
+        this._resize = 'horizontal';
+        this._minHeight = '60px';
+        this._height = '60px';
+        this._maxHeight = 'auto';
+        this._autocomplete = 'off';
+        this._autofocus = false;
+        this._readOnly = false;
+        this._required = false;
+        this._disabled = false;
+        this._lowerCase = false;
+        this._upperCase = false;
+        this._spaceDrop = false;
+        this.onChange = function () { };
+        this.onTouched = function () { };
+    }
+    GIPITextareaComponent_1 = GIPITextareaComponent;
+    Object.defineProperty(GIPITextareaComponent.prototype, "resize", {
+        get: function () {
+            return this._resize;
+        },
+        set: function (value) {
+            if (value !== this.resize) {
+                this._resize = value.toLowerCase();
+                this._changeDetectorRef.detectChanges();
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPITextareaComponent.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(GIPITextareaComponent.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(GIPITextareaComponent.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
+    });
+    Object.defineProperty(GIPITextareaComponent.prototype, "autocomplete", {
+        get: function () {
+            return this._autocomplete;
+        },
+        set: function (value) {
+            this._autocomplete = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPITextareaComponent.prototype, "autofocus", {
+        get: function () {
+            return this._autofocus;
+        },
+        set: function (value) {
+            this._autofocus = coerceBooleanProperty(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPITextareaComponent.prototype, "readOnly", {
+        get: function () {
+            return this._readOnly;
+        },
+        set: function (value) {
+            this._readOnly = coerceBooleanProperty(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPITextareaComponent.prototype, "required", {
+        get: function () {
+            return this._required;
+        },
+        set: function (value) {
+            this._required = coerceBooleanProperty(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPITextareaComponent.prototype, "disabled", {
+        get: function () {
+            return this._disabled;
+        },
+        set: function (value) {
+            this._disabled = coerceBooleanProperty(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPITextareaComponent.prototype, "lowerCase", {
+        get: function () {
+            return this._lowerCase;
+        },
+        set: function (value) {
+            this._lowerCase = coerceBooleanProperty(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPITextareaComponent.prototype, "upperCase", {
+        get: function () {
+            return this._upperCase;
+        },
+        set: function (value) {
+            this._upperCase = coerceBooleanProperty(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPITextareaComponent.prototype, "spaceDrop", {
+        get: function () {
+            return this._spaceDrop;
+        },
+        set: function (value) {
+            this._spaceDrop = coerceBooleanProperty(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPITextareaComponent.prototype, "value", {
+        get: function () {
+            return this._value;
+        },
+        set: function (value) {
+            var valueAux = value;
+            valueAux = this._checkSpaceDrop(valueAux);
+            valueAux = this._checkLowercase(valueAux);
+            valueAux = this._checkUppercase(valueAux);
+            this._value = valueAux;
+            this.onChange(this._value);
+            this.onTouched(this._value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    GIPITextareaComponent.prototype.ngOnInit = function () { };
+    GIPITextareaComponent.prototype.writeValue = function (value) {
+        this._value = value;
+    };
+    GIPITextareaComponent.prototype.registerOnChange = function (fn) {
+        this.onChange = fn;
+    };
+    GIPITextareaComponent.prototype.registerOnTouched = function (fn) {
+        this.onTouched = fn;
+    };
+    GIPITextareaComponent.prototype.setDisabledState = function (isDisabled) {
+        this.disabled = isDisabled;
+        this._changeDetectorRef.markForCheck();
+    };
+    GIPITextareaComponent.prototype._checkSpaceDrop = function (value) {
+        if (this.spaceDrop && value) {
+            return value.replace(/\s/g, '');
+        }
+        return value;
+    };
+    GIPITextareaComponent.prototype._checkUppercase = function (value) {
+        if (this.upperCase && value) {
+            return value.toUpperCase();
+        }
+        return value;
+    };
+    GIPITextareaComponent.prototype._checkLowercase = function (value) {
+        if (this.lowerCase && value) {
+            return value.toLowerCase();
+        }
+        return value;
+    };
+    var GIPITextareaComponent_1;
+    GIPITextareaComponent.ctorParameters = function () { return [
+        { type: ElementRef },
+        { type: ChangeDetectorRef }
+    ]; };
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], GIPITextareaComponent.prototype, "id", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], GIPITextareaComponent.prototype, "name", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], GIPITextareaComponent.prototype, "label", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], GIPITextareaComponent.prototype, "placeholder", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Number)
+    ], GIPITextareaComponent.prototype, "cols", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Number)
+    ], GIPITextareaComponent.prototype, "rows", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], GIPITextareaComponent.prototype, "help", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Number)
+    ], GIPITextareaComponent.prototype, "maxlength", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Number)
+    ], GIPITextareaComponent.prototype, "minlength", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String),
+        __metadata("design:paramtypes", [String])
+    ], GIPITextareaComponent.prototype, "resize", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", String),
+        __metadata("design:paramtypes", [String])
+    ], GIPITextareaComponent.prototype, "minHeight", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", String),
+        __metadata("design:paramtypes", [String])
+    ], GIPITextareaComponent.prototype, "height", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", String),
+        __metadata("design:paramtypes", [String])
+    ], GIPITextareaComponent.prototype, "maxHeight", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", String),
+        __metadata("design:paramtypes", [String])
+    ], GIPITextareaComponent.prototype, "autocomplete", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean),
+        __metadata("design:paramtypes", [Boolean])
+    ], GIPITextareaComponent.prototype, "autofocus", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean),
+        __metadata("design:paramtypes", [Boolean])
+    ], GIPITextareaComponent.prototype, "readOnly", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean),
+        __metadata("design:paramtypes", [Boolean])
+    ], GIPITextareaComponent.prototype, "required", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean),
+        __metadata("design:paramtypes", [Boolean])
+    ], GIPITextareaComponent.prototype, "disabled", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean),
+        __metadata("design:paramtypes", [Boolean])
+    ], GIPITextareaComponent.prototype, "lowerCase", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean),
+        __metadata("design:paramtypes", [Boolean])
+    ], GIPITextareaComponent.prototype, "upperCase", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean),
+        __metadata("design:paramtypes", [Boolean])
+    ], GIPITextareaComponent.prototype, "spaceDrop", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object),
+        __metadata("design:paramtypes", [Object])
+    ], GIPITextareaComponent.prototype, "value", null);
+    GIPITextareaComponent = GIPITextareaComponent_1 = __decorate([
+        Component({
+            selector: 'gipi-textarea',
+            exportAs: 'gipiTextarea',
+            template: "<label class=\"textarea-label\"\n       *ngIf=\"label\"\n       [attr.for]=\"id\">\n    {{ label }}\n    <span *ngIf=\"required\"> * </span>\n</label>\n\n<textarea class=\"textarea-element\"\n          [attr.id]=\"id\"\n          [attr.name]=\"name\"\n          [placeholder]=\"placeholder\"\n          [cols]=\"cols\"\n          [rows]=\"rows\"\n          [class.resize-none]=\"resize === 'none'\"\n          [class.resize-both]=\"resize === 'both'\"\n          [class.resize-horizontal]=\"resize === 'horizontal'\"\n          [class.resize-vertical]=\"resize === 'vertical'\"\n          [style.min-height.px]=\"minHeight\"\n          [style.height.px]=\"height\"\n          [style.max-height.px]=\"maxHeight\"\n          [minlength]=\"minlength\"\n          [maxlength]=\"maxlength\"\n          [disabled]=\"disabled\"\n          [required]=\"required\"\n          [readOnly]=\"readOnly\"\n          [attr.autocomplete]=\"autocomplete\"\n          [autofocus]=\"autofocus\"\n          [(ngModel)]=\"value\"\n          [value]=\"value\">\n    </textarea>\n\n<small *ngIf=\"help\"\n       class=\"textarea-help\">\n    {{ help }}\n</small>",
+            providers: [
+                {
+                    provide: NG_VALUE_ACCESSOR,
+                    useExisting: forwardRef(function () { return GIPITextareaComponent_1; }),
+                    multi: true
+                }
+            ],
+            host: {
+                'class': 'gipi-textarea',
+            },
+            changeDetection: ChangeDetectionStrategy.OnPush,
+            styles: [":host{display:flex;flex-direction:column;gap:.8rem;font-size:1.4rem;color:#696969}:host .textarea-label{display:flex;align-items:center;gap:.4rem;color:#131313;line-height:1.6rem}:host .textarea-label>span{font-size:1.6rem;line-height:1.6rem;color:#d14014}:host .textarea-element{display:flex;font-family:inherit;font-size:inherit;color:inherit;padding:.75rem .8rem;background:#fff;border:1px solid rgba(0,0,0,.12);transition:background-color .2s,color .2s,border-color .2s,box-shadow .2s;-webkit-appearance:none;-moz-appearance:none;appearance:none;border-radius:6px;caret-color:#696969;max-height:12rem;min-height:6rem;resize:vertical;outline:0;overflow:auto}:host .textarea-element:not(:disabled):hover{border-color:#6d6f73}:host .textarea-element:not(:disabled).ng-dirty.ng-invalid:enabled:hover,:host .textarea-element:not(:disabled):invalid:enabled:hover{border-color:#e07f62}:host .textarea-element:not(:disabled):enabled:focus{outline:0;outline-offset:0;box-shadow:0 0 0 .2rem #e0e1e2;border-color:#6d6f73}:host .textarea-element:not(:disabled).ng-dirty.ng-invalid:enabled,:host .textarea-element:not(:disabled):invalid:enabled{border-color:#d14014}:host .textarea-element:not(:disabled).ng-dirty.ng-invalid:enabled:focus,:host .textarea-element:not(:disabled):invalid:enabled:focus{outline:0;outline-offset:0;box-shadow:0 0 0 .2rem #f1c4b6;border-color:#d14014}:host .textarea-element:disabled{color:#bbbdc1!important;border-color:#e0e1e2!important;background-color:#f5f5f6!important;cursor:not-allowed}:host .textarea-element.resize-none{resize:none}:host .textarea-element.resize-both{resize:both}:host .textarea-element.resize-horizontal{resize:horizontal}:host .textarea-element.resize-vertical{resize:vertical}:host .textarea-help{flex:1;font-size:1rem;font-weight:500;margin-top:-.4rem;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}::-webkit-input-placeholder{color:#bbbdc1}:-moz-placeholder{color:#bbbdc1}::-moz-placeholder{color:#bbbdc1}:-ms-input-placeholder{color:#bbbdc1}"]
+        }),
+        __metadata("design:paramtypes", [ElementRef,
+            ChangeDetectorRef])
+    ], GIPITextareaComponent);
+    return GIPITextareaComponent;
+}());
+export { GIPITextareaComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"textarea.component.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["shared/gipi-components/textarea/textarea.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { coerceBooleanProperty, coerceCssPixelValue } from '@angular/cdk/coercion';\nimport { ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, forwardRef, Input, OnInit } from '@angular/core';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\n\nlet nextUniqueId = 0;\n\ntype TextareaResize = 'both' | 'horizontal' | 'vertical' | 'none';\n\n@Component({\n    selector: 'gipi-textarea',\n    exportAs: 'gipiTextarea',\n    templateUrl: './textarea.component.html',\n    styleUrls: ['./textarea.component.scss'],\n    providers: [\n        {\n            provide: NG_VALUE_ACCESSOR,\n            useExisting: forwardRef(() => GIPITextareaComponent),\n            multi: true\n        }\n    ],\n    host: {\n        'class': 'gipi-textarea',\n    },\n    changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class GIPITextareaComponent implements OnInit, ControlValueAccessor {\n\n    private _name: string = `gipi-textarea-${nextUniqueId++}`;\n\n    @Input() id: string = this._name;\n\n    @Input() name: string = this._name;\n\n    @Input() label: string = '';\n\n    @Input() placeholder: string = '';\n\n    @Input() cols: number = 20;\n\n    @Input() rows: number = 4;\n\n    @Input() help: string = '';\n\n    @Input() maxlength: number = 254;\n\n    @Input() minlength: number = 0;\n\n    private _resize: TextareaResize = 'horizontal';\n    @Input() get resize(): TextareaResize {\n        return this._resize;\n    }\n    set resize(value: TextareaResize) {\n        if (value !== this.resize) {\n            this._resize = (value.toLowerCase() as TextareaResize);\n            this._changeDetectorRef.detectChanges();\n        }\n    }\n\n    private _minHeight: string = '60px';\n    @Input() get minHeight(): string {\n        return this._minHeight;\n    }\n    set minHeight(value: string) {\n        if (value.trim().toUpperCase() === 'AUTO') {\n            this._minHeight = 'auto';\n        } else {\n            this._minHeight = coerceCssPixelValue(value);\n        }\n    }\n\n    private _height: string = '60px';\n    @Input() get height(): string {\n        return this._height;\n    }\n    set height(value: string) {\n        if (value.trim().toUpperCase() === 'AUTO') {\n            this._height = 'auto';\n        } else {\n            this._height = coerceCssPixelValue(value);\n        }\n    }\n\n    private _maxHeight: string = 'auto';\n    @Input() get maxHeight(): string {\n        return this._maxHeight;\n    }\n    set maxHeight(value: string) {\n        if (value.trim().toUpperCase() === 'AUTO') {\n            this._maxHeight = 'auto';\n        } else {\n            this._maxHeight = coerceCssPixelValue(value);\n        }\n    }\n\n    private _autocomplete: 'on' | 'off' = 'off';\n    @Input() get autocomplete(): 'on' | 'off' {\n        return this._autocomplete;\n    }\n    set autocomplete(value: 'on' | 'off') {\n        this._autocomplete = value;\n    }\n\n    private _autofocus: boolean = false;\n    @Input() get autofocus(): boolean {\n        return this._autofocus;\n    }\n    set autofocus(value: boolean) {\n        this._autofocus = coerceBooleanProperty(value);\n    }\n\n    private _readOnly: boolean = false;\n    @Input() get readOnly(): boolean {\n        return this._readOnly;\n    }\n    set readOnly(value: boolean) {\n        this._readOnly = coerceBooleanProperty(value);\n    }\n\n    private _required: boolean = false;\n    @Input() get required(): boolean {\n        return this._required;\n    }\n    set required(value: boolean) {\n        this._required = coerceBooleanProperty(value);\n    }\n\n    private _disabled: boolean = false;\n    @Input() get disabled(): boolean {\n        return this._disabled;\n    }\n    set disabled(value: boolean) {\n        this._disabled = coerceBooleanProperty(value);\n    }\n\n    private _lowerCase: boolean = false;\n    @Input() get lowerCase(): boolean {\n        return this._lowerCase;\n    }\n    set lowerCase(value: boolean) {\n        this._lowerCase = coerceBooleanProperty(value);\n    }\n\n    private _upperCase: boolean = false;\n    @Input() get upperCase(): boolean {\n        return this._upperCase;\n    }\n    set upperCase(value: boolean) {\n        this._upperCase = coerceBooleanProperty(value);\n    }\n\n    private _spaceDrop: boolean = false;\n    @Input() get spaceDrop(): boolean {\n        return this._spaceDrop;\n    }\n    set spaceDrop(value: boolean) {\n        this._spaceDrop = coerceBooleanProperty(value);\n    }\n\n    private _value!: any;\n    @Input()\n    get value(): any {\n        return this._value;\n    }\n    set value(value: any) {\n        let valueAux: any = value;\n        valueAux = this._checkSpaceDrop(valueAux);\n        valueAux = this._checkLowercase(valueAux);\n        valueAux = this._checkUppercase(valueAux);\n        this._value = valueAux;\n\n        this.onChange(this._value);\n        this.onTouched(this._value);\n    }\n\n    onChange: Function = () => { };\n\n    onTouched: Function = () => { };\n\n    constructor(\n        public elementRef: ElementRef<HTMLElement>,\n        private _changeDetectorRef: ChangeDetectorRef,\n    ) { }\n\n    ngOnInit(): void { }\n\n    writeValue(value: any): void {\n        this._value = value;\n    }\n\n    registerOnChange(fn: Function): void {\n        this.onChange = fn;\n    }\n\n    registerOnTouched(fn: Function): void {\n        this.onTouched = fn;\n    }\n\n    setDisabledState?(isDisabled: boolean): void {\n        this.disabled = isDisabled;\n        this._changeDetectorRef.markForCheck();\n    }\n\n    private _checkSpaceDrop(value: any): any {\n        if (this.spaceDrop && value) {\n            return value.replace(/\\s/g, '');\n        }\n        return value;\n    }\n\n    private _checkUppercase(value: any): any {\n        if (this.upperCase && value) {\n            return value.toUpperCase();\n        }\n        return value;\n    }\n\n    private _checkLowercase(value: any): any {\n        if (this.lowerCase && value) {\n            return value.toLowerCase();\n        }\n        return value;\n    }\n\n}\n"]}