@gipisistemas/ng-core 1.1.0 → 1.1.1

package/esm5/shared/gipi-components/input-checkbox/input-checkbox.component.js

@@ -0,0 +1,118 @@
+import { __decorate, __metadata } from "tslib";
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, EventEmitter, Input, OnInit, Output, forwardRef } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+var nextUniqueId = 0;
+var GIPIInputCheckboxComponent = /** @class */ (function () {
+    function GIPIInputCheckboxComponent(_changeDetectorRef) {
+        this._changeDetectorRef = _changeDetectorRef;
+        this._name = "gipi-input-checkbox-" + nextUniqueId++;
+        this.id = this._name;
+        this.name = this._name;
+        this.disabled = false;
+        this.disableRipple = false;
+        this.labelPosition = 'after';
+        this.change = new EventEmitter();
+        this.indeterminateChange = new EventEmitter();
+        this.onChange = function () { };
+        this.onTouch = function () { };
+    }
+    GIPIInputCheckboxComponent_1 = GIPIInputCheckboxComponent;
+    Object.defineProperty(GIPIInputCheckboxComponent.prototype, "value", {
+        get: function () {
+            return this._value;
+        },
+        set: function (val) {
+            this._value = val;
+            this.onChange(val);
+            this.onTouch();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    GIPIInputCheckboxComponent.prototype.ngOnInit = function () { };
+    GIPIInputCheckboxComponent.prototype.registerOnChange = function (fn) {
+        this.onChange = fn;
+    };
+    GIPIInputCheckboxComponent.prototype.registerOnTouched = function (fn) {
+        this.onTouch = fn;
+    };
+    GIPIInputCheckboxComponent.prototype.writeValue = function (value) {
+        this.value = value;
+    };
+    GIPIInputCheckboxComponent.prototype.setDisabledState = function (val) {
+        this.disabled = val;
+        this._changeDetectorRef.markForCheck();
+    };
+    var GIPIInputCheckboxComponent_1;
+    GIPIInputCheckboxComponent.ctorParameters = function () { return [
+        { type: ChangeDetectorRef }
+    ]; };
+    __decorate([
+        Input(),
+        __metadata("design:type", Object)
+    ], GIPIInputCheckboxComponent.prototype, "id", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], GIPIInputCheckboxComponent.prototype, "name", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], GIPIInputCheckboxComponent.prototype, "label", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], GIPIInputCheckboxComponent.prototype, "disabled", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], GIPIInputCheckboxComponent.prototype, "disableRipple", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], GIPIInputCheckboxComponent.prototype, "labelPosition", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], GIPIInputCheckboxComponent.prototype, "required", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], GIPIInputCheckboxComponent.prototype, "indeterminate", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object),
+        __metadata("design:paramtypes", [Object])
+    ], GIPIInputCheckboxComponent.prototype, "value", null);
+    __decorate([
+        Output(),
+        __metadata("design:type", EventEmitter)
+    ], GIPIInputCheckboxComponent.prototype, "change", void 0);
+    __decorate([
+        Output(),
+        __metadata("design:type", EventEmitter)
+    ], GIPIInputCheckboxComponent.prototype, "indeterminateChange", void 0);
+    GIPIInputCheckboxComponent = GIPIInputCheckboxComponent_1 = __decorate([
+        Component({
+            selector: "gipi-input-checkbox",
+            exportAs: 'gipiInputCheckbox',
+            template: "<mat-checkbox [attr.id]=\"id\"\n              [name]=\"name\"\n              [(ngModel)]=\"value\"\n              [required]=\"required\"\n              [disabled]=\"disabled\"\n              [disableRipple]=\"disableRipple\"\n              [labelPosition]=\"labelPosition\"\n              [(indeterminate)]=\"indeterminate\"\n              (change)=\"change.emit($event)\"\n              (indeterminateChange)=\"indeterminateChange.emit($event)\">\n    {{ label }}\n</mat-checkbox>",
+            providers: [
+                {
+                    provide: NG_VALUE_ACCESSOR,
+                    useExisting: forwardRef(function () { return GIPIInputCheckboxComponent_1; }),
+                    multi: true
+                }
+            ],
+            host: {
+                'class': 'gipi-input-checkbox',
+            },
+            changeDetection: ChangeDetectionStrategy.OnPush,
+            styles: ["::ng-deep .mat-checkbox-disabled{cursor:not-allowed!important}"]
+        }),
+        __metadata("design:paramtypes", [ChangeDetectorRef])
+    ], GIPIInputCheckboxComponent);
+    return GIPIInputCheckboxComponent;
+}());
+export { GIPIInputCheckboxComponent };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/shared/gipi-components/input-currency/input-currency.component.js

@@ -0,0 +1,207 @@
+import { __decorate, __metadata } from "tslib";
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, EventEmitter, Input, OnInit, Output, ViewChild, forwardRef } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { ObjectUtil } from '../../../core';
+var nextUniqueId = 0;
+var GIPIInputCurrencyComponent = /** @class */ (function () {
+    function GIPIInputCurrencyComponent(_changeDetectorRef, elementRef) {
+        this._changeDetectorRef = _changeDetectorRef;
+        this.elementRef = elementRef;
+        this._name = "gipi-input-currency-" + nextUniqueId++;
+        this.id = this._name;
+        this.name = this._name;
+        this.placeholder = '';
+        this.readonly = false;
+        this.disabled = false;
+        this.required = false;
+        this.onKeydown = new EventEmitter();
+        this.onKeydownEnter = new EventEmitter();
+        this.onFocus = new EventEmitter();
+        this.onBlur = new EventEmitter();
+        this.onClick = new EventEmitter();
+        this.onChange = function () { };
+        this.onTouch = function () { };
+    }
+    GIPIInputCurrencyComponent_1 = GIPIInputCurrencyComponent;
+    Object.defineProperty(GIPIInputCurrencyComponent.prototype, "model", {
+        get: function () {
+            return this._model;
+        },
+        set: function (value) {
+            this._model = value;
+            this.onChange(value);
+            this.onTouch();
+            this._changeDetectorRef.markForCheck();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPIInputCurrencyComponent.prototype, "value", {
+        get: function () {
+            return this._value;
+        },
+        set: function (value) {
+            this._value = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    GIPIInputCurrencyComponent.prototype.ngOnInit = function () { };
+    GIPIInputCurrencyComponent.prototype.writeValue = function (value) {
+        this.model = value;
+    };
+    GIPIInputCurrencyComponent.prototype.registerOnChange = function (fn) {
+        this.onChange = fn;
+    };
+    GIPIInputCurrencyComponent.prototype.registerOnTouched = function (fn) {
+        this.onTouch = fn;
+    };
+    GIPIInputCurrencyComponent.prototype.setDisabledState = function (value) {
+        this.disabled = value;
+        this._changeDetectorRef.markForCheck();
+    };
+    GIPIInputCurrencyComponent.prototype.onInputKeydown = function (event) {
+        if (!this.disabled) {
+            if (event.key.toUpperCase() === 'ENTER') {
+                this.onKeydownEnter.emit(event);
+            }
+            this.onKeydown.emit(event);
+        }
+    };
+    GIPIInputCurrencyComponent.prototype.onInputFocus = function (event) {
+        if (!this.disabled) {
+            this.onFocus.emit(event);
+        }
+    };
+    GIPIInputCurrencyComponent.prototype.onInputBlur = function (event) {
+        if (!this.disabled) {
+            this.onBlur.emit(event);
+            this.onTouch();
+        }
+    };
+    GIPIInputCurrencyComponent.prototype.onInputClick = function (event) {
+        if (!this.disabled) {
+            this.onClick.emit(event);
+            this.focus();
+        }
+    };
+    /**
+     * Seta o foco no inputRef
+     */
+    GIPIInputCurrencyComponent.prototype.focus = function () {
+        if (!ObjectUtil.isNull(this.inputCurrencyRef)) {
+            this.inputCurrencyRef.nativeElement.focus();
+        }
+    };
+    var GIPIInputCurrencyComponent_1;
+    GIPIInputCurrencyComponent.ctorParameters = function () { return [
+        { type: ChangeDetectorRef },
+        { type: ElementRef }
+    ]; };
+    __decorate([
+        Input(),
+        __metadata("design:type", Object)
+    ], GIPIInputCurrencyComponent.prototype, "id", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], GIPIInputCurrencyComponent.prototype, "name", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], GIPIInputCurrencyComponent.prototype, "label", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], GIPIInputCurrencyComponent.prototype, "ariaLabel", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], GIPIInputCurrencyComponent.prototype, "placeholder", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], GIPIInputCurrencyComponent.prototype, "readonly", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], GIPIInputCurrencyComponent.prototype, "disabled", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], GIPIInputCurrencyComponent.prototype, "required", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Number)
+    ], GIPIInputCurrencyComponent.prototype, "min", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Number)
+    ], GIPIInputCurrencyComponent.prototype, "max", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Number)
+    ], GIPIInputCurrencyComponent.prototype, "maxLength", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object)
+    ], GIPIInputCurrencyComponent.prototype, "options", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object),
+        __metadata("design:paramtypes", [Object])
+    ], GIPIInputCurrencyComponent.prototype, "model", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object),
+        __metadata("design:paramtypes", [Object])
+    ], GIPIInputCurrencyComponent.prototype, "value", null);
+    __decorate([
+        ViewChild('inputCurrencyRef', { static: true, read: ElementRef }),
+        __metadata("design:type", ElementRef)
+    ], GIPIInputCurrencyComponent.prototype, "inputCurrencyRef", void 0);
+    __decorate([
+        Output(),
+        __metadata("design:type", EventEmitter)
+    ], GIPIInputCurrencyComponent.prototype, "onKeydown", void 0);
+    __decorate([
+        Output(),
+        __metadata("design:type", EventEmitter)
+    ], GIPIInputCurrencyComponent.prototype, "onKeydownEnter", void 0);
+    __decorate([
+        Output(),
+        __metadata("design:type", EventEmitter)
+    ], GIPIInputCurrencyComponent.prototype, "onFocus", void 0);
+    __decorate([
+        Output(),
+        __metadata("design:type", EventEmitter)
+    ], GIPIInputCurrencyComponent.prototype, "onBlur", void 0);
+    __decorate([
+        Output(),
+        __metadata("design:type", EventEmitter)
+    ], GIPIInputCurrencyComponent.prototype, "onClick", void 0);
+    GIPIInputCurrencyComponent = GIPIInputCurrencyComponent_1 = __decorate([
+        Component({
+            selector: "gipi-input-currency",
+            exportAs: 'gipiInputCurrency',
+            template: "<label class=\"input-currency-container\"\n       [attr.for]=\"id\">\n    <span class=\"input-currency-label\"\n          *ngIf=\"label\">\n        {{ label }}\n        <span *ngIf=\"required && label\"> * </span>\n    </span>\n\n    <div class=\"input-currency-content\"\n         (click)=\"onInputClick($event)\">\n        <input class=\"input-currency-input\"\n               #inputCurrencyRef\n               currencyMask\n               autocomplete=\"off\"\n               type=\"currency\"\n               [attr.id]=\"id\"\n               [attr.aria-label]=\"ariaLabel\"\n               [name]=\"name\"\n               [min]=\"min\"\n               [max]=\"max\"\n               [maxlength]=\"maxLength\"\n               [required]=\"required\"\n               [placeholder]=\"placeholder\"\n               [readonly]=\"readonly\"\n               [disabled]=\"disabled\"\n               [(ngModel)]=\"model\"\n               [value]=\"value\"\n               [options]=\"options\"\n               (keydown)=\"onInputKeydown($event)\"\n               (focus)=\"onInputFocus($event)\"\n               (blur)=\"onInputBlur($event)\"\n               (click)=\"onInputClick($event)\">\n    </div>\n</label>",
+            providers: [
+                {
+                    provide: NG_VALUE_ACCESSOR,
+                    useExisting: forwardRef(function () { return GIPIInputCurrencyComponent_1; }),
+                    multi: true
+                }
+            ],
+            host: {
+                'class': 'gipi-input-currency',
+            },
+            changeDetection: ChangeDetectionStrategy.OnPush,
+            styles: [".input-currency-container{display:flex;flex-direction:column;gap:12px;width:100%}.input-currency-container .input-currency-label{color:#131313;font-size:1.4rem;line-height:100%}.input-currency-container .input-currency-label>span{color:#d14014;font-size:inherit;line-height:inherit}.input-currency-container .input-currency-content{display:flex;flex-direction:row;align-items:center;justify-content:space-between;padding:12px;width:100%;max-height:4rem;border-radius:5px;cursor:text;background-color:#fff;border:1px solid rgba(0,0,0,.12);color:#696969;caret-color:#9a9da2;transition:.2s}.input-currency-container .input-currency-content:focus-within,.input-currency-container .input-currency-content:has(.input-currency-input:active),.input-currency-container .input-currency-content:has(.input-currency-input:focus){box-shadow:0 0 0 .2rem #f0f0f0}.input-currency-container .input-currency-content:focus-within,.input-currency-container .input-currency-content:hover{border-color:#bfbfbf!important}.input-currency-container .input-currency-content:has(.input-currency-input:invalid){border-color:#d14014!important;color:#d14014!important;caret-color:#d14014!important}.input-currency-container .input-currency-content:has(.input-currency-input:invalid):focus-within{box-shadow:0 0 0 .2rem #f1c4b6!important}.input-currency-container .input-currency-content:has(.input-currency-input:disabled){border-color:#e0e1e2!important;color:#d1d2d4!important;box-shadow:none!important;cursor:not-allowed!important;caret-color:#d1d2d4!important;pointer-events:none!important}.input-currency-container .input-currency-content .input-currency-input{height:16px;outline:0;border:none;background-color:transparent;color:inherit;flex:1}"]
+        }),
+        __metadata("design:paramtypes", [ChangeDetectorRef,
+            ElementRef])
+    ], GIPIInputCurrencyComponent);
+    return GIPIInputCurrencyComponent;
+}());
+export { GIPIInputCurrencyComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"input-currency.component.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["shared/gipi-components/input-currency/input-currency.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, EventEmitter, Input, OnInit, Output, ViewChild, forwardRef } from '@angular/core';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\n\nimport { CurrencyMaskConfig } from 'ngx-currency';\nimport { ObjectUtil } from '../../../core';\n\nlet nextUniqueId = 0;\n\n@Component({\n    selector: `gipi-input-currency`,\n    exportAs: 'gipiInputCurrency',\n    templateUrl: './input-currency.component.html',\n    styleUrls: ['./input-currency.component.scss'],\n    providers: [\n        {\n            provide: NG_VALUE_ACCESSOR,\n            useExisting: forwardRef((): typeof GIPIInputCurrencyComponent => GIPIInputCurrencyComponent),\n            multi: true\n        }\n    ],\n    host: {\n        'class': 'gipi-input-currency',\n    },\n    changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class GIPIInputCurrencyComponent implements OnInit, ControlValueAccessor {\n\n    private _name: string = `gipi-input-currency-${nextUniqueId++}`;\n\n    @Input() id: number | string = this._name;\n\n    @Input() name: string = this._name;\n\n    @Input() label: string;\n\n    @Input() ariaLabel: string;\n\n    @Input() placeholder: string = '';\n\n    @Input() readonly: boolean = false;\n\n    @Input() disabled: boolean = false;\n\n    @Input() required: boolean = false;\n\n    @Input() min: number;\n\n    @Input() max: number;\n\n    @Input() maxLength: number;\n\n    @Input() options: Partial<CurrencyMaskConfig>;\n\n    private _model: any;\n    @Input() set model(value: any) {\n        this._model = value;\n        this.onChange(value);\n        this.onTouch();\n        this._changeDetectorRef.markForCheck();\n    }\n    get model() {\n        return this._model;\n    }\n\n    private _value: any;\n    @Input() set value(value: any) {\n        this._value = value;\n    }\n    get value() {\n        return this._value;\n    }\n\n    @ViewChild('inputCurrencyRef', { static: true, read: ElementRef }) inputCurrencyRef: ElementRef;\n\n    @Output() onKeydown: EventEmitter<KeyboardEvent> = new EventEmitter<KeyboardEvent>();\n    @Output() onKeydownEnter: EventEmitter<KeyboardEvent> = new EventEmitter<KeyboardEvent>();\n    @Output() onFocus: EventEmitter<Event> = new EventEmitter<Event>();\n    @Output() onBlur: EventEmitter<Event> = new EventEmitter<Event>();\n    @Output() onClick: EventEmitter<Event> = new EventEmitter<Event>();\n\n    constructor(\n        private _changeDetectorRef: ChangeDetectorRef,\n        public elementRef: ElementRef,\n    ) { }\n\n    ngOnInit() { }\n\n    onChange: any = (): void => { };\n\n    onTouch: any = (): void => { };\n\n    writeValue(value: any): void {\n        this.model = value;\n    }\n\n    registerOnChange(fn: any): void {\n        this.onChange = fn;\n    }\n\n    registerOnTouched(fn: any): void {\n        this.onTouch = fn;\n    }\n\n    setDisabledState?(value: boolean): void {\n        this.disabled = value;\n        this._changeDetectorRef.markForCheck();\n    }\n\n    public onInputKeydown(event: KeyboardEvent): void {\n        if (!this.disabled) {\n            if (event.key.toUpperCase() === 'ENTER') {\n                this.onKeydownEnter.emit(event);\n            }\n            this.onKeydown.emit(event);\n        }\n    }\n\n    public onInputFocus(event: Event): void {\n        if (!this.disabled) {\n            this.onFocus.emit(event);\n        }\n    }\n\n    public onInputBlur(event: Event): void {\n        if (!this.disabled) {\n            this.onBlur.emit(event);\n            this.onTouch();\n        }\n    }\n\n    public onInputClick(event: Event): void {\n        if (!this.disabled) {\n            this.onClick.emit(event);\n            this.focus();\n        }\n    }\n\n    /**\n     * Seta o foco no inputRef\n     */\n    public focus(): void {\n        if (!ObjectUtil.isNull(this.inputCurrencyRef)) {\n            this.inputCurrencyRef.nativeElement.focus();\n        }\n    }\n\n}\n"]}