@po-ui/ng-components 5.22.1 → 6.1.0

package/esm2020/lib/components/po-field/po-input/po-input-base.component.mjs

@@ -0,0 +1,397 @@
+import { __decorate } from "tslib";
+import { EventEmitter, Input, Output, Directive } from '@angular/core';
+import { convertToBoolean } from '../../../utils/util';
+import { requiredFailed, maxlengpoailed, minlengpoailed, patternFailed } from './../validators';
+import { InputBoolean } from '../../../decorators';
+import { PoMask } from './po-mask';
+import * as i0 from "@angular/core";
+/**
+ * @description
+ *
+ * Este é um componente baseado em input, com várias propriedades do input nativo e outras
+ * propriedades extras como: máscara, pattern, mensagem de erro e etc.
+ * Você deve informar a variável que contém o valor como [(ngModel)]="variavel", para que o
+ * input receba o valor da variável e para que ela receba as alterações do valor (two-way-databinding).
+ * A propriedade name é obrigatória para que o formulário e o model funcionem corretamente.
+ *
+ * Importante:
+ *
+ * - Caso o input tenha um [(ngModel)] sem o atributo name, ocorrerá um erro de angular.
+ * Então você precisa informar o atributo name ou o atributo [ngModelOptions]="{standalone: true}".
+ * Exemplo: [(ngModel)]="pessoa.nome" [ngModelOptions]="{standalone: true}".
+ *
+ */
+export class PoInputBaseComponent {
+    constructor(cd) {
+        this.cd = cd;
+        /**
+         * @optional
+         *
+         * @description
+         *
+         * Aplica foco no elemento ao ser iniciado.
+         *
+         * > Caso mais de um elemento seja configurado com essa propriedade, apenas o último elemento declarado com ela terá o foco.
+         *
+         * @default `false`
+         */
+        this.autoFocus = false;
+        /**
+         * @description
+         *
+         * Mensagem que será apresentada quando o `pattern` ou a máscara não for satisfeita.
+         *
+         * > Esta mensagem não é apresentada quando o campo estiver vazio, mesmo que ele seja requerido.
+         */
+        this.errorPattern = '';
+        /**
+         * @optional
+         *
+         * @description
+         *
+         * Evento disparado ao sair do campo.
+         */
+        this.blur = new EventEmitter();
+        /**
+         * @optional
+         *
+         * @description
+         *
+         * Evento disparado ao entrar do campo.
+         */
+        this.enter = new EventEmitter();
+        /**
+         * @optional
+         *
+         * @description
+         *
+         * Evento disparado ao alterar valor e deixar o campo.
+         */
+        this.change = new EventEmitter();
+        /**
+         * @optional
+         *
+         * @description
+         *
+         * Evento disparado ao alterar valor do model.
+         */
+        this.changeModel = new EventEmitter();
+        this.onChangePropagate = null;
+        this.onTouched = null;
+        this.passedWriteValue = false;
+        this._noAutocomplete = false;
+        this._placeholder = '';
+        /**
+         * @description
+         *
+         * Se verdadeiro, desabilita o campo.
+         *
+         * @default `false`
+         */
+        // eslint-disable-next-line @typescript-eslint/member-ordering
+        this.disabled = false;
+        /** Indica que o campo será somente leitura. */
+        // eslint-disable-next-line @typescript-eslint/member-ordering
+        this.readonly = false;
+        /**
+         * @description
+         *
+         * Indica que o campo será obrigatório.
+         *
+         * > Esta propriedade é desconsiderada quando o input está desabilitado `(p-disabled)`.
+         *
+         * @default `false`
+         */
+        // eslint-disable-next-line @typescript-eslint/member-ordering
+        this.required = false;
+        /** Se verdadeiro, o campo receberá um botão para ser limpo. */
+        // eslint-disable-next-line @typescript-eslint/member-ordering
+        this.clean = false;
+        /**
+         * @description
+         *
+         * Indica uma máscara para o campo. Exemplos: (+99) (99) 99999?-9999, 99999-999, 999.999.999-99.
+         * A máscara gera uma validação automática do campo, podendo esta ser substituída por um REGEX específico
+         * através da propriedade p-pattern.
+         * O campo será sinalizado e o formulário ficará inválido quando o valor informado estiver fora do padrão definido,
+         * mesmo quando desabilitado.
+         */
+        // eslint-disable-next-line @typescript-eslint/member-ordering
+        this.mask = '';
+        /**
+         * @description
+         *
+         * Indica se o `model` receberá o valor formatado pela máscara ou apenas o valor puro (sem formatação).
+         *
+         * @default `false`
+         */
+        // eslint-disable-next-line @typescript-eslint/member-ordering
+        this.maskFormatModel = false;
+    }
+    /**
+     * @optional
+     *
+     * @description
+     *
+     * Define a propriedade nativa `autocomplete` do campo como `off`.
+     *
+     * > No componente `po-password` será definido como `new-password`.
+     *
+     * @default `false`
+     */
+    set noAutocomplete(value) {
+        this._noAutocomplete = convertToBoolean(value);
+    }
+    get noAutocomplete() {
+        return this._noAutocomplete;
+    }
+    /**
+     * @optional
+     *
+     * @description
+     *
+     * Mensagem que aparecerá enquanto o campo não estiver preenchido.
+     *
+     * @default ''
+     */
+    set placeholder(value) {
+        this._placeholder = value || '';
+    }
+    get placeholder() {
+        return this._placeholder;
+    }
+    set setDisabled(disabled) {
+        this.disabled = disabled === '' ? true : convertToBoolean(disabled);
+        this.validateModel();
+    }
+    set setReadonly(readonly) {
+        this.readonly = readonly === '' ? true : convertToBoolean(readonly);
+    }
+    set setRequired(required) {
+        this.required = required === '' ? true : convertToBoolean(required);
+        this.validateModel();
+    }
+    set setClean(clean) {
+        this.clean = clean === '' ? true : convertToBoolean(clean);
+    }
+    set setPattern(pattern) {
+        this.pattern = pattern;
+        this.validateModel();
+    }
+    /**
+     * @optional
+     *
+     * @description
+     *
+     * Indica a quantidade máxima de caracteres que o campo aceita.
+     */
+    set maxlength(value) {
+        if (!isNaN(parseInt(value, 10))) {
+            this._maxlength = parseInt(value, 10);
+            this.validateModel();
+        }
+        else if (!value) {
+            this._maxlength = undefined;
+            this.validateModel();
+        }
+    }
+    get maxlength() {
+        return this._maxlength;
+    }
+    /**
+     * @optional
+     *
+     * @description
+     *
+     * Indica a quantidade mínima de caracteres que o campo aceita.
+     */
+    set minlength(value) {
+        if (!isNaN(parseInt(value, 10))) {
+            this._minlength = parseInt(value, 10);
+            this.validateModel();
+        }
+        else if (!value) {
+            this._minlength = undefined;
+            this.validateModel();
+        }
+    }
+    get minlength() {
+        return this._minlength;
+    }
+    set setMask(mask) {
+        this.mask = mask;
+        // Atualiza Máscara do Campo
+        this.objMask = new PoMask(this.mask, this.maskFormatModel);
+    }
+    set setMaskFormatModel(maskFormatModel) {
+        this.maskFormatModel = maskFormatModel === '' ? true : convertToBoolean(maskFormatModel);
+        if (this.objMask instanceof PoMask) {
+            this.objMask.formatModel = this.maskFormatModel;
+            this.validateModel();
+        }
+    }
+    callOnChange(value) {
+        this.updateModel(value);
+        this.controlChangeModelEmitter(value);
+    }
+    callUpdateModelWithTimeout(value) {
+        setTimeout(() => this.updateModel(value));
+    }
+    controlChangeModelEmitter(value) {
+        if (this.modelLastUpdate !== value) {
+            this.changeModel.emit(value);
+            this.modelLastUpdate = value;
+        }
+    }
+    // Função implementada do ControlValueAccessor
+    // Usada para interceptar os estados de habilitado via forms api
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+        this.cd?.markForCheck();
+    }
+    // Função implementada do ControlValueAccessor
+    // Usada para interceptar as mudanças e não atualizar automaticamente o Model
+    registerOnChange(func) {
+        this.onChangePropagate = func;
+    }
+    // Função implementada do ControlValueAccessor
+    // Usada para interceptar as mudanças e não atualizar automaticamente o Model
+    registerOnTouched(func) {
+        this.onTouched = func;
+    }
+    registerOnValidatorChange(fn) {
+        this.validatorChange = fn;
+    }
+    updateModel(value) {
+        // Quando o input não possui um formulário, então esta função não é registrada
+        if (this.onChangePropagate) {
+            this.onChangePropagate(value);
+        }
+    }
+    validate(c) {
+        if (requiredFailed(this.required, this.disabled, this.getScreenValue())) {
+            return {
+                required: {
+                    valid: false
+                }
+            };
+        }
+        if (maxlengpoailed(this.maxlength, this.getScreenValue())) {
+            return {
+                maxlength: {
+                    valid: false
+                }
+            };
+        }
+        if (minlengpoailed(this.minlength, this.getScreenValue())) {
+            return {
+                minlength: {
+                    valid: false
+                }
+            };
+        }
+        if (patternFailed(this.pattern, c.value)) {
+            this.validatePatternOnWriteValue(c.value);
+            return {
+                pattern: {
+                    valid: false
+                }
+            };
+        }
+        return this.extraValidation(c);
+    }
+    // Função implementada do ControlValueAccessor
+    writeValue(value) {
+        this.writeValueModel(value);
+        this.cd?.markForCheck();
+    }
+    validateModel() {
+        if (this.validatorChange) {
+            this.validatorChange();
+        }
+    }
+    // utilizado para validar o pattern na inicializacao, fazendo dessa forma o campo fica sujo (dirty).
+    validatePatternOnWriteValue(value) {
+        if (value && this.passedWriteValue) {
+            setTimeout(() => {
+                this.updateModel(value);
+            });
+            this.passedWriteValue = false;
+        }
+    }
+}
+PoInputBaseComponent.ɵfac = function PoInputBaseComponent_Factory(t) { return new (t || PoInputBaseComponent)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef)); };
+PoInputBaseComponent.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: PoInputBaseComponent, inputs: { autoFocus: ["p-auto-focus", "autoFocus"], icon: ["p-icon", "icon"], label: ["p-label", "label"], help: ["p-help", "help"], name: "name", errorPattern: ["p-error-pattern", "errorPattern"], optional: ["p-optional", "optional"], noAutocomplete: ["p-no-autocomplete", "noAutocomplete"], placeholder: ["p-placeholder", "placeholder"], setDisabled: ["p-disabled", "setDisabled"], setReadonly: ["p-readonly", "setReadonly"], setRequired: ["p-required", "setRequired"], setClean: ["p-clean", "setClean"], setPattern: ["p-pattern", "setPattern"], maxlength: ["p-maxlength", "maxlength"], minlength: ["p-minlength", "minlength"], setMask: ["p-mask", "setMask"], setMaskFormatModel: ["p-mask-format-model", "setMaskFormatModel"] }, outputs: { blur: "p-blur", enter: "p-enter", change: "p-change", changeModel: "p-change-model" } });
+__decorate([
+    InputBoolean()
+], PoInputBaseComponent.prototype, "autoFocus", void 0);
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoInputBaseComponent, [{
+        type: Directive
+    }], function () { return [{ type: i0.ChangeDetectorRef }]; }, { autoFocus: [{
+            type: Input,
+            args: ['p-auto-focus']
+        }], icon: [{
+            type: Input,
+            args: ['p-icon']
+        }], label: [{
+            type: Input,
+            args: ['p-label']
+        }], help: [{
+            type: Input,
+            args: ['p-help']
+        }], name: [{
+            type: Input,
+            args: ['name']
+        }], errorPattern: [{
+            type: Input,
+            args: ['p-error-pattern']
+        }], optional: [{
+            type: Input,
+            args: ['p-optional']
+        }], blur: [{
+            type: Output,
+            args: ['p-blur']
+        }], enter: [{
+            type: Output,
+            args: ['p-enter']
+        }], change: [{
+            type: Output,
+            args: ['p-change']
+        }], changeModel: [{
+            type: Output,
+            args: ['p-change-model']
+        }], noAutocomplete: [{
+            type: Input,
+            args: ['p-no-autocomplete']
+        }], placeholder: [{
+            type: Input,
+            args: ['p-placeholder']
+        }], setDisabled: [{
+            type: Input,
+            args: ['p-disabled']
+        }], setReadonly: [{
+            type: Input,
+            args: ['p-readonly']
+        }], setRequired: [{
+            type: Input,
+            args: ['p-required']
+        }], setClean: [{
+            type: Input,
+            args: ['p-clean']
+        }], setPattern: [{
+            type: Input,
+            args: ['p-pattern']
+        }], maxlength: [{
+            type: Input,
+            args: ['p-maxlength']
+        }], minlength: [{
+            type: Input,
+            args: ['p-minlength']
+        }], setMask: [{
+            type: Input,
+            args: ['p-mask']
+        }], setMaskFormatModel: [{
+            type: Input,
+            args: ['p-mask-format-model']
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"po-input-base.component.js","sourceRoot":"","sources":["../../../../../../../projects/ui/src/lib/components/po-field/po-input/po-input-base.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { EventEmitter, Input, Output, Directive, TemplateRef, ChangeDetectorRef } from '@angular/core';\nimport { AbstractControl, ControlValueAccessor, Validator } from '@angular/forms';\n\nimport { convertToBoolean } from '../../../utils/util';\nimport { requiredFailed, maxlengpoailed, minlengpoailed, patternFailed } from './../validators';\nimport { InputBoolean } from '../../../decorators';\nimport { PoMask } from './po-mask';\n\n/**\n * @description\n *\n * Este é um componente baseado em input, com várias propriedades do input nativo e outras\n * propriedades extras como: máscara, pattern, mensagem de erro e etc.\n * Você deve informar a variável que contém o valor como [(ngModel)]=\"variavel\", para que o\n * input receba o valor da variável e para que ela receba as alterações do valor (two-way-databinding).\n * A propriedade name é obrigatória para que o formulário e o model funcionem corretamente.\n *\n * Importante:\n *\n * - Caso o input tenha um [(ngModel)] sem o atributo name, ocorrerá um erro de angular.\n * Então você precisa informar o atributo name ou o atributo [ngModelOptions]=\"{standalone: true}\".\n * Exemplo: [(ngModel)]=\"pessoa.nome\" [ngModelOptions]=\"{standalone: true}\".\n *\n */\n@Directive()\nexport abstract class PoInputBaseComponent implements ControlValueAccessor, Validator {\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Aplica foco no elemento ao ser iniciado.\n   *\n   * > Caso mais de um elemento seja configurado com essa propriedade, apenas o último elemento declarado com ela terá o foco.\n   *\n   * @default `false`\n   */\n  @Input('p-auto-focus') @InputBoolean() autoFocus: boolean = false;\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Define o ícone que será exibido no início do campo.\n   *\n   * É possível usar qualquer um dos ícones da [Biblioteca de ícones](/guides/icons). conforme exemplo abaixo:\n   * ```\n   * <po-input p-icon=\"po-icon-user\" p-label=\"PO input\"></po-input>\n   * ```\n   * Também é possível utilizar outras fontes de ícones, por exemplo a biblioteca *Font Awesome*, da seguinte forma:\n   * ```\n   * <po-input p-icon=\"fa fa-podcast\" p-label=\"PO input\"></po-input>\n   * ```\n   * Outra opção seria a customização do ícone através do `TemplateRef`, conforme exemplo abaixo:\n   * ```\n   * <po-input [p-icon]=\"template\" p-label=\"input template ionic\"></po-input>\n   *\n   * <ng-template #template>\n   *  <ion-icon style=\"font-size: inherit\" name=\"heart\"></ion-icon>\n   * </ng-template>\n   * ```\n   * > Para o ícone enquadrar corretamente, deve-se utilizar `font-size: inherit` caso o ícone utilizado não aplique-o.\n   */\n  @Input('p-icon') icon?: string | TemplateRef<void>;\n\n  /** Rótulo do campo. */\n  @Input('p-label') label?: string;\n\n  /** Texto de apoio do campo. */\n  @Input('p-help') help?: string;\n\n  /** Nome e identificador do campo. */\n  @Input('name') name: string;\n\n  /**\n   * @description\n   *\n   * Mensagem que será apresentada quando o `pattern` ou a máscara não for satisfeita.\n   *\n   * > Esta mensagem não é apresentada quando o campo estiver vazio, mesmo que ele seja requerido.\n   */\n  @Input('p-error-pattern') errorPattern?: string = '';\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Define se a indicação de campo opcional será exibida.\n   *\n   * > Não será exibida a indicação se:\n   * - O campo conter `p-required`;\n   * - Não possuir `p-help` e/ou `p-label`.\n   *\n   * @default `false`\n   */\n  @Input('p-optional') optional: boolean;\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Evento disparado ao sair do campo.\n   */\n  @Output('p-blur') blur: EventEmitter<any> = new EventEmitter();\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Evento disparado ao entrar do campo.\n   */\n  @Output('p-enter') enter: EventEmitter<any> = new EventEmitter();\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Evento disparado ao alterar valor e deixar o campo.\n   */\n  @Output('p-change') change: EventEmitter<any> = new EventEmitter();\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Evento disparado ao alterar valor do model.\n   */\n  @Output('p-change-model') changeModel: EventEmitter<any> = new EventEmitter();\n\n  type: string;\n\n  onChangePropagate: any = null;\n  objMask: any;\n  modelLastUpdate: any;\n  protected onTouched: any = null;\n\n  protected passedWriteValue: boolean = false;\n  protected validatorChange: any;\n\n  private _maxlength?: number;\n  private _minlength?: number;\n  private _noAutocomplete?: boolean = false;\n  private _placeholder?: string = '';\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Define a propriedade nativa `autocomplete` do campo como `off`.\n   *\n   * > No componente `po-password` será definido como `new-password`.\n   *\n   * @default `false`\n   */\n  @Input('p-no-autocomplete') set noAutocomplete(value: boolean) {\n    this._noAutocomplete = convertToBoolean(value);\n  }\n\n  get noAutocomplete() {\n    return this._noAutocomplete;\n  }\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Mensagem que aparecerá enquanto o campo não estiver preenchido.\n   *\n   * @default ''\n   */\n  @Input('p-placeholder') set placeholder(value: string) {\n    this._placeholder = value || '';\n  }\n  get placeholder() {\n    return this._placeholder;\n  }\n\n  /**\n   * @description\n   *\n   * Se verdadeiro, desabilita o campo.\n   *\n   * @default `false`\n   */\n  // eslint-disable-next-line @typescript-eslint/member-ordering\n  disabled?: boolean = false;\n  @Input('p-disabled') set setDisabled(disabled: string) {\n    this.disabled = disabled === '' ? true : convertToBoolean(disabled);\n\n    this.validateModel();\n  }\n\n  /** Indica que o campo será somente leitura. */\n  // eslint-disable-next-line @typescript-eslint/member-ordering\n  readonly?: boolean = false;\n  @Input('p-readonly') set setReadonly(readonly: string) {\n    this.readonly = readonly === '' ? true : convertToBoolean(readonly);\n  }\n\n  /**\n   * @description\n   *\n   * Indica que o campo será obrigatório.\n   *\n   * > Esta propriedade é desconsiderada quando o input está desabilitado `(p-disabled)`.\n   *\n   * @default `false`\n   */\n  // eslint-disable-next-line @typescript-eslint/member-ordering\n  required?: boolean = false;\n  @Input('p-required') set setRequired(required: string) {\n    this.required = required === '' ? true : convertToBoolean(required);\n\n    this.validateModel();\n  }\n\n  /** Se verdadeiro, o campo receberá um botão para ser limpo. */\n  // eslint-disable-next-line @typescript-eslint/member-ordering\n  clean?: boolean = false;\n  @Input('p-clean') set setClean(clean: string) {\n    this.clean = clean === '' ? true : convertToBoolean(clean);\n  }\n\n  /**\n   * @description\n   *\n   * Expressão regular para validar o campo.\n   * Quando o campo possuir uma máscara `(p-mask)` será automaticamente validado por ela, porém\n   * é possível definir um p-pattern para substituir a validação da máscara.\n   */\n  // eslint-disable-next-line @typescript-eslint/member-ordering\n  pattern?: string;\n  @Input('p-pattern') set setPattern(pattern: string) {\n    this.pattern = pattern;\n\n    this.validateModel();\n  }\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Indica a quantidade máxima de caracteres que o campo aceita.\n   */\n  @Input('p-maxlength') set maxlength(value: number) {\n    if (!isNaN(parseInt(<any>value, 10))) {\n      this._maxlength = parseInt(<any>value, 10);\n\n      this.validateModel();\n    } else if (!value) {\n      this._maxlength = undefined;\n\n      this.validateModel();\n    }\n  }\n\n  get maxlength() {\n    return this._maxlength;\n  }\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Indica a quantidade mínima de caracteres que o campo aceita.\n   */\n  @Input('p-minlength') set minlength(value: number) {\n    if (!isNaN(parseInt(<any>value, 10))) {\n      this._minlength = parseInt(<any>value, 10);\n\n      this.validateModel();\n    } else if (!value) {\n      this._minlength = undefined;\n\n      this.validateModel();\n    }\n  }\n\n  get minlength() {\n    return this._minlength;\n  }\n\n  /**\n   * @description\n   *\n   * Indica uma máscara para o campo. Exemplos: (+99) (99) 99999?-9999, 99999-999, 999.999.999-99.\n   * A máscara gera uma validação automática do campo, podendo esta ser substituída por um REGEX específico\n   * através da propriedade p-pattern.\n   * O campo será sinalizado e o formulário ficará inválido quando o valor informado estiver fora do padrão definido,\n   * mesmo quando desabilitado.\n   */\n  // eslint-disable-next-line @typescript-eslint/member-ordering\n  mask?: string = '';\n  @Input('p-mask') set setMask(mask: string) {\n    this.mask = mask;\n\n    // Atualiza Máscara do Campo\n    this.objMask = new PoMask(this.mask, this.maskFormatModel);\n  }\n\n  /**\n   * @description\n   *\n   * Indica se o `model` receberá o valor formatado pela máscara ou apenas o valor puro (sem formatação).\n   *\n   * @default `false`\n   */\n  // eslint-disable-next-line @typescript-eslint/member-ordering\n  maskFormatModel?: boolean = false;\n  @Input('p-mask-format-model') set setMaskFormatModel(maskFormatModel: string) {\n    this.maskFormatModel = maskFormatModel === '' ? true : convertToBoolean(maskFormatModel);\n\n    if (this.objMask instanceof PoMask) {\n      this.objMask.formatModel = this.maskFormatModel;\n\n      this.validateModel();\n    }\n  }\n\n  constructor(private cd?: ChangeDetectorRef) {}\n\n  callOnChange(value: any) {\n    this.updateModel(value);\n\n    this.controlChangeModelEmitter(value);\n  }\n\n  callUpdateModelWithTimeout(value) {\n    setTimeout(() => this.updateModel(value));\n  }\n\n  controlChangeModelEmitter(value: any) {\n    if (this.modelLastUpdate !== value) {\n      this.changeModel.emit(value);\n      this.modelLastUpdate = value;\n    }\n  }\n\n  // Função implementada do ControlValueAccessor\n  // Usada para interceptar os estados de habilitado via forms api\n  setDisabledState(isDisabled: boolean) {\n    this.disabled = isDisabled;\n    this.cd?.markForCheck();\n  }\n\n  // Função implementada do ControlValueAccessor\n  // Usada para interceptar as mudanças e não atualizar automaticamente o Model\n  registerOnChange(func: any): void {\n    this.onChangePropagate = func;\n  }\n\n  // Função implementada do ControlValueAccessor\n  // Usada para interceptar as mudanças e não atualizar automaticamente o Model\n  registerOnTouched(func: any): void {\n    this.onTouched = func;\n  }\n\n  registerOnValidatorChange(fn: () => void) {\n    this.validatorChange = fn;\n  }\n\n  updateModel(value: any) {\n    // Quando o input não possui um formulário, então esta função não é registrada\n    if (this.onChangePropagate) {\n      this.onChangePropagate(value);\n    }\n  }\n\n  validate(c: AbstractControl): { [key: string]: any } {\n    if (requiredFailed(this.required, this.disabled, this.getScreenValue())) {\n      return {\n        required: {\n          valid: false\n        }\n      };\n    }\n\n    if (maxlengpoailed(this.maxlength, this.getScreenValue())) {\n      return {\n        maxlength: {\n          valid: false\n        }\n      };\n    }\n\n    if (minlengpoailed(this.minlength, this.getScreenValue())) {\n      return {\n        minlength: {\n          valid: false\n        }\n      };\n    }\n\n    if (patternFailed(this.pattern, c.value)) {\n      this.validatePatternOnWriteValue(c.value);\n      return {\n        pattern: {\n          valid: false\n        }\n      };\n    }\n\n    return this.extraValidation(c);\n  }\n\n  // Função implementada do ControlValueAccessor\n  writeValue(value: any) {\n    this.writeValueModel(value);\n    this.cd?.markForCheck();\n  }\n\n  protected validateModel() {\n    if (this.validatorChange) {\n      this.validatorChange();\n    }\n  }\n\n  // utilizado para validar o pattern na inicializacao, fazendo dessa forma o campo fica sujo (dirty).\n  private validatePatternOnWriteValue(value: string) {\n    if (value && this.passedWriteValue) {\n      setTimeout(() => {\n        this.updateModel(value);\n      });\n\n      this.passedWriteValue = false;\n    }\n  }\n\n  /**\n   * Função que atribui foco ao componente.\n   *\n   * Para utilizá-la é necessário ter a instância do componente no DOM, podendo ser utilizado o ViewChild da seguinte forma:\n   *\n   * ```\n   * import { PoNomeDoComponenteComponent } from '@po-ui/ng-components';\n   *\n   * ...\n   *\n   * @ViewChild(PoNomeDoComponenteComponent, { static: true }) nomeDoComponente: PoNomeDoComponenteComponent;\n   *\n   * focusComponent() {\n   *   this.nomeDoComponente.focus();\n   * }\n   * ```\n   */\n  abstract focus(): void;\n\n  // Método que receberá o valor do model\n  abstract writeValueModel(value: any): void;\n\n  // Validações do campo\n  abstract extraValidation(c: AbstractControl): { [key: string]: any };\n\n  // Deve retornar o valor do campo\n  abstract getScreenValue(): string;\n}\n"]}

package/esm2020/lib/components/po-field/po-input/po-input.component.mjs

@@ -0,0 +1,111 @@
+import { ChangeDetectionStrategy, Component, forwardRef } from '@angular/core';
+import { NG_VALUE_ACCESSOR, NG_VALIDATORS } from '@angular/forms';
+import { PoInputGeneric } from '../po-input-generic/po-input-generic';
+import * as i0 from "@angular/core";
+import * as i1 from "../po-field-container/po-field-container.component";
+import * as i2 from "@angular/common";
+import * as i3 from "../po-field-container/po-field-container-bottom/po-field-container-bottom.component";
+import * as i4 from "../../po-icon/po-icon.component";
+import * as i5 from "../po-clean/po-clean.component";
+function PoInputComponent_div_2_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "div", 8);
+    i0.ɵɵelement(1, "po-icon", 9);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r0 = i0.ɵɵnextContext();
+    i0.ɵɵadvance(1);
+    i0.ɵɵclassProp("po-field-icon-disabled", ctx_r0.disabled);
+    i0.ɵɵproperty("p-icon", ctx_r0.icon);
+} }
+function PoInputComponent_po_clean_6_Template(rf, ctx) { if (rf & 1) {
+    const _r4 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "po-clean", 10);
+    i0.ɵɵlistener("p-change-event", function PoInputComponent_po_clean_6_Template_po_clean_p_change_event_0_listener($event) { i0.ɵɵrestoreView(_r4); const ctx_r3 = i0.ɵɵnextContext(); return ctx_r3.clear($event); });
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r2 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("p-element-ref", ctx_r2.inputEl);
+} }
+/**
+ * @docsExtends PoInputBaseComponent
+ *
+ * @example
+ *
+ * <example name="po-input-basic" title="PO Input Basic">
+ *  <file name="sample-po-input-basic/sample-po-input-basic.component.html"> </file>
+ *  <file name="sample-po-input-basic/sample-po-input-basic.component.ts"> </file>
+ * </example>
+ *
+ * <example name="po-input-labs" title="PO Input Labs">
+ *  <file name="sample-po-input-labs/sample-po-input-labs.component.html"> </file>
+ *  <file name="sample-po-input-labs/sample-po-input-labs.component.ts"> </file>
+ * </example>
+ *
+ * <example name="po-input-reactive-form" title="PO Input - Reactive Form">
+ *  <file name="sample-po-input-reactive-form/sample-po-input-reactive-form.component.html"> </file>
+ *  <file name="sample-po-input-reactive-form/sample-po-input-reactive-form.component.ts"> </file>
+ * </example>
+ */
+export class PoInputComponent extends PoInputGeneric {
+    /* istanbul ignore next */
+    constructor(el, cd) {
+        super(el, cd);
+    }
+    extraValidation(c) {
+        return null;
+    }
+}
+PoInputComponent.ɵfac = function PoInputComponent_Factory(t) { return new (t || PoInputComponent)(i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.ChangeDetectorRef)); };
+PoInputComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: PoInputComponent, selectors: [["po-input"]], features: [i0.ɵɵProvidersFeature([
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => PoInputComponent),
+                multi: true
+            },
+            {
+                provide: NG_VALIDATORS,
+                useExisting: forwardRef(() => PoInputComponent),
+                multi: true
+            }
+        ]), i0.ɵɵInheritDefinitionFeature], decls: 8, vars: 17, consts: [[3, "p-help", "p-label", "p-optional"], [1, "po-field-container-content"], ["class", "po-field-icon-container-left", 4, "ngIf"], [1, "po-input", 3, "autocomplete", "disabled", "placeholder", "readonly", "required", "type", "blur", "click", "focus", "input"], ["inp", ""], [1, "po-field-icon-container-right"], [3, "p-element-ref", "p-change-event", 4, "ngIf"], [3, "p-error-pattern"], [1, "po-field-icon-container-left"], [1, "po-field-icon", 3, "p-icon"], [3, "p-element-ref", "p-change-event"]], template: function PoInputComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵelementStart(0, "po-field-container", 0);
+        i0.ɵɵelementStart(1, "div", 1);
+        i0.ɵɵtemplate(2, PoInputComponent_div_2_Template, 2, 3, "div", 2);
+        i0.ɵɵelementStart(3, "input", 3, 4);
+        i0.ɵɵlistener("blur", function PoInputComponent_Template_input_blur_3_listener($event) { return ctx.eventOnBlur($event); })("click", function PoInputComponent_Template_input_click_3_listener($event) { return ctx.eventOnClick($event); })("focus", function PoInputComponent_Template_input_focus_3_listener($event) { return ctx.eventOnFocus($event); })("input", function PoInputComponent_Template_input_input_3_listener($event) { return ctx.eventOnInput($event); });
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementStart(5, "div", 5);
+        i0.ɵɵtemplate(6, PoInputComponent_po_clean_6_Template, 1, 1, "po-clean", 6);
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementEnd();
+        i0.ɵɵelement(7, "po-field-container-bottom", 7);
+        i0.ɵɵelementEnd();
+    } if (rf & 2) {
+        i0.ɵɵproperty("p-help", ctx.help)("p-label", ctx.label)("p-optional", !ctx.required && ctx.optional);
+        i0.ɵɵadvance(2);
+        i0.ɵɵproperty("ngIf", ctx.icon);
+        i0.ɵɵadvance(1);
+        i0.ɵɵclassProp("po-input-icon-left", ctx.icon)("po-input-icon-right", ctx.clean);
+        i0.ɵɵproperty("autocomplete", ctx.autocomplete)("disabled", ctx.disabled)("placeholder", ctx.placeholder)("readonly", ctx.readonly)("required", ctx.required)("type", ctx.type);
+        i0.ɵɵattribute("name", ctx.name);
+        i0.ɵɵadvance(3);
+        i0.ɵɵproperty("ngIf", ctx.clean && !ctx.disabled && !ctx.readonly);
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("p-error-pattern", ctx.getErrorPattern());
+    } }, directives: [i1.PoFieldContainerComponent, i2.NgIf, i3.PoFieldContainerBottomComponent, i4.PoIconComponent, i5.PoCleanComponent], encapsulation: 2, changeDetection: 0 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoInputComponent, [{
+        type: Component,
+        args: [{ selector: 'po-input', providers: [
+                    {
+                        provide: NG_VALUE_ACCESSOR,
+                        useExisting: forwardRef(() => PoInputComponent),
+                        multi: true
+                    },
+                    {
+                        provide: NG_VALIDATORS,
+                        useExisting: forwardRef(() => PoInputComponent),
+                        multi: true
+                    }
+                ], changeDetection: ChangeDetectionStrategy.OnPush, template: "<po-field-container [p-help]=\"help\" [p-label]=\"label\" [p-optional]=\"!required && optional\">\n  <div class=\"po-field-container-content\">\n    <div *ngIf=\"icon\" class=\"po-field-icon-container-left\">\n      <po-icon class=\"po-field-icon\" [class.po-field-icon-disabled]=\"disabled\" [p-icon]=\"icon\"></po-icon>\n    </div>\n\n    <input\n      #inp\n      class=\"po-input\"\n      [attr.name]=\"name\"\n      [autocomplete]=\"autocomplete\"\n      [class.po-input-icon-left]=\"icon\"\n      [class.po-input-icon-right]=\"clean\"\n      [disabled]=\"disabled\"\n      [placeholder]=\"placeholder\"\n      [readonly]=\"readonly\"\n      [required]=\"required\"\n      [type]=\"type\"\n      (blur)=\"eventOnBlur($event)\"\n      (click)=\"eventOnClick($event)\"\n      (focus)=\"eventOnFocus($event)\"\n      (input)=\"eventOnInput($event)\"\n    />\n\n    <div class=\"po-field-icon-container-right\">\n      <po-clean *ngIf=\"clean && !disabled && !readonly\" [p-element-ref]=\"inputEl\" (p-change-event)=\"clear($event)\">\n      </po-clean>\n    </div>\n  </div>\n\n  <po-field-container-bottom [p-error-pattern]=\"getErrorPattern()\"> </po-field-container-bottom>\n</po-field-container>\n" }]
+    }], function () { return [{ type: i0.ElementRef }, { type: i0.ChangeDetectorRef }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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