@sapphire-ion/framework 1.3.6 → 1.3.8

package/src/lib/components/inputs/input-color/input-color.component.ts

@@ -1,544 +0,0 @@
-import { Component, ElementRef, forwardRef, ViewChild } from '@angular/core';
-import { CustomInput } from '../custom-input';
-import { Clipboard } from '@capacitor/clipboard';
-import { GenericService } from '../../../services/generic.service';
-import { SIonPopoverComponent } from '../../popover/sion-popover/sion-popover.component';
-import { MaskitoMaskExpression, MaskitoOptions } from '@maskito/core';
-import { InputProviderFactory } from '../input-provider-factory';
-
-type RGB = { r: number, g: number, b: number };
-type HSL = { h: number, l: number, s: number };
-
-@Component({
-  selector: 'input-color',
-  templateUrl: './input-color.component.html',
-  styleUrls: ['./input-color.component.scss', '../inputs.scss'],
-  providers: [
-    ...InputProviderFactory.GetProviders(InputColorComponent),
-    { provide: CustomInput, useExisting: forwardRef(() => InputColorComponent) },
-  ],
-})
-export class InputColorComponent extends CustomInput<string> {
-  
-  // configuration: InputSignal<InputStringConfiguration> = input<InputStringConfiguration>(new InputStringConfiguration());
-
-  @ViewChild('input') input: ElementRef<HTMLInputElement>;
-  @ViewChild('inputContainer') inputContainer: ElementRef<HTMLDivElement>;
-  override setFocus(event: MouseEvent | null): void {
-    if(this.input && (event == null || event.target == this.inputContainer.nativeElement)) { this.input.nativeElement.focus(); }      
-  }
-
-  constructor(
-    private genericService: GenericService
-  ) { super(); this.value.set(""); }
-
-
-  @ViewChild(SIonPopoverComponent) popover: SIonPopoverComponent;
-
-  rgbColor : RGB = { r: 255, g: 0, b: 0 };
-  hslColor : HSL = { h: 0, s: 100, l: 50 };
-  alpha    : number = 100
-  override writeValue(obj: string): void | Promise<void> {
-    this.value.set(obj);
-    this.runValidation();
-  }
-
-  override SetValue(value: string): void {
-    this.value.set(value);
-    this.runValidation();
-    this.propagateChange(value);
-  }
-
-  rendering: boolean = false;
-  async Present(event: MouseEvent): Promise<void> {
-    this.rendering = true;
-    await this.popover.present(event);
-    this.InitializeGradient()
-    this.InitializeHueSlider()
-    this.InitializeAlphaSlider()
-    this.DrawColorGradient()
-    this.DrawHueSlider()
-    this.DrawAlphaSlider()
-    this.rendering = false;
-  }
-
-  //#region [ Gradient ]
-  indicatorX: number = 100
-  indicatorY: number = 0
-
-  @ViewChild('gradient'     ) gradient: ElementRef<HTMLCanvasElement>;
-  private isGradientDragging: boolean = false;
-  private gradientCtx: CanvasRenderingContext2D;
-  private gradientWidth: number = 0;
-  private gradientHeight: number = 0;
-  InitializeGradient(): void {
-    const gradient      = this.gradient.nativeElement;
-    this.gradientWidth  = gradient.width; 
-    this.gradientHeight = gradient.height; 
-    this.gradientCtx    = gradient.getContext('2d');
-
-    gradient.addEventListener('mousedown' , this.StartGradientDrag.bind(this));
-    gradient.addEventListener('mousemove' , this.GradientDrag.bind(this));
-    gradient.addEventListener('mouseup'   , this.EndGradientDrag.bind(this));
-    gradient.addEventListener('mouseleave', this.EndGradientDrag.bind(this));
-
-    // Touch events
-    gradient.addEventListener('touchstart', this.HandleGradientTouch.bind(this));
-    gradient.addEventListener('touchmove' , this.HandleGradientTouch.bind(this));
-    gradient.addEventListener('touchend'  , this.EndGradientDrag.bind(this));
-  }
-  StartGradientDrag(e: MouseEvent): void {
-    this.isGradientDragging = true
-    this.HandleColorSelection(e.offsetX, e.offsetY)
-  }
-  GradientDrag(e: MouseEvent): void {
-    if (this.isGradientDragging) {
-      this.HandleColorSelection(e.offsetX, e.offsetY)
-    }
-  }
-  EndGradientDrag(): void {
-    this.isGradientDragging = false
-  }
-  HandleGradientTouch(e: TouchEvent): void {
-    e.preventDefault()
-    if (e.type === "touchstart") {
-      this.isGradientDragging = true
-    }
-
-    if (this.isGradientDragging) {
-      const rect = this.gradient.nativeElement.getBoundingClientRect()
-      const touch = e.touches[0]
-      const x = touch.clientX - rect.left
-      const y = touch.clientY - rect.top
-      this.HandleColorSelection(x, y)
-    }
-  }
-
-  HandleColorSelection(x: number, y: number): void {
-    // Constrain coordinates to canvas bounds
-    x = Math.max(0, Math.min(x, this.gradientWidth))
-    y = Math.max(0, Math.min(y, this.gradientHeight))
-
-    // Store the raw position percentage for the indicator
-    this.indicatorX = (x / this.gradientWidth) * 100
-    this.indicatorY = (y / this.gradientHeight) * 100
-
-    // Calculate saturation and lightness based on position
-    this.hslColor.s = Math.round(this.indicatorX)
-    // Adjust lightness calculation:
-    // - Top of canvas (y=0) should be white (lightness=100) on the left and pure color (lightness=50) on the right
-    // - Bottom of canvas (y=height) should be black (lightness=0)
-    if (this.hslColor.s === 0) {
-      // Left edge is always white to black, regardless of y position
-      this.hslColor.l = Math.round(100 - this.indicatorY)
-    } else {
-      // For other saturation values, top is 50-100% lightness (based on saturation), bottom is 0%
-      const maxLightness = 100 - this.hslColor.s / 2
-      this.hslColor.l = Math.round(maxLightness - (this.indicatorY / 100) * maxLightness)
-    }
-
-    // Update selected color
-    this.UpdateSelectedColor(this.hslColor.s, this.hslColor.l, true)
-
-    // Redraw alpha slider with new color
-    this.DrawAlphaSlider()
-  }
-  //#endregion [ Gradient ]
-  
-  UpdateSelectedColor(saturation: number | null = null, lightness: number | null = null, emitChanges: boolean = false): void {
-    // Update HSL values
-    if(saturation != null){
-      this.hslColor.s = saturation
-    }
-    if(lightness != null){
-      this.hslColor.l = lightness
-    }
-    // Convert HSL to RGB
-    const rgb = HSLToRGB(this.hslColor);
-
-    this.rgbColor = rgb
-
-    // Convert RGB to HEX
-    const hex = RGBToHex(rgb, this.alpha / 100);
-    if(emitChanges){ 
-      this.SetValue(hex);
-    } else { 
-      this.value.set(hex);
-    }
-  }
-
-  //#region [ Hue Slider ]
-  @ViewChild("hueSlider"  ) hueSlider: ElementRef<HTMLCanvasElement>
-  private isHueDragging: boolean = false;
-  private hueCtx: CanvasRenderingContext2D;
-  private hueSliderWidth: number = 0;
-  private hueSliderHeight: number = 0;
-  InitializeHueSlider(): void {
-    const hueSlider      = this.hueSlider.nativeElement
-    this.hueSliderWidth  = hueSlider.width;
-    this.hueSliderHeight = hueSlider.height;
-    this.hueCtx = hueSlider.getContext("2d")
-
-    hueSlider.addEventListener("mousedown" , this.StartHueDrag.bind(this))
-    hueSlider.addEventListener("mousemove" , this.HueDrag.bind(this))
-    hueSlider.addEventListener("mouseup"   , this.EndHueDrag.bind(this))
-    hueSlider.addEventListener("mouseleave", this.EndHueDrag.bind(this))
-
-    // Touch events
-    hueSlider.addEventListener("touchstart", this.HandleHueTouch.bind(this))
-    hueSlider.addEventListener("touchmove" , this.HandleHueTouch.bind(this))
-    hueSlider.addEventListener("touchend"  , this.EndHueDrag.bind(this))
-  }
-
-  StartHueDrag(e: MouseEvent): void {
-    this.isHueDragging = true
-    this.HandleHueSelection(e.offsetX)
-  }
-
-  HueDrag(e: MouseEvent): void {
-    if (this.isHueDragging) {
-      this.HandleHueSelection(e.offsetX)
-    }
-  }
-
-  EndHueDrag(): void {
-    this.isHueDragging = false
-  }
-  HandleHueTouch(e: TouchEvent): void {
-    e.preventDefault()
-    if (e.type === "touchstart") {
-      this.isHueDragging = true
-    }
-
-    if (this.isHueDragging) {
-      const rect = this.hueSlider.nativeElement.getBoundingClientRect()
-      const touch = e.touches[0]
-      const x = touch.clientX - rect.left
-      this.HandleHueSelection(x)
-    }
-  }
-  HandleHueSelection(x: number): void {
-    // Constrain x to canvas bounds
-    x = Math.max(0, Math.min(x, this.hueSliderWidth))
-
-    // Calculate hue based on x position (0-360)
-    this.hslColor.h = Math.round((x / this.hueSliderWidth) * 360)
-
-    // Redraw color gradient with new hue
-    this.DrawColorGradient()
-
-    // Redraw alpha slider with new color
-    this.DrawAlphaSlider()
-
-    // Update selected color
-    this.UpdateSelectedColor(this.hslColor.s, this.hslColor.l, true)
-  }
-  //#endregion [ Hue Slider ]
-
-  //#region [ Alpha Slider ]
-  @ViewChild("alphaSlider") alphaSlider: ElementRef<HTMLCanvasElement>
-  private isAlphaDragging: boolean = false;
-  private alphaCtx: CanvasRenderingContext2D;
-  private alphaSliderWidth: number = 0;
-  private alphaSliderHeight: number = 0;
-  InitializeAlphaSlider(): void {
-    const alphaSlider      = this.alphaSlider.nativeElement;
-    this.alphaSliderHeight = alphaSlider.height;
-    this.alphaSliderWidth  = alphaSlider.width;
-
-    this.alphaCtx = alphaSlider.getContext("2d")
-
-    alphaSlider.addEventListener("mousedown" , this.StartAlphaDrag.bind(this))
-    alphaSlider.addEventListener("mousemove" , this.AlphaDrag.bind(this))
-    alphaSlider.addEventListener("mouseup"   , this.EndAlphaDrag.bind(this))
-    alphaSlider.addEventListener("mouseleave", this.EndAlphaDrag.bind(this))
-
-    // Touch events
-    alphaSlider.addEventListener("touchstart", this.HandleAlphaTouch.bind(this))
-    alphaSlider.addEventListener("touchmove" , this.HandleAlphaTouch.bind(this))
-    alphaSlider.addEventListener("touchend"  , this.EndAlphaDrag.bind(this))
-  }
-  StartAlphaDrag(e: MouseEvent): void {
-    this.isAlphaDragging = true
-    this.HandleAlphaSelection(e.offsetX)
-  }
-
-  AlphaDrag(e: MouseEvent): void {
-    if (this.isAlphaDragging) {
-      this.HandleAlphaSelection(e.offsetX)
-    }
-  }
-
-  EndAlphaDrag(): void {
-    this.isAlphaDragging = false
-  }
-
-  HandleAlphaTouch(e: TouchEvent): void {
-    e.preventDefault()
-    if (e.type === "touchstart") {
-      this.isAlphaDragging = true
-    }
-
-    if (this.isAlphaDragging) {
-      const rect = this.alphaSlider.nativeElement.getBoundingClientRect()
-      const touch = e.touches[0]
-      const x = touch.clientX - rect.left
-      this.HandleAlphaSelection(x)
-    }
-  }
-
-  HandleAlphaSelection(x: number): void {
-    // Constrain x to canvas bounds
-    x = Math.max(0, Math.min(x, this.alphaSliderWidth))
-
-    // Calculate alpha based on x position (0-100)
-    this.alpha = Math.round((x / this.alphaSliderWidth) * 100)
-
-    // Update selected color
-    this.UpdateSelectedColor(this.hslColor.s, this.hslColor.l, true)
-  }
-  //#endregion [ Alpha Slider ]
-
-  SetColorFromHex(hexColor: string, updateCanvas: boolean = true, emitChanges: boolean = false): void {
-    // Remove # if present
-    hexColor = hexColor.replace(/^#/, "")
-
-    let r: number, g: number, b: number, a = 1
-
-    // Parse hex values based on string length
-    if (hexColor.length === 3) {
-      // Short hex (#RGB)
-      r = Number.parseInt(hexColor.charAt(0) + hexColor.charAt(0), 16)
-      g = Number.parseInt(hexColor.charAt(1) + hexColor.charAt(1), 16)
-      b = Number.parseInt(hexColor.charAt(2) + hexColor.charAt(2), 16)
-    } else 
-    if (hexColor.length === 6) {
-      // Standard hex (#RRGGBB)
-      r = Number.parseInt(hexColor.substring(0, 2), 16)
-      g = Number.parseInt(hexColor.substring(2, 4), 16)
-      b = Number.parseInt(hexColor.substring(4, 6), 16)
-    } else 
-    if (hexColor.length === 8) {
-      // Hex with alpha (#RRGGBBAA)
-      r = Number.parseInt(hexColor.substring(0, 2), 16)
-      g = Number.parseInt(hexColor.substring(2, 4), 16)
-      b = Number.parseInt(hexColor.substring(4, 6), 16)
-      a = Number.parseInt(hexColor.substring(6, 8), 16) / 255
-    } else {
-      // Invalid hex, use default
-      console.error("Invalid hex color format")
-      return;
-    }
-
-    // Update RGB color
-    this.rgbColor = { r, g, b }
-
-    // Convert RGB to HSL
-    this.hslColor = RGBToHSL(this.rgbColor)
-
-    // Update alpha
-    this.alpha = Math.round(a * 100)
-
-    // Update selected color
-    const hex = RGBToHex(this.rgbColor, a)
-    if(emitChanges){ 
-      this.SetValue(hex);
-    } else { 
-      this.value.set(hex);
-    }
-
-    if(updateCanvas){
-      // Calculate indicator position
-      this.UpdateIndicatorPositions()
-  
-      // Redraw components
-      this.DrawColorGradient()
-      this.DrawAlphaSlider()
-    }
-    
-  }
-
-  DrawColorGradient(): void {
-    const ctx = this.gradientCtx;
-
-    // Clear canvas
-    ctx.clearRect(0, 0, this.gradientWidth, this.gradientHeight)
-
-    // Draw the pure hue color at the top-right corner
-    ctx.fillStyle = `hsl(${this.hslColor.h}, 100%, 50%)`
-    ctx.fillRect(0, 0, this.gradientWidth, this.gradientHeight)
-
-    // White gradient (horizontal - saturation)
-    const whiteGradient = ctx.createLinearGradient(0, 0, this.gradientWidth, 0)
-    whiteGradient.addColorStop(0, "white")
-    whiteGradient.addColorStop(1, "rgba(255, 255, 255, 0)")
-    ctx.fillStyle = whiteGradient
-    ctx.fillRect(0, 0, this.gradientWidth, this.gradientHeight)
-
-    // Black gradient (vertical - brightness)
-    const blackGradient = ctx.createLinearGradient(0, 0, 0, this.gradientHeight)
-    blackGradient.addColorStop(0, "rgba(0, 0, 0, 0)")
-    blackGradient.addColorStop(1, "black")
-    ctx.fillStyle = blackGradient
-    ctx.fillRect(0, 0, this.gradientWidth, this.gradientHeight)
-  }
-
-  DrawHueSlider(): void {
-    const ctx = this.hueCtx
-
-    // Create hue gradient
-    const gradient = ctx.createLinearGradient(0, 0, this.hueSliderWidth, 0)
-    for (let i = 0; i <= 360; i += 60) {
-      gradient.addColorStop(i / 360, `hsl(${i}, 100%, 50%)`)
-    }
-
-    ctx.fillStyle = gradient
-    ctx.fillRect(0, 0, this.hueSliderWidth, this.hueSliderHeight)
-  }
-
-  DrawAlphaSlider(): void {
-    const ctx = this.alphaCtx
-    const width  = this.alphaSliderWidth
-    const height = this.alphaSliderHeight
-
-    // Clear canvas
-    ctx.clearRect(0, 0, width, height)
-
-    // Create checkerboard pattern for transparency
-    const squareSize = 8
-    for (let i = 0; i < width; i += squareSize) {
-      for (let j = 0; j < height; j += squareSize) {
-        const isEven = (i / squareSize + j / squareSize) % 2 === 0
-        ctx.fillStyle = isEven ? "#ffffff" : "#cccccc"
-        ctx.fillRect(i, j, squareSize, squareSize)
-      }
-    }
-    
-
-    // Create alpha gradient
-    const gradient = ctx.createLinearGradient(0, 0, width, 0)
-    const rgb = HSLToRGB(this.hslColor);
-
-    gradient.addColorStop(0, `rgba(${rgb.r}, ${rgb.g}, ${rgb.b}, 0)`)
-    gradient.addColorStop(1, `rgba(${rgb.r}, ${rgb.g}, ${rgb.b}, 1)`)
-
-    ctx.fillStyle = gradient
-    ctx.fillRect(0, 0, width, height)
-  }
-
-  async CopyToClipboard() {
-    await Clipboard.write({
-      string: this.value()
-    });
-    await this.genericService.PresentToastSuccess(`${this.value()} copiada para a área de transferência!`);
-  }
-
-  UpdateIndicatorPositions(): void {
-    // Set X position directly from saturation (0-100)
-    this.indicatorX = this.hslColor.s;
-
-    // Calculate Y position using the inverse of the HandleColorSelection logic
-    if (this.hslColor.s === 0) {
-      // Left edge: simple white to black mapping
-      this.indicatorY = 100 - this.hslColor.l;
-    } else {
-      // For other saturation values, we need to reverse the maxLightness calculation
-      const maxLightness = 100 - this.hslColor.s / 2;
-      this.indicatorY = ((maxLightness - this.hslColor.l) / maxLightness) * 100;
-    }
-    
-    // Ensure the position stays within bounds
-    this.indicatorY = Math.max(0, Math.min(100, this.indicatorY));
-  }
-
-  HEXMask: MaskitoOptions = { mask: HEXMask };
-}
-
-function HSLToRGB(hsl: HSL): RGB {
-  var h = hsl.h / 360;
-  var s = hsl.s / 100;
-  var l = hsl.l / 100;
-
-  let r: number, g: number, b: number
-
-  if (s === 0) {
-    r = g = b = l // achromatic
-  } else {
-    const q = l < 0.5 ? l * (1 + s) : l + s - l * s
-    const p = 2 * l - q
-
-    r = HUEtoRGB(p, q, h + 1 / 3)
-    g = HUEtoRGB(p, q, h)
-    b = HUEtoRGB(p, q, h - 1 / 3)
-  }
-
-  return {
-    r: Math.round(r * 255),
-    g: Math.round(g * 255),
-    b: Math.round(b * 255),
-  }
-}
-function HUEtoRGB(p: number, q: number, t: number): number {
-  if (t < 0) t += 1
-  if (t > 1) t -= 1
-  if (t < 1 / 6) return p + (q - p) * 6 * t
-  if (t < 1 / 2) return q
-  if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6
-  return p
-}
-
-function RGBToHSL(rgb: RGB): HSL {
-  var r = rgb.r / 255
-  var g = rgb.g / 255
-  var b = rgb.b / 255
-
-  const max = Math.max(r, g, b)
-  const min = Math.min(r, g, b)
-  let h = 0,
-    s = 0
-  const l = (max + min) / 2
-
-  if (max !== min) {
-    const d = max - min
-    s = l > 0.5 ? d / (2 - max - min) : d / (max + min)
-
-    switch (max) {
-      case r:
-        h = ((g - b) / d + (g < b ? 6 : 0)) / 6
-        break
-      case g:
-        h = ((b - r) / d + 2) / 6
-        break
-      case b:
-        h = ((r - g) / d + 4) / 6
-        break
-    }
-  }
-
-  return {
-    h: Math.round(h * 360),
-    s: Math.round(s * 100),
-    l: Math.round(l * 100),
-  }
-}
-
-function RGBToHex(rgb: RGB, alpha = 1): string {
-  let { r, g, b } = rgb
-
-  const alphaHex = Math.round(alpha * 255)
-    .toString(16)
-    .padStart(2, "0")
-  return (
-    "#" +
-    [r, g, b]
-      .map((x) => {
-        const hex = x.toString(16)
-        return hex.length === 1 ? "0" + hex : hex
-      })
-      .join("") +
-    (alpha < 1 ? alphaHex : "")
-  ).toUpperCase();
-}
-
-const HEXDigitRegex: RegExp = /[0-9a-f]+/i;
-const HEXMask: MaskitoMaskExpression = [ '#', HEXDigitRegex, HEXDigitRegex, HEXDigitRegex, HEXDigitRegex, HEXDigitRegex, HEXDigitRegex, HEXDigitRegex ];

package/src/lib/components/inputs/input-cpf-cnpj/input-cpf-cnpj.component.html

@@ -1,28 +0,0 @@
-<div 
-  #inputContainer
-  class="input-container" 
-  (click)="setFocus($event)"
-  [class.required]="required()" 
-  [class.submitted]="submitted()" 
-  [class.invalid]="invalid" 
-  [class.disabled]="disabled() || loading()"
-  [class.loading]="loading()"
->
-  <div class="input-label"> 
-    <span class="truncate">
-      {{label()}} 
-    </span>
-  </div>
-  <input #input
-    [ngModel]="value()" 
-    [maskito]="mask"
-    inputmode="numeric"
-    [type]="'text'" 
-    (ngModelChange)="SetValue($event)"
-    [disabled]="disabled() || loading()"
-    (blur)="blur.emit($event)"
-  />
-  <div class="loading-container" [class.loading]="loading()">
-    <ion-spinner></ion-spinner>
-  </div>
-</div>

package/src/lib/components/inputs/input-cpf-cnpj/input-cpf-cnpj.component.ts

@@ -1,99 +0,0 @@
-import { Component, ElementRef, forwardRef, model, ModelSignal, ViewChild } from '@angular/core';
-import { MaskitoMaskExpression, MaskitoOptions, maskitoTransform } from '@maskito/core';
-import { CustomInput } from '../custom-input';
-import { InputCpfCnpjConfiguration } from './input-cpf-cnpj.configuration';
-import { InputProviderFactory } from '../input-provider-factory';
-
-@Component({
-  selector: 'input-cpf-cnpj, input-cpf, input-cnpj',
-  templateUrl: './input-cpf-cnpj.component.html',
-  styleUrls: ['./input-cpf-cnpj.component.scss', '../inputs.scss'],
-  providers: [
-    ...InputProviderFactory.GetProviders(InputCpfCnpjComponent),
-    { provide: CustomInput, useExisting: forwardRef(() => InputCpfCnpjComponent) },
-  ],
-})
-export class InputCpfCnpjComponent extends CustomInput<string> {
-
-  configuration: ModelSignal<InputCpfCnpjConfiguration> = model<InputCpfCnpjConfiguration>(new InputCpfCnpjConfiguration());
-
-  @ViewChild('input') input: ElementRef<HTMLInputElement>;
-  @ViewChild('inputContainer') inputContainer: ElementRef<HTMLDivElement>;
-  override setFocus(event: MouseEvent | null): void {
-    if(this.input && (event == null || event.target == this.inputContainer.nativeElement)) { this.input.nativeElement.focus(); }      
-  }
-
-  constructor(
-    protected override elementRef: ElementRef<HTMLInputElement>
-  ) { 
-    super(); 
-    if(this.elementRef.nativeElement.tagName.toLowerCase() == 'input-cpf-cnpj'){
-      this.configuration.set(new InputCpfCnpjConfiguration());
-    }else{
-      const selector: string = this.elementRef.nativeElement.tagName.toLowerCase().split('-')[1];
-      if(selector == 'cpf' ){ this.configuration.set(new InputCpfCnpjConfiguration('CPF'))  } else
-      if(selector == 'cnpj'){ this.configuration.set(new InputCpfCnpjConfiguration('CNPJ')) } 
-    }
-  }
-
-  override writeValue(obj: string): void | Promise<void> {
-    this.value.set(obj);
-    this.runValidation();
-  }
-  
-  override SetValue(obj: string): void {
-    this.value.set(obj);
-    this.runValidation();
-    this.propagateChange(obj.replaceAll('.', '').replaceAll('-', '').replaceAll('/', ''));
-  }
-
-
-  readonly mask: MaskitoOptions = {
-    mask: (elementState) => {
-      if(this.configuration().type == 'CPFCNPJ'){
-        if(!elementState.value){ 
-          return cpfMask;
-        }else{
-          if(elementState.value.includes('.')){
-            if(elementState.value.length <= 14) { 
-              return cpfMask; 
-            }
-            return cnpjMask;
-          }else{
-            if(elementState.value.length <= 11) { 
-              return cpfMask; 
-            }
-            return cnpjMask;
-          }
-        }
-      }
-      if(this.configuration().type == 'CNPJ'){ return cnpjMask; }
-      if(this.configuration().type == 'CPF' ){ return cpfMask;  }
-    },
-  };
-}
-
-const cpfMask : MaskitoMaskExpression = [ /\d/, /\d/, /\d/, '.', /\d/, /\d/, /\d/, '.', /\d/, /\d/, /\d/, '-', /\d/, /\d/  ];
-const cnpjMask: MaskitoMaskExpression = [ /\d/, /\d/, '.', /\d/, /\d/, /\d/, '.', /\d/, /\d/, /\d/, '/', /\d/, /\d/, /\d/, /\d/, '-', /\d/, /\d/];
-const cpfCnpjMask: MaskitoOptions = {
-  mask: (elementState) => {
-    if(!elementState.value){ 
-      return cpfMask;
-    }else{
-      if(elementState.value.includes('.')){
-        if(elementState.value.length <= 14) { 
-          return cpfMask; 
-        }
-        return cnpjMask;
-      }else{
-        if(elementState.value.length <= 11) { 
-          return cpfMask; 
-        }
-        return cnpjMask;
-      }
-    }
-  }
-}
-export function FormatCpfCnpj(value: string): string {
-  return maskitoTransform(value, cpfCnpjMask);
-}

package/src/lib/components/inputs/input-cpf-cnpj/input-cpf-cnpj.configuration.ts

@@ -1,4 +0,0 @@
-export type CPFCnpj = 'CPF' | 'CNPJ' | 'CPFCNPJ'
-export class InputCpfCnpjConfiguration {
-  constructor(public type: CPFCnpj = 'CPFCNPJ'){}
-}