keevo-components 2.0.106 → 2.0.107

package/src/lib/api/directives/stepper/dynamicinput.directive.ts

@@ -0,0 +1,23 @@
+import { Directive, Input, ViewContainerRef, ComponentRef, Type } from '@angular/core';
+
+@Directive({
+  selector: '[dynamicComponent]'
+})
+export class DynamicInputDirective {
+  @Input() set dynamicComponent({ component, inputs }: { component: Type<any>, inputs: { [key: string]: any } }) {
+    if (component) {
+      const componentRef = this.vcr.createComponent(component);
+      this.applyInputs(componentRef, inputs);
+    }
+  }
+
+  constructor(private vcr: ViewContainerRef) { }
+
+  private applyInputs(componentRef: ComponentRef<any>, inputs: { [key: string]: any }) {
+    if (inputs) {
+      for (const key of Object.keys(inputs)) {
+        componentRef.instance[key] = inputs[key];
+      }
+    }
+  }
+}

package/src/lib/api/directives/template/template.directive.ts

@@ -0,0 +1,15 @@
+import { Directive, Input, TemplateRef } from '@angular/core';
+
+@Directive({
+  selector: '[cTemplate]'
+})
+export class TemplateDirective {
+  @Input() type!: string;
+  @Input('cTemplate') name!: string;
+
+  constructor(public template: TemplateRef<any>) { }
+
+  getType(): string {
+    return this.name;
+  }
+}

package/src/lib/api/helpers/component-providers.ts

@@ -0,0 +1,16 @@
+import { Provider, forwardRef } from "@angular/core";
+import { NG_VALUE_ACCESSOR } from "@angular/forms";
+import { ComponentService } from '../services/component.service';
+
+export function ComponentProviders(ref: any): Provider[] {
+  return [
+    {
+      provide: NG_VALUE_ACCESSOR,
+      useExisting: forwardRef(() => ref),
+      multi: true,
+    },
+    {
+      provide: ComponentService
+    }
+  ]
+}

package/src/lib/api/helpers/keevo-validators.ts

@@ -0,0 +1,174 @@
+import { AbstractControl, FormGroup, ValidationErrors, ValidatorFn, Validators } from '@angular/forms';
+import { DocsService } from '../services/docs.service';
+
+export class KeevoValidators {
+  static required(erroMessage?: string): ValidatorFn {
+    return (control: AbstractControl): ValidationErrors | null => {
+      if (Validators.required(control))
+        return { required: true, erroMessage: `${erroMessage ? erroMessage : 'Campo obrigatório'}` };
+
+      return null;
+    };
+  }
+
+  static dateGreaterThan(startControlName: string, erroMessage?: string): ValidatorFn {
+    return (endControl: AbstractControl): ValidationErrors | null => {
+      const parent = endControl.parent as FormGroup;
+
+      if (!parent) return null;
+
+      const startControl: AbstractControl = parent.get(startControlName) as AbstractControl;
+
+      const startDate: Date = startControl.value;
+      const endDate: Date = endControl.value;
+
+      if (!startDate || !endDate) {
+        return null;
+      }
+      if (startDate > endDate) {
+        return { greaterThan: true, erroMessage: erroMessage };
+      }
+      return null;
+    };
+  }
+
+  static dateLessThan(startControlName: string, erroMessage?: string): ValidatorFn {
+    return (endControl: AbstractControl): ValidationErrors | null => {
+      const parent = endControl.parent as FormGroup;
+
+      if (!parent) return null;
+
+      const startControl: AbstractControl = parent.get(startControlName) as AbstractControl;
+
+      const startDate: Date = startControl.value;
+      const endDate: Date = endControl.value;
+
+      if (!startDate || !endDate) {
+        return null;
+      }
+      if (startDate < endDate) {
+        return { greaterThan: true, erroMessage: erroMessage };
+      }
+      return null;
+    };
+  }
+
+  static min(min: number, erroMessage?: string): ValidatorFn {
+    return (control: AbstractControl): ValidationErrors | null => {
+      if (Validators.min(min)(control))
+        return { min: true, erroMessage: `${erroMessage ? erroMessage : 'Informe um valor maior ou igual à '}${min}` };
+
+      return null;
+    };
+  }
+
+  static max(min: number, erroMessage?: string): ValidatorFn {
+    return (control: AbstractControl): ValidationErrors | null => {
+      if (Validators.max(min)(control))
+        return { min: true, erroMessage: `${erroMessage ? erroMessage : 'Informe um valor menor ou igual à '}${min}` };
+
+      return null;
+    };
+  }
+
+  static email(erroMessage?: string): ValidatorFn {
+    return (control: AbstractControl): ValidationErrors | null => {
+      if (Validators.email(control)) {
+        return { email: true, erroMessage: `${erroMessage ? erroMessage : 'Endereço de e-mail inválido!'}` };
+      }
+      return null;
+    };
+  }
+
+  static maxLengthArray(max: number): ValidatorFn {
+    return (control: AbstractControl): ValidationErrors | null => {
+      if (control.value.length < max)
+        return null;
+
+      return { maxLengthArray: true, erroMessage: 'Tamanho máximo excedido!' };
+    }
+  }
+
+  static maxLength(max: number, erroMessage?: string): ValidatorFn {
+    return (control: AbstractControl): ValidationErrors | null => {
+      if (Validators.maxLength(max)(control))
+        return { maxLength: true, erroMessage: `${erroMessage ? erroMessage : 'Limite máximo de ${max} caracteres atingido!'}` };
+      return null;
+    }
+  }
+
+  static minLength(min: number, erroMessage?: string): ValidatorFn {
+    return (control: AbstractControl): ValidationErrors | null => {
+      if (Validators.minLength(min)(control))
+        return { minLength: true, erroMessage: `${erroMessage ? erroMessage : 'É necessário mínimo de ${min} caracteres!'}` };
+      return null;
+    }
+  }
+
+  static nome(): ValidatorFn {
+    return (control: AbstractControl): ValidationErrors | null => {
+      let palavras = control.value.trim().split(' ');
+      if (palavras?.length < 2)
+        return { nome: true, erroMessage: 'Digite seu nome completo.' };
+      return null;
+    }
+  }
+
+  static cpfCnpjValido(erroMessage?: string): ValidatorFn {
+    return (control: AbstractControl): ValidationErrors | null => {
+      let value = (control.value ?? '').replace(/\D/g, '');
+      if (!DocsService.validaCpfCnpj(value)) {
+        return { cpfcnpj: true, erroMessage: `${erroMessage ? erroMessage : 'CPF/CNPJ inválido!'}` };
+      }
+      return null;
+    };
+  }
+
+  static validText(minWords: number = 5, erroMessage?: string): ValidatorFn {
+    return (control: AbstractControl): ValidationErrors | null => {
+      const value = control.value;
+      if (value.length > 8) {
+        const errors: { [key: string]: boolean } = {};
+
+        if (KeevoValidators.checkMinWords(value, minWords)) {
+          errors['invalidWordCount'] = true;
+        }
+
+        if (KeevoValidators.checkRepeatedCharacters(value)) {
+          errors['repeatCharacterInWord'] = true;
+        }
+
+        return Object.keys(errors).length ? { ...errors, erroMessage: erroMessage || 'Texto inválido' } : null;
+      }
+      return null
+    };
+  }
+
+  static fieldGreaterThan(fieldToValidate: string, fieldToCompare: string, erroMessage: string): ValidatorFn {
+    return (form: AbstractControl): ValidationErrors | null => {
+      const group = form as FormGroup;
+
+      const fieldToValidateValue = group.get(fieldToValidate)?.value ?? 0;
+      const fieldToCompareValue = group.get(fieldToCompare)?.value ?? 0;
+      const fieldToValidateControl = group.get(fieldToValidate);
+
+      if (fieldToValidateValue > fieldToCompareValue) {
+        fieldToValidateControl?.setErrors({ erroMessage })
+        return { fieldGreaterThan: true };
+      }
+
+      return null;
+    };
+  }
+
+  private static checkMinWords(value: string, minWords: number): boolean {
+    const words = value.match(/\S+/g);
+    return !words || words.length < minWords;
+  }
+
+  private static checkRepeatedCharacters(value: string): boolean {
+    const regex = /(.)\1{7,}/g;
+    const matches = value.match(regex);
+    return matches && matches.length > 0 || false;
+  }
+}

package/src/lib/api/helpers/severity-color.ts

@@ -0,0 +1,77 @@
+import Severity from "../types/severity";
+
+export function severityColorNormal(severity: Severity): string {
+  switch (severity) {
+    case "primary":
+      return "#002542";
+    case "secondary":
+      return "#F2F3F5";
+    case "success":
+      return "#29B92D";
+    case "info":
+      return "#03A9F4";
+    case "warning":
+      return "#FFC107";
+    case "help":
+      return "#9C27B0";
+    case "danger":
+      return "#F44336";
+  }
+}
+
+export function severityColorHover(severity: Severity): string {
+  switch (severity) {
+    case "primary":
+      return "#002038";
+    case "secondary":
+      return "#D9DADB";
+    case "success":
+      return "#249A29";
+    case "info":
+      return "#039BE5";
+    case "warning":
+      return "#FFB300";
+    case "help":
+      return "#8E24AA";
+    case "danger":
+      return "#E53935";
+  }
+}
+
+export function severityColorActive(severity: Severity): string {
+  switch (severity) {
+    case "primary":
+      return "#001729";
+    case "secondary":
+      return "#C0C1C2";
+    case "success":
+      return "#1C801F";
+    case "info":
+      return "#0288D1";
+    case "warning":
+      return "#FFA000";
+    case "help":
+      return "#7B1FA2";
+    case "danger":
+      return "#d32f2f";
+  }
+}
+
+export function severityColorText(severity: Severity): string {
+  switch (severity) {
+    case "primary":
+      return "#FFFFFF";
+    case "secondary":
+      return "#212121";
+    case "success":
+      return "#FFFFFF";
+    case "info":
+      return "#FFFFFF";
+    case "warning":
+      return "#495057"
+    case "help":
+      return "#FFFFFF";
+    case "danger":
+      return "#FFFFFF";
+  }
+}

package/src/lib/api/helpers/translate-primeng.ts

@@ -0,0 +1,25 @@
+import { PrimeNGConfig } from 'primeng/api';
+
+export class TranslatePrimeng {
+  public config(config: PrimeNGConfig): void {
+    config.ripple = true;
+
+    config.setTranslation({
+      monthNames: ['Janeiro', 'Fevereiro', 'Março', 'Abril', 'Maio', 'Junho', 'Julho', 'Agosto', 'Setembro', 'Outubro', 'Novembro', 'Dezembro'],
+      monthNamesShort: ['Jan', 'Fev', 'Mar', 'Abr', 'Mai', 'Jun', 'Jul', 'Ago', 'Set', 'Out', 'Nov', 'Dez'],
+      dayNames: ['Domingo', 'Segunda', 'Terça', 'Quarta', 'Quinta', 'Sexta', 'Sabádo'],
+      dayNamesShort: ['Dom', 'Seg', 'Ter', 'Qua', 'Qui', 'Sex', 'Sab'],
+      dayNamesMin: ['Dom', 'Seg', 'Ter', 'Qua', 'Qui', 'Sex', 'Sab'],
+      today: 'Hoje',
+      weekHeader: 'Semana',
+      emptyMessage: 'Nenhum resultado encontrado',
+      emptyFilterMessage: 'Nenhum registro encontrado com o filtro informado',
+      weak: 'Fraca',
+      medium: 'Média',
+      strong: 'Forte',
+      passwordPrompt: 'Informe a senha',
+      clear: 'Limpar',
+      apply: 'Aplicar'
+    });
+  }
+}

package/src/lib/api/modules/primeng.module.ts

@@ -0,0 +1,144 @@
+import { NgModule } from '@angular/core';
+
+import { AccordionModule } from 'primeng/accordion';
+import { AutoFocusModule } from 'primeng/autofocus';
+import { BadgeModule } from 'primeng/badge';
+import { BreadcrumbModule } from 'primeng/breadcrumb';
+import { ButtonModule } from 'primeng/button';
+import { CalendarModule } from 'primeng/calendar';
+import { CardModule } from 'primeng/card';
+import { CarouselModule } from 'primeng/carousel';
+import { ChartModule } from 'primeng/chart';
+import { CheckboxModule } from 'primeng/checkbox';
+import { ChipModule } from 'primeng/chip';
+import { ConfirmationService, MessageService } from 'primeng/api';
+import { ConfirmDialogModule } from 'primeng/confirmdialog';
+import { ContextMenuModule } from 'primeng/contextmenu';
+import { DataViewModule } from 'primeng/dataview';
+import { DialogModule } from 'primeng/dialog';
+import { DialogService, DynamicDialogRef, DynamicDialogConfig } from 'primeng/dynamicdialog';
+import { DividerModule } from 'primeng/divider';
+import { DropdownModule } from 'primeng/dropdown';
+import { DynamicDialogModule } from 'primeng/dynamicdialog';
+import { EditorModule } from 'primeng/editor';
+import { FieldsetModule } from 'primeng/fieldset';
+import { FileUploadModule } from 'primeng/fileupload';
+import { ImageModule } from 'primeng/image';
+import { InputMaskModule } from 'primeng/inputmask';
+import { InputNumberModule } from 'primeng/inputnumber';
+import { InputSwitchModule } from 'primeng/inputswitch';
+import { InputTextareaModule } from 'primeng/inputtextarea';
+import { InputTextModule } from 'primeng/inputtext';
+import { KnobModule } from 'primeng/knob';
+import { MenuModule } from 'primeng/menu';
+import { MessageModule } from 'primeng/message';
+import { MessagesModule } from 'primeng/messages';
+import { MultiSelectModule } from 'primeng/multiselect';
+import { OverlayModule } from 'primeng/overlay';
+import { OverlayPanelModule } from 'primeng/overlaypanel';
+import { PanelMenuModule } from 'primeng/panelmenu';
+import { PanelModule } from 'primeng/panel';
+import { PasswordModule } from 'primeng/password';
+import { PickListModule } from 'primeng/picklist';
+import { ProgressBarModule } from 'primeng/progressbar';
+import { RadioButtonModule } from 'primeng/radiobutton';
+import { RatingModule } from 'primeng/rating';
+import { RippleModule } from 'primeng/ripple';
+import { SidebarModule } from 'primeng/sidebar';
+import { SkeletonModule } from 'primeng/skeleton';
+import { SpeedDialModule } from 'primeng/speeddial';
+import { SplitButtonModule } from 'primeng/splitbutton';
+import { StepsModule } from 'primeng/steps'
+import { StyleClassModule } from 'primeng/styleclass';
+import { TableModule } from 'primeng/table';
+import { TabViewModule } from 'primeng/tabview';
+import { TagModule } from 'primeng/tag';
+import { ToastModule } from 'primeng/toast';
+import { ToolbarModule } from 'primeng/toolbar';
+import { TooltipModule } from 'primeng/tooltip';
+import { TreeModule } from 'primeng/tree';
+import { TreeTableModule } from 'primeng/treetable';
+import { SelectButtonModule } from 'primeng/selectbutton';
+import { StepperModule } from 'primeng/stepper';
+import { InputGroupModule } from 'primeng/inputgroup';
+import { InputGroupAddonModule } from 'primeng/inputgroupaddon';
+import { TreeSelectModule } from 'primeng/treeselect';
+import { TimelineModule } from 'primeng/timeline';
+import { SplitterModule } from 'primeng/splitter';
+
+@NgModule({
+  exports: [
+    AccordionModule,
+    AutoFocusModule,
+    BadgeModule,
+    BreadcrumbModule,
+    ButtonModule,
+    CalendarModule,
+    CardModule,
+    CarouselModule,
+    ChartModule,
+    CheckboxModule,
+    ChipModule,
+    ConfirmDialogModule,
+    ContextMenuModule,
+    DataViewModule,
+    DialogModule,
+    DividerModule,
+    DropdownModule,
+    DynamicDialogModule,
+    EditorModule,
+    FieldsetModule,
+    FileUploadModule,
+    ImageModule,
+    InputMaskModule,
+    InputNumberModule,
+    InputSwitchModule,
+    InputTextareaModule,
+    InputTextModule,
+    KnobModule,
+    MenuModule,
+    MessageModule,
+    MessagesModule,
+    MultiSelectModule,
+    OverlayModule,
+    OverlayPanelModule,
+    OverlayPanelModule,
+    PanelMenuModule,
+    PanelModule,
+    PasswordModule,
+    PickListModule,
+    ProgressBarModule,
+    RadioButtonModule,
+    RatingModule,
+    RippleModule,
+    SidebarModule,
+    SkeletonModule,
+    SpeedDialModule,
+    SplitButtonModule,
+    StepsModule,
+    StyleClassModule,
+    TableModule,
+    TabViewModule,
+    TagModule,
+    ToastModule,
+    ToolbarModule,
+    TooltipModule,
+    TreeModule,
+    TreeTableModule,
+    SelectButtonModule,
+    StepperModule,
+    InputGroupModule,
+    InputGroupAddonModule,
+    TreeSelectModule,
+    TimelineModule,
+    SplitterModule
+  ],
+  providers: [
+    ConfirmationService,
+    DialogService,
+    DynamicDialogRef,
+    DynamicDialogConfig,
+    MessageService,
+  ]
+})
+export class PrimeNgModule { }

package/src/lib/api/pipes/capitalize.pipe.ts

@@ -0,0 +1,47 @@
+import { Pipe, PipeTransform } from '@angular/core';
+
+@Pipe({
+  name: 'capitalize'
+})
+export class CapitalizePipe implements PipeTransform {
+
+  private prepositions = new Set<string>([
+    'de', 'da', 'do', 'em', 'no', 'na', 'para', 'por', 'com', 'a', 'o', 'e'
+  ]);
+  
+  private romanNumerals = new Set<string>([
+    'I', 'II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII', 'IX', 'X', 'XI', 'XII', 'XIII', 'XIV', 'XV', 
+    'XVI', 'XVII', 'XVIII', 'XIX', 'XX'
+  ]);
+  
+  private siglas = new Set<string>([
+    'UI', 'UX', 'TI'
+  ]);
+
+  transform(value: string): string {
+    if (!value) return value;
+
+    return value.split(' ').map((word, index) => {
+      const wordUpper = word.toUpperCase();
+      const wordLower = word.toLocaleLowerCase();
+  
+      // Verifica numerais romanos
+      if (this.romanNumerals.has(wordUpper)) {
+        return word;
+      }
+  
+      // Verifica siglas
+      if (this.siglas.has(wordUpper)) {
+        return word;
+      }
+  
+      // Verifica preposições, mas não altera a primeira palavra
+      if (index !== 0 && this.prepositions.has(wordLower)) {
+        return wordLower;
+      }
+  
+      // Capitaliza a primeira letra das demais palavras
+      return word.charAt(0).toLocaleUpperCase() + word.slice(1).toLocaleLowerCase();
+    }).join(' ');
+  }
+}

package/src/lib/api/pipes/cpfcnpj.pipe.ts

@@ -0,0 +1,21 @@
+import { Pipe, PipeTransform } from '@angular/core';
+
+@Pipe({ name: 'cpfCnpj' })
+export class CpfCnpjPipe implements PipeTransform {
+
+  transform(value: string) {
+    if (value) {
+
+      const identificacao = value.replace(/[^0-9]/g, '');
+
+      if (identificacao.length === 11) {
+        return identificacao.replace(/(\d{3})(\d{3})(\d{3})(\d{2})/g, "\$1.\$2.\$3\-\$4");
+      } else if (identificacao.length === 14) {
+        return identificacao.replace(/(\d{2})(\d{3})(\d{3})(\d{4})(\d{2})/g, "\$1.\$2.\$3\/\$4\-\$5");
+      }
+
+      return value;
+    }
+    else return null;
+  }
+}

package/src/lib/api/pipes/mask.pipe.ts

@@ -0,0 +1,24 @@
+import { Pipe, PipeTransform } from '@angular/core';
+
+@Pipe({
+  name: 'mask'
+})
+export class MaskPipe implements PipeTransform {
+  transform(value: string, mask: string): any {
+    if (!value) return '';
+
+    let i = 0;
+    let maskedValue = '';
+    for (let m of mask) {
+      if (m !== '9' && m !== 'X') {
+        maskedValue += m;
+        continue;
+      }
+
+      if (i >= value.length) break;
+
+      maskedValue += value[i++];
+    }
+    return maskedValue;
+  }
+}

package/src/lib/api/pipes/pipes.module.ts

@@ -0,0 +1,26 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+
+import { CpfCnpjPipe } from './cpfcnpj.pipe';
+import { MaskPipe } from './mask.pipe';
+import { TelefonePipe } from './telefone.pipe';
+import { CapitalizePipe } from './capitalize.pipe';
+
+@NgModule({
+  imports: [
+    CommonModule
+  ],
+  declarations: [
+    CpfCnpjPipe,
+    MaskPipe,
+    TelefonePipe,
+    CapitalizePipe
+  ],
+  exports: [
+    CpfCnpjPipe,
+    MaskPipe,
+    TelefonePipe,
+    CapitalizePipe
+  ]
+})
+export class PipesModule { }

package/src/lib/api/pipes/telefone.pipe.ts

@@ -0,0 +1,38 @@
+import { Pipe, PipeTransform } from '@angular/core';
+
+@Pipe({
+  name: 'Telefone'
+})
+export class TelefonePipe implements PipeTransform {
+
+  transform(tel: string) {
+    if (tel) {
+      const value = tel.toString().replace(/\D/g, '');
+
+      let foneFormatado = '';
+
+      if (value.length > 12) {
+        foneFormatado = value.replace(/(\d{2})?(\d{2})?(\d{5})?(\d{4})/, '+$1 ($2) $3-$4');
+
+      } else if (value.length > 11) {
+        foneFormatado = value.replace(/(\d{2})?(\d{2})?(\d{4})?(\d{4})/, '+$1 ($2) $3-$4');
+
+      } else if (value.length > 10) {
+        foneFormatado = value.replace(/(\d{2})?(\d{5})?(\d{4})/, '($1) $2-$3');
+
+      } else if (value.length > 9) {
+        foneFormatado = value.replace(/(\d{2})?(\d{4})?(\d{4})/, '($1) $2-$3');
+
+      } else if (value.length > 5) {
+        foneFormatado = value.replace(/^(\d{2})?(\d{4})?(\d{0,4})/, '($1) $2-$3');
+
+      } else if (value.length > 1) {
+        foneFormatado = value.replace(/^(\d{2})?(\d{0,5})/, '($1) $2');
+      } else {
+        if (tel !== '') { foneFormatado = value.replace(/^(\d*)/, '($1'); }
+      }
+      return foneFormatado;
+    }
+    else return null;
+  }
+}