@po-ui/ng-components 5.22.3 → 6.2.0

package/esm2020/lib/components/po-dynamic/po-dynamic-form/po-dynamic-form-fields/po-dynamic-form-fields-base.component.mjs

@@ -0,0 +1,221 @@
+import { Input, EventEmitter, Output, Directive } from '@angular/core';
+import { isTypeof, sortFields } from '../../../../utils/util';
+import { getGridColumnsClasses, isVisibleField } from '../../po-dynamic.util';
+import { PoDynamicFieldType } from '../../po-dynamic-field-type.enum';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class PoDynamicFormFieldsBaseComponent {
+    constructor(titleCasePipe) {
+        this.titleCasePipe = titleCasePipe;
+        this.formValidate = new EventEmitter();
+        this.fieldsChange = new EventEmitter();
+        // Evento disparado se existir optionsService em visibleField. Necessário resgatar referência do objeto selecionado para quando se tratar de recebimento de opções via serviço.
+        this.objectValue = new EventEmitter();
+        this.visibleFields = [];
+        this._value = {};
+    }
+    // array de objetos que implementam a interface PoDynamicFormField, que serão exibidos no componente.
+    set fields(value) {
+        this._fields = Array.isArray(value) ? [...value] : [];
+    }
+    get fields() {
+        return this._fields;
+    }
+    // valor que será utilizado para iniciar valor no componente.
+    set value(value) {
+        this._value = value && isTypeof(value, 'object') ? value : {};
+    }
+    get value() {
+        return this._value;
+    }
+    set validateFields(value) {
+        this._validateFields = Array.isArray(value) ? [...value] : [];
+    }
+    get validateFields() {
+        return this._validateFields;
+    }
+    compareTo(value, compareTo) {
+        return value === compareTo;
+    }
+    // retorna um array com os objetos configurados e visiveis.
+    getVisibleFields() {
+        const visibleFields = [];
+        this.fields.forEach(field => {
+            if (this.existsProperty(visibleFields, field.property)) {
+                this.printError(`"po-dynamic-form" property "${field.property}" está duplicado. Interface: PoDynamicFormField.`);
+                return;
+            }
+            if (!field['property']) {
+                this.printError('"po-dynamic-form" É obrigatório ser especificado um property.');
+                return;
+            }
+            if (isVisibleField(field)) {
+                visibleFields.push(this.createField(field));
+            }
+        });
+        return sortFields(visibleFields);
+    }
+    // converte um array em string para um array de objetos que contem label e value.
+    convertOptions(options) {
+        const everyOptionString = options.every(option => typeof option === 'string');
+        if (everyOptionString) {
+            return options.map(value => ({ label: value, value }));
+        }
+        return options;
+    }
+    // cria um novo objeto com as classes de grid system, com control (tipo do componente) e label default.
+    createField(field) {
+        const control = this.getComponentControl(field);
+        const options = !!field.options ? this.convertOptions(field.options) : undefined;
+        const focus = this.hasFocus(field);
+        const type = field && field.type ? field.type.toLocaleLowerCase() : 'string';
+        const componentClass = getGridColumnsClasses(field.gridSmColumns, field.gridMdColumns, field.gridLgColumns, field.gridXlColumns, field.gridColumns, {
+            smPull: field.gridSmPull,
+            mdPull: field.gridMdPull,
+            lgPull: field.gridLgPull,
+            xlPull: field.gridXlPull
+        });
+        return {
+            label: this.titleCasePipe.transform(field.property),
+            maskFormatModel: this.compareTo(type, PoDynamicFieldType.Time),
+            ...field,
+            componentClass,
+            control,
+            focus,
+            options
+        };
+    }
+    existsProperty(fields, property) {
+        return fields.some(field => field.property === property);
+    }
+    // recupera o componente de acordo com algumas regras do field.
+    getComponentControl(field = {}) {
+        const type = field && field.type ? field.type.toLocaleLowerCase() : 'string';
+        if (this.isNumberType(field, type)) {
+            return 'number';
+        }
+        else if (this.isCurrencyType(field, type)) {
+            return 'decimal';
+        }
+        else if (this.isSelect(field)) {
+            return 'select';
+        }
+        else if (this.isRadioGroup(field)) {
+            return 'radioGroup';
+        }
+        else if (this.isCheckboxGroup(field)) {
+            return 'checkboxGroup';
+        }
+        else if (this.isMultiselect(field)) {
+            return 'multiselect';
+        }
+        else if (this.compareTo(type, PoDynamicFieldType.Boolean)) {
+            return 'switch';
+        }
+        else if (this.compareTo(type, PoDynamicFieldType.Date) || this.compareTo(type, PoDynamicFieldType.DateTime)) {
+            return field.range ? 'datepickerrange' : 'datepicker';
+        }
+        else if (this.compareTo(type, PoDynamicFieldType.Time)) {
+            field.mask = field.mask || '99:99';
+            return 'input';
+        }
+        else if (this.isCombo(field)) {
+            return 'combo';
+        }
+        else if (this.isLookup(field)) {
+            return 'lookup';
+        }
+        else if (this.isTextarea(field)) {
+            return 'textarea';
+        }
+        else if (this.isPassword(field)) {
+            return 'password';
+        }
+        return 'input';
+    }
+    hasFocus(field) {
+        return !!this.autoFocus && this.autoFocus === field.property;
+    }
+    isCheckboxGroup(field) {
+        const { optionsService, optionsMulti, options } = field;
+        return !optionsService && optionsMulti && !!options && options.length <= 3;
+    }
+    isCombo(field) {
+        const { optionsService } = field;
+        return !!optionsService && (isTypeof(optionsService, 'string') || this.isComboFilter(optionsService));
+    }
+    isCurrencyType(field, type) {
+        const { mask, pattern } = field;
+        return this.compareTo(type, PoDynamicFieldType.Currency) && !mask && !pattern;
+    }
+    isLookupFilter(object) {
+        return object && object.getObjectByValue !== undefined;
+    }
+    isComboFilter(object) {
+        return object && object.getFilteredData !== undefined;
+    }
+    isLookup(field) {
+        const { searchService } = field;
+        return !!searchService && (isTypeof(searchService, 'string') || this.isLookupFilter(searchService));
+    }
+    isMultiselect(field) {
+        const { optionsService, optionsMulti, options } = field;
+        return optionsMulti && (!!optionsService || (!!options && options.length > 3));
+    }
+    isNumberType(field, type) {
+        const { mask, pattern } = field;
+        return this.compareTo(type, PoDynamicFieldType.Number) && !mask && !pattern;
+    }
+    isPassword(field) {
+        const { secret } = field;
+        return secret;
+    }
+    isRadioGroup(field) {
+        const { optionsMulti, options } = field;
+        return !optionsMulti && !!options && options.length <= 3;
+    }
+    isSelect(field) {
+        const { optionsMulti, options } = field;
+        return !optionsMulti && !!options && options.length > 3;
+    }
+    isTextarea(field) {
+        const { rows } = field;
+        return rows && rows >= 3;
+    }
+    printError(error) {
+        console.error(error);
+    }
+}
+PoDynamicFormFieldsBaseComponent.ɵfac = function PoDynamicFormFieldsBaseComponent_Factory(t) { return new (t || PoDynamicFormFieldsBaseComponent)(i0.ɵɵdirectiveInject(i1.TitleCasePipe)); };
+PoDynamicFormFieldsBaseComponent.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: PoDynamicFormFieldsBaseComponent, inputs: { autoFocus: ["p-auto-focus", "autoFocus"], disabledForm: ["p-disabled-form", "disabledForm"], validate: ["p-validate", "validate"], fields: ["p-fields", "fields"], value: ["p-value", "value"], validateFields: ["p-validate-fields", "validateFields"] }, outputs: { formValidate: "p-form-validate", fieldsChange: "p-fieldsChange", objectValue: "p-object-value" } });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoDynamicFormFieldsBaseComponent, [{
+        type: Directive
+    }], function () { return [{ type: i1.TitleCasePipe }]; }, { autoFocus: [{
+            type: Input,
+            args: ['p-auto-focus']
+        }], disabledForm: [{
+            type: Input,
+            args: ['p-disabled-form']
+        }], validate: [{
+            type: Input,
+            args: ['p-validate']
+        }], formValidate: [{
+            type: Output,
+            args: ['p-form-validate']
+        }], fieldsChange: [{
+            type: Output,
+            args: ['p-fieldsChange']
+        }], objectValue: [{
+            type: Output,
+            args: ['p-object-value']
+        }], fields: [{
+            type: Input,
+            args: ['p-fields']
+        }], value: [{
+            type: Input,
+            args: ['p-value']
+        }], validateFields: [{
+            type: Input,
+            args: ['p-validate-fields']
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"po-dynamic-form-fields-base.component.js","sourceRoot":"","sources":["../../../../../../../../projects/ui/src/lib/components/po-dynamic/po-dynamic-form/po-dynamic-form-fields/po-dynamic-form-fields-base.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Input, EventEmitter, Output, Directive } from '@angular/core';\nimport { TitleCasePipe } from '@angular/common';\n\nimport { isTypeof, sortFields } from '../../../../utils/util';\n\nimport { getGridColumnsClasses, isVisibleField } from '../../po-dynamic.util';\nimport { PoDynamicFieldType } from '../../po-dynamic-field-type.enum';\nimport { PoDynamicFormField } from '../po-dynamic-form-field.interface';\nimport { PoDynamicFormFieldInternal } from './po-dynamic-form-field-internal.interface';\nimport { PoComboFilter } from '../../../po-field/po-combo/interfaces/po-combo-filter.interface';\nimport { PoLookupFilter } from '../../../po-field/po-lookup/interfaces/po-lookup-filter.interface';\n\n@Directive()\nexport class PoDynamicFormFieldsBaseComponent {\n  @Input('p-auto-focus') autoFocus?: string;\n\n  @Input('p-disabled-form') disabledForm: boolean;\n\n  @Input('p-validate') validate?: string | Function;\n\n  @Output('p-form-validate') formValidate = new EventEmitter<any>();\n\n  @Output('p-fieldsChange') fieldsChange = new EventEmitter<any>();\n\n  // Evento disparado se existir optionsService em visibleField. Necessário resgatar referência do objeto selecionado para quando se tratar de recebimento de opções via serviço.\n  @Output('p-object-value') objectValue = new EventEmitter<any>();\n\n  visibleFields: Array<PoDynamicFormFieldInternal> = [];\n\n  private _fields: Array<PoDynamicFormField>;\n  private _validateFields: Array<string>;\n  private _value?: any = {};\n\n  // array de objetos que implementam a interface PoDynamicFormField, que serão exibidos no componente.\n  @Input('p-fields') set fields(value: Array<PoDynamicFormField>) {\n    this._fields = Array.isArray(value) ? [...value] : [];\n  }\n\n  get fields() {\n    return this._fields;\n  }\n\n  // valor que será utilizado para iniciar valor no componente.\n  @Input('p-value') set value(value: any) {\n    this._value = value && isTypeof(value, 'object') ? value : {};\n  }\n\n  get value() {\n    return this._value;\n  }\n\n  @Input('p-validate-fields') set validateFields(value: Array<string>) {\n    this._validateFields = Array.isArray(value) ? [...value] : [];\n  }\n\n  get validateFields() {\n    return this._validateFields;\n  }\n\n  constructor(private titleCasePipe: TitleCasePipe) {}\n\n  compareTo(value, compareTo) {\n    return value === compareTo;\n  }\n\n  // retorna um array com os objetos configurados e visiveis.\n  protected getVisibleFields() {\n    const visibleFields = [];\n\n    this.fields.forEach(field => {\n      if (this.existsProperty(visibleFields, field.property)) {\n        this.printError(\n          `\"po-dynamic-form\" property \"${field.property}\" está duplicado. Interface: PoDynamicFormField.`\n        );\n        return;\n      }\n\n      if (!field['property']) {\n        this.printError('\"po-dynamic-form\" É obrigatório ser especificado um property.');\n        return;\n      }\n\n      if (isVisibleField(field)) {\n        visibleFields.push(this.createField(field));\n      }\n    });\n\n    return sortFields(visibleFields);\n  }\n\n  // converte um array em string para um array de objetos que contem label e value.\n  private convertOptions(options: Array<any>): Array<{ label: string; value: string }> {\n    const everyOptionString = options.every(option => typeof option === 'string');\n\n    if (everyOptionString) {\n      return options.map(value => ({ label: value, value }));\n    }\n\n    return options;\n  }\n\n  // cria um novo objeto com as classes de grid system, com control (tipo do componente) e label default.\n  private createField(field: PoDynamicFormField): PoDynamicFormFieldInternal {\n    const control = this.getComponentControl(field);\n    const options = !!field.options ? this.convertOptions(field.options) : undefined;\n    const focus = this.hasFocus(field);\n    const type = field && field.type ? field.type.toLocaleLowerCase() : 'string';\n\n    const componentClass = getGridColumnsClasses(\n      field.gridSmColumns,\n      field.gridMdColumns,\n      field.gridLgColumns,\n      field.gridXlColumns,\n      field.gridColumns,\n      {\n        smPull: field.gridSmPull,\n        mdPull: field.gridMdPull,\n        lgPull: field.gridLgPull,\n        xlPull: field.gridXlPull\n      }\n    );\n\n    return {\n      label: this.titleCasePipe.transform(field.property),\n      maskFormatModel: this.compareTo(type, PoDynamicFieldType.Time),\n      ...field,\n      componentClass,\n      control,\n      focus,\n      options\n    };\n  }\n\n  private existsProperty(fields: Array<PoDynamicFormField>, property: string) {\n    return fields.some(field => field.property === property);\n  }\n\n  // recupera o componente de acordo com algumas regras do field.\n  private getComponentControl(field: PoDynamicFormField = <any>{}) {\n    const type = field && field.type ? field.type.toLocaleLowerCase() : 'string';\n\n    if (this.isNumberType(field, type)) {\n      return 'number';\n    } else if (this.isCurrencyType(field, type)) {\n      return 'decimal';\n    } else if (this.isSelect(field)) {\n      return 'select';\n    } else if (this.isRadioGroup(field)) {\n      return 'radioGroup';\n    } else if (this.isCheckboxGroup(field)) {\n      return 'checkboxGroup';\n    } else if (this.isMultiselect(field)) {\n      return 'multiselect';\n    } else if (this.compareTo(type, PoDynamicFieldType.Boolean)) {\n      return 'switch';\n    } else if (this.compareTo(type, PoDynamicFieldType.Date) || this.compareTo(type, PoDynamicFieldType.DateTime)) {\n      return field.range ? 'datepickerrange' : 'datepicker';\n    } else if (this.compareTo(type, PoDynamicFieldType.Time)) {\n      field.mask = field.mask || '99:99';\n\n      return 'input';\n    } else if (this.isCombo(field)) {\n      return 'combo';\n    } else if (this.isLookup(field)) {\n      return 'lookup';\n    } else if (this.isTextarea(field)) {\n      return 'textarea';\n    } else if (this.isPassword(field)) {\n      return 'password';\n    }\n\n    return 'input';\n  }\n\n  private hasFocus(field: PoDynamicFormField) {\n    return !!this.autoFocus && this.autoFocus === field.property;\n  }\n\n  private isCheckboxGroup(field: PoDynamicFormField) {\n    const { optionsService, optionsMulti, options } = field;\n\n    return !optionsService && optionsMulti && !!options && options.length <= 3;\n  }\n\n  private isCombo(field: PoDynamicFormField) {\n    const { optionsService } = field;\n\n    return !!optionsService && (isTypeof(optionsService, 'string') || this.isComboFilter(optionsService));\n  }\n\n  private isCurrencyType(field: PoDynamicFormField, type: string) {\n    const { mask, pattern } = field;\n\n    return this.compareTo(type, PoDynamicFieldType.Currency) && !mask && !pattern;\n  }\n\n  private isLookupFilter(object: any): object is PoLookupFilter {\n    return object && (<PoLookupFilter>object).getObjectByValue !== undefined;\n  }\n\n  private isComboFilter(object: any): object is PoComboFilter {\n    return object && (<PoComboFilter>object).getFilteredData !== undefined;\n  }\n\n  private isLookup(field: PoDynamicFormField) {\n    const { searchService } = field;\n\n    return !!searchService && (isTypeof(searchService, 'string') || this.isLookupFilter(searchService));\n  }\n\n  private isMultiselect(field: PoDynamicFormField) {\n    const { optionsService, optionsMulti, options } = field;\n\n    return optionsMulti && (!!optionsService || (!!options && options.length > 3));\n  }\n\n  private isNumberType(field: PoDynamicFormField, type: string) {\n    const { mask, pattern } = field;\n\n    return this.compareTo(type, PoDynamicFieldType.Number) && !mask && !pattern;\n  }\n\n  private isPassword(field: PoDynamicFormField) {\n    const { secret } = field;\n\n    return secret;\n  }\n\n  private isRadioGroup(field: PoDynamicFormField) {\n    const { optionsMulti, options } = field;\n\n    return !optionsMulti && !!options && options.length <= 3;\n  }\n\n  private isSelect(field: PoDynamicFormField) {\n    const { optionsMulti, options } = field;\n\n    return !optionsMulti && !!options && options.length > 3;\n  }\n\n  private isTextarea(field: PoDynamicFormField) {\n    const { rows } = field;\n\n    return rows && rows >= 3;\n  }\n\n  private printError(error: string) {\n    console.error(error);\n  }\n}\n"]}