@gipisistemas/ng-core 1.0.67 → 1.0.68

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

@@ -0,0 +1,112 @@
+var GIPIInputCheckboxComponent_1;
+import { __decorate, __metadata } from "tslib";
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, EventEmitter, Input, OnInit, Output, forwardRef } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+let nextUniqueId = 0;
+let GIPIInputCheckboxComponent = GIPIInputCheckboxComponent_1 = class GIPIInputCheckboxComponent {
+    constructor(_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 = () => { };
+        this.onTouch = () => { };
+    }
+    set value(val) {
+        this._value = val;
+        this.onChange(val);
+        this.onTouch();
+    }
+    get value() {
+        return this._value;
+    }
+    ngOnInit() { }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouch = fn;
+    }
+    writeValue(value) {
+        this.value = value;
+    }
+    setDisabledState(val) {
+        this.disabled = val;
+        this._changeDetectorRef.markForCheck();
+    }
+};
+GIPIInputCheckboxComponent.ctorParameters = () => [
+    { 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(() => 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);
+export { GIPIInputCheckboxComponent };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,197 @@
+var GIPIInputCurrencyComponent_1;
+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';
+let nextUniqueId = 0;
+let GIPIInputCurrencyComponent = GIPIInputCurrencyComponent_1 = class GIPIInputCurrencyComponent {
+    constructor(_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 = () => { };
+        this.onTouch = () => { };
+    }
+    set model(value) {
+        this._model = value;
+        this.onChange(value);
+        this.onTouch();
+        this._changeDetectorRef.markForCheck();
+    }
+    get model() {
+        return this._model;
+    }
+    set value(value) {
+        this._value = value;
+    }
+    get value() {
+        return this._value;
+    }
+    ngOnInit() { }
+    writeValue(value) {
+        this.model = value;
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouch = fn;
+    }
+    setDisabledState(value) {
+        this.disabled = value;
+        this._changeDetectorRef.markForCheck();
+    }
+    onInputKeydown(event) {
+        if (!this.disabled) {
+            if (event.key.toUpperCase() === 'ENTER') {
+                this.onKeydownEnter.emit(event);
+            }
+            this.onKeydown.emit(event);
+        }
+    }
+    onInputFocus(event) {
+        if (!this.disabled) {
+            this.onFocus.emit(event);
+        }
+    }
+    onInputBlur(event) {
+        if (!this.disabled) {
+            this.onBlur.emit(event);
+            this.onTouch();
+        }
+    }
+    onInputClick(event) {
+        if (!this.disabled) {
+            this.onClick.emit(event);
+            this.focus();
+        }
+    }
+    /**
+     * Seta o foco no inputRef
+     */
+    focus() {
+        if (!ObjectUtil.isNull(this.inputCurrencyRef)) {
+            this.inputCurrencyRef.nativeElement.focus();
+        }
+    }
+};
+GIPIInputCurrencyComponent.ctorParameters = () => [
+    { 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(() => 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);
+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"]}