matcha-components 18.0.47 → 18.2.0

package/esm2022/lib/matcha-tooltip/tooltip/tooltip.component.mjs

@@ -0,0 +1,198 @@
+import { Component, HostListener, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+export class MatchaTooltipComponent {
+    constructor(el, renderer) {
+        this.el = el;
+        this.renderer = renderer;
+        this.tooltipText = '';
+        this.tooltipDisabled = false;
+        // Inputs para displayência de posição (true = displayência ativa)
+        this.displayAbove = false;
+        this.displayBelow = false;
+        this.displayLeft = false;
+        this.displayRight = false;
+        // Input para exibir botão de fechar (útil para mobile)
+        this.tooltipEnableClose = false;
+        this.tooltipElement = null;
+        this.documentClickListener = null;
+    }
+    // Para desktop: usamos mouseenter se não estivermos no modo "close-enabled"
+    onMouseEnter() {
+        if (this.tooltipEnableClose) {
+            // Se estiver em modo de clique/tap para mobile, não abre via hover.
+            return;
+        }
+        if (this.tooltipDisabled || this.tooltipElement || !this.tooltipText) {
+            return;
+        }
+        this.createTooltip();
+    }
+    // Em modo desktop, fecha ao sair do hover, exceto se tooltipEnableClose for true
+    onMouseLeave() {
+        if (!this.tooltipEnableClose && this.tooltipElement) {
+            this.destroyTooltip();
+        }
+    }
+    // Para mobile ou quando tooltipEnableClose está ativo, abrimos o tooltip com clique/tap
+    onClick(event) {
+        if (!this.tooltipEnableClose) {
+            // Se não estiver no modo de fechar com clique, ignora o click
+            return;
+        }
+        event.stopPropagation();
+        // Se o tooltip já estiver aberto, não faz nada (ou pode implementar toggle)
+        if (!this.tooltipElement && !this.tooltipDisabled && this.tooltipText) {
+            this.createTooltip();
+        }
+    }
+    createTooltip() {
+        // Cria o tooltip e adiciona a classe base
+        this.tooltipElement = this.renderer.createElement('div');
+        this.renderer.addClass(this.tooltipElement, 'matcha-tooltip-content');
+        // Define o texto do tooltip (aqui não usamos innerHTML, permitindo que o botão seja inserido depois)
+        this.tooltipElement.textContent = this.tooltipText;
+        // Define estilos iniciais para posicionamento e medição
+        this.renderer.setStyle(this.tooltipElement, 'position', 'absolute');
+        this.renderer.setStyle(this.tooltipElement, 'top', '0');
+        this.renderer.setStyle(this.tooltipElement, 'left', '0');
+        this.renderer.setStyle(this.tooltipElement, 'visibility', 'hidden');
+        this.renderer.appendChild(document.body, this.tooltipElement);
+        // Se tooltipEnableClose estiver true, adiciona o botão de fechar
+        if (this.tooltipEnableClose) {
+            const closeButton = this.renderer.createElement('div');
+            this.renderer.addClass(closeButton, 'matcha-tooltip-close');
+            // O botão de fechar fica dentro do tooltip
+            this.renderer.appendChild(this.tooltipElement, closeButton);
+            // Ao clicar no botão X, fecha o tooltip
+            this.renderer.listen(closeButton, 'click', (e) => {
+                e.stopPropagation();
+                this.destroyTooltip();
+            });
+            // Adiciona listener global para fechar o tooltip quando clicar fora dele
+            this.documentClickListener = this.renderer.listen('document', 'click', (e) => {
+                if (this.tooltipElement && !this.tooltipElement.contains(e.target)) {
+                    this.destroyTooltip();
+                }
+            });
+        }
+        // Medidas para posicionamento
+        const margin = 8;
+        const hostRect = this.el.nativeElement.getBoundingClientRect();
+        const tooltipRect = this.tooltipElement.getBoundingClientRect();
+        // Verifica se há espaço suficiente para cada posição
+        const hasSpaceAbove = hostRect.top >= tooltipRect.height + margin;
+        const hasSpaceBelow = (window.innerHeight - hostRect.bottom) >= tooltipRect.height + margin;
+        const hasSpaceLeft = hostRect.left >= tooltipRect.width + margin;
+        const hasSpaceRight = (window.innerWidth - hostRect.right) >= tooltipRect.width + margin;
+        // Determina a posição desejada com base na displayência do usuário e disponibilidade
+        let chosenPosition = 'above';
+        if (this.displayAbove && hasSpaceAbove) {
+            chosenPosition = 'above';
+        }
+        else if (this.displayBelow && hasSpaceBelow) {
+            chosenPosition = 'below';
+        }
+        else if (this.displayLeft && hasSpaceLeft) {
+            chosenPosition = 'left';
+        }
+        else if (this.displayRight && hasSpaceRight) {
+            chosenPosition = 'right';
+        }
+        else {
+            chosenPosition = hasSpaceAbove ? 'above' : (hasSpaceBelow ? 'below' : 'above');
+        }
+        // Calcula a posição (top e left) de acordo com a posição escolhida
+        let top = 0;
+        let left = 0;
+        switch (chosenPosition) {
+            case 'above':
+                top = hostRect.top + window.scrollY - tooltipRect.height - margin;
+                left = hostRect.left + window.scrollX + (hostRect.width - tooltipRect.width) / 2;
+                break;
+            case 'below':
+                top = hostRect.bottom + window.scrollY + margin;
+                left = hostRect.left + window.scrollX + (hostRect.width - tooltipRect.width) / 2;
+                break;
+            case 'left':
+                top = hostRect.top + window.scrollY + (hostRect.height - tooltipRect.height) / 2;
+                left = hostRect.left + window.scrollX - tooltipRect.width - margin;
+                break;
+            case 'right':
+                top = hostRect.top + window.scrollY + (hostRect.height - tooltipRect.height) / 2;
+                left = hostRect.right + window.scrollX + margin;
+                break;
+        }
+        // Ajusta horizontalmente para não ultrapassar os limites da tela
+        if (left < margin) {
+            left = margin;
+        }
+        else if (left + tooltipRect.width > window.innerWidth - margin) {
+            left = window.innerWidth - tooltipRect.width - margin;
+        }
+        // Aplica os estilos calculados e torna o tooltip visível
+        this.renderer.setStyle(this.tooltipElement, 'top', `${top}px`);
+        this.renderer.setStyle(this.tooltipElement, 'left', `${left}px`);
+        this.renderer.setStyle(this.tooltipElement, 'visibility', 'visible');
+        // Adiciona classes específicas para customizar a seta de acordo com a posição
+        this.renderer.removeClass(this.tooltipElement, 'matcha-tooltip-content_below');
+        this.renderer.removeClass(this.tooltipElement, 'matcha-tooltip-content_left');
+        this.renderer.removeClass(this.tooltipElement, 'matcha-tooltip-content_right');
+        if (chosenPosition === 'below') {
+            this.renderer.addClass(this.tooltipElement, 'matcha-tooltip-content_below');
+        }
+        else if (chosenPosition === 'left') {
+            this.renderer.addClass(this.tooltipElement, 'matcha-tooltip-content_left');
+        }
+        else if (chosenPosition === 'right') {
+            this.renderer.addClass(this.tooltipElement, 'matcha-tooltip-content_right');
+        }
+        // Para a posição 'above', mantém o estilo padrão
+    }
+    destroyTooltip() {
+        if (this.tooltipElement) {
+            this.renderer.removeChild(document.body, this.tooltipElement);
+            this.tooltipElement = null;
+        }
+        if (this.documentClickListener) {
+            this.documentClickListener(); // Remove o listener global
+            this.documentClickListener = null;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MatchaTooltipComponent, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: MatchaTooltipComponent, selector: "matcha-tooltip", inputs: { tooltipText: ["matcha-tooltip", "tooltipText"], tooltipDisabled: ["tooltip-disabled", "tooltipDisabled"], displayAbove: ["display-above", "displayAbove"], displayBelow: ["display-below", "displayBelow"], displayLeft: ["display-left", "displayLeft"], displayRight: ["display-right", "displayRight"], tooltipEnableClose: ["tooltip-enable-close", "tooltipEnableClose"] }, host: { listeners: { "mouseenter": "onMouseEnter()", "mouseleave": "onMouseLeave()", "click": "onClick($event)" } }, ngImport: i0, template: "<ng-content></ng-content>\n", styles: [""] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MatchaTooltipComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'matcha-tooltip', template: "<ng-content></ng-content>\n" }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }], propDecorators: { tooltipText: [{
+                type: Input,
+                args: ['matcha-tooltip']
+            }], tooltipDisabled: [{
+                type: Input,
+                args: ['tooltip-disabled']
+            }], displayAbove: [{
+                type: Input,
+                args: ['display-above']
+            }], displayBelow: [{
+                type: Input,
+                args: ['display-below']
+            }], displayLeft: [{
+                type: Input,
+                args: ['display-left']
+            }], displayRight: [{
+                type: Input,
+                args: ['display-right']
+            }], tooltipEnableClose: [{
+                type: Input,
+                args: ['tooltip-enable-close']
+            }], onMouseEnter: [{
+                type: HostListener,
+                args: ['mouseenter']
+            }], onMouseLeave: [{
+                type: HostListener,
+                args: ['mouseleave']
+            }], onClick: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tooltip.component.js","sourceRoot":"","sources":["../../../../../../projects/matcha-components/src/lib/matcha-tooltip/tooltip/tooltip.component.ts","../../../../../../projects/matcha-components/src/lib/matcha-tooltip/tooltip/tooltip.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, ElementRef, HostListener, Input, Renderer2 } from '@angular/core';\n\n@Component({\n  selector: 'matcha-tooltip', // Usado como atributo\n  templateUrl: './tooltip.component.html',\n  styleUrls: ['./tooltip.component.scss']\n})\nexport class MatchaTooltipComponent {\n  @Input('matcha-tooltip') tooltipText: string = '';\n  @Input('tooltip-disabled') tooltipDisabled: boolean = false;\n\n  // Inputs para displayência de posição (true = displayência ativa)\n  @Input('display-above') displayAbove: boolean = false;\n  @Input('display-below') displayBelow: boolean = false;\n  @Input('display-left') displayLeft: boolean = false;\n  @Input('display-right') displayRight: boolean = false;\n\n  // Input para exibir botão de fechar (útil para mobile)\n  @Input('tooltip-enable-close') tooltipEnableClose: boolean = false;\n\n  private tooltipElement: HTMLElement | null = null;\n  private documentClickListener: (() => void) | null = null;\n\n  constructor(private el: ElementRef, private renderer: Renderer2) {}\n\n  // Para desktop: usamos mouseenter se não estivermos no modo \"close-enabled\"\n  @HostListener('mouseenter') onMouseEnter() {\n    if (this.tooltipEnableClose) {\n      // Se estiver em modo de clique/tap para mobile, não abre via hover.\n      return;\n    }\n    if (this.tooltipDisabled || this.tooltipElement || !this.tooltipText) {\n      return;\n    }\n    this.createTooltip();\n  }\n\n  // Em modo desktop, fecha ao sair do hover, exceto se tooltipEnableClose for true\n  @HostListener('mouseleave') onMouseLeave() {\n    if (!this.tooltipEnableClose && this.tooltipElement) {\n      this.destroyTooltip();\n    }\n  }\n\n  // Para mobile ou quando tooltipEnableClose está ativo, abrimos o tooltip com clique/tap\n  @HostListener('click', ['$event'])\n  onClick(event: Event) {\n    if (!this.tooltipEnableClose) {\n      // Se não estiver no modo de fechar com clique, ignora o click\n      return;\n    }\n    event.stopPropagation();\n    // Se o tooltip já estiver aberto, não faz nada (ou pode implementar toggle)\n    if (!this.tooltipElement && !this.tooltipDisabled && this.tooltipText) {\n      this.createTooltip();\n    }\n  }\n\n  private createTooltip() {\n    // Cria o tooltip e adiciona a classe base\n    this.tooltipElement = this.renderer.createElement('div');\n    this.renderer.addClass(this.tooltipElement, 'matcha-tooltip-content');\n    // Define o texto do tooltip (aqui não usamos innerHTML, permitindo que o botão seja inserido depois)\n    this.tooltipElement!.textContent = this.tooltipText;\n\n    // Define estilos iniciais para posicionamento e medição\n    this.renderer.setStyle(this.tooltipElement, 'position', 'absolute');\n    this.renderer.setStyle(this.tooltipElement, 'top', '0');\n    this.renderer.setStyle(this.tooltipElement, 'left', '0');\n    this.renderer.setStyle(this.tooltipElement, 'visibility', 'hidden');\n    this.renderer.appendChild(document.body, this.tooltipElement);\n\n    // Se tooltipEnableClose estiver true, adiciona o botão de fechar\n    if (this.tooltipEnableClose) {\n      const closeButton = this.renderer.createElement('div');\n      this.renderer.addClass(closeButton, 'matcha-tooltip-close');\n      // O botão de fechar fica dentro do tooltip\n      this.renderer.appendChild(this.tooltipElement, closeButton);\n      // Ao clicar no botão X, fecha o tooltip\n      this.renderer.listen(closeButton, 'click', (e: Event) => {\n        e.stopPropagation();\n        this.destroyTooltip();\n      });\n      // Adiciona listener global para fechar o tooltip quando clicar fora dele\n      this.documentClickListener = this.renderer.listen('document', 'click', (e: Event) => {\n        if (this.tooltipElement && !this.tooltipElement.contains(e.target as Node)) {\n          this.destroyTooltip();\n        }\n      });\n    }\n\n    // Medidas para posicionamento\n    const margin = 8;\n    const hostRect = this.el.nativeElement.getBoundingClientRect();\n    const tooltipRect = this.tooltipElement!.getBoundingClientRect();\n\n    // Verifica se há espaço suficiente para cada posição\n    const hasSpaceAbove = hostRect.top >= tooltipRect.height + margin;\n    const hasSpaceBelow = (window.innerHeight - hostRect.bottom) >= tooltipRect.height + margin;\n    const hasSpaceLeft  = hostRect.left >= tooltipRect.width + margin;\n    const hasSpaceRight = (window.innerWidth - hostRect.right) >= tooltipRect.width + margin;\n\n    // Determina a posição desejada com base na displayência do usuário e disponibilidade\n    let chosenPosition: 'above' | 'below' | 'left' | 'right' = 'above';\n    if (this.displayAbove && hasSpaceAbove) {\n      chosenPosition = 'above';\n    } else if (this.displayBelow && hasSpaceBelow) {\n      chosenPosition = 'below';\n    } else if (this.displayLeft && hasSpaceLeft) {\n      chosenPosition = 'left';\n    } else if (this.displayRight && hasSpaceRight) {\n      chosenPosition = 'right';\n    } else {\n      chosenPosition = hasSpaceAbove ? 'above' : (hasSpaceBelow ? 'below' : 'above');\n    }\n\n    // Calcula a posição (top e left) de acordo com a posição escolhida\n    let top: number = 0;\n    let left: number = 0;\n    switch (chosenPosition) {\n      case 'above':\n        top = hostRect.top + window.scrollY - tooltipRect.height - margin;\n        left = hostRect.left + window.scrollX + (hostRect.width - tooltipRect.width) / 2;\n        break;\n      case 'below':\n        top = hostRect.bottom + window.scrollY + margin;\n        left = hostRect.left + window.scrollX + (hostRect.width - tooltipRect.width) / 2;\n        break;\n      case 'left':\n        top = hostRect.top + window.scrollY + (hostRect.height - tooltipRect.height) / 2;\n        left = hostRect.left + window.scrollX - tooltipRect.width - margin;\n        break;\n      case 'right':\n        top = hostRect.top + window.scrollY + (hostRect.height - tooltipRect.height) / 2;\n        left = hostRect.right + window.scrollX + margin;\n        break;\n    }\n\n    // Ajusta horizontalmente para não ultrapassar os limites da tela\n    if (left < margin) {\n      left = margin;\n    } else if (left + tooltipRect.width > window.innerWidth - margin) {\n      left = window.innerWidth - tooltipRect.width - margin;\n    }\n\n    // Aplica os estilos calculados e torna o tooltip visível\n    this.renderer.setStyle(this.tooltipElement, 'top', `${top}px`);\n    this.renderer.setStyle(this.tooltipElement, 'left', `${left}px`);\n    this.renderer.setStyle(this.tooltipElement, 'visibility', 'visible');\n\n    // Adiciona classes específicas para customizar a seta de acordo com a posição\n    this.renderer.removeClass(this.tooltipElement, 'matcha-tooltip-content_below');\n    this.renderer.removeClass(this.tooltipElement, 'matcha-tooltip-content_left');\n    this.renderer.removeClass(this.tooltipElement, 'matcha-tooltip-content_right');\n    if (chosenPosition === 'below') {\n      this.renderer.addClass(this.tooltipElement, 'matcha-tooltip-content_below');\n    } else if (chosenPosition === 'left') {\n      this.renderer.addClass(this.tooltipElement, 'matcha-tooltip-content_left');\n    } else if (chosenPosition === 'right') {\n      this.renderer.addClass(this.tooltipElement, 'matcha-tooltip-content_right');\n    }\n    // Para a posição 'above', mantém o estilo padrão\n  }\n\n  private destroyTooltip() {\n    if (this.tooltipElement) {\n      this.renderer.removeChild(document.body, this.tooltipElement);\n      this.tooltipElement = null;\n    }\n    if (this.documentClickListener) {\n      this.documentClickListener(); // Remove o listener global\n      this.documentClickListener = null;\n    }\n  }\n}\n","<ng-content></ng-content>\n"]}

package/esm2022/lib/matcha-tooltip/tooltip.directive.mjs

@@ -1,19 +1,183 @@
-import { Directive } from '@angular/core';
+import { Directive, HostListener, Input } from '@angular/core';
 import * as i0 from "@angular/core";
 export class MatchaTooltipDirective {
-    constructor(_elementRef, _renderer) {
-        this._elementRef = _elementRef;
-        this._renderer = _renderer;
-        //this._elementRef.nativeElement.style.backgroundColor = 'grey';
-        this._renderer.addClass(this._elementRef.nativeElement, 'matcha-tooltip');
+    constructor(el, renderer) {
+        this.el = el;
+        this.renderer = renderer;
+        this.tooltipText = '';
+        this.tooltipDisabled = false;
+        this.preferAbove = false;
+        this.preferBelow = false;
+        this.preferLeft = false;
+        this.preferRight = false;
+        this.tooltipEnableClose = false;
+        this.tooltipElement = null;
+        this.documentClickListener = null;
+    }
+    onMouseEnter() {
+        if (this.tooltipEnableClose) {
+            // Em modo de clique/tap, não abre via hover
+            return;
+        }
+        if (this.tooltipDisabled || this.tooltipElement || !this.tooltipText) {
+            return;
+        }
+        this.createTooltip();
+    }
+    onMouseLeave() {
+        if (!this.tooltipEnableClose && this.tooltipElement) {
+            this.destroyTooltip();
+        }
+    }
+    onClick(event) {
+        if (!this.tooltipEnableClose) {
+            return;
+        }
+        event.stopPropagation();
+        if (!this.tooltipElement && !this.tooltipDisabled && this.tooltipText) {
+            this.createTooltip();
+        }
+    }
+    createTooltip() {
+        // Cria o tooltip e adiciona a classe base
+        this.tooltipElement = this.renderer.createElement('div');
+        this.renderer.addClass(this.tooltipElement, 'matcha-tooltip-content');
+        // Define o conteúdo do tooltip
+        this.tooltipElement.textContent = this.tooltipText;
+        // Define estilos iniciais para medição
+        this.renderer.setStyle(this.tooltipElement, 'position', 'absolute');
+        this.renderer.setStyle(this.tooltipElement, 'top', '0');
+        this.renderer.setStyle(this.tooltipElement, 'left', '0');
+        this.renderer.setStyle(this.tooltipElement, 'visibility', 'hidden');
+        this.renderer.appendChild(document.body, this.tooltipElement);
+        // Se tooltipEnableClose estiver ativo, adiciona o botão de fechar
+        if (this.tooltipEnableClose) {
+            const closeButton = this.renderer.createElement('div');
+            this.renderer.addClass(closeButton, 'matcha-tooltip-close');
+            this.renderer.appendChild(this.tooltipElement, closeButton);
+            this.renderer.listen(closeButton, 'click', (e) => {
+                e.stopPropagation();
+                this.destroyTooltip();
+            });
+            this.documentClickListener = this.renderer.listen('document', 'click', (e) => {
+                if (this.tooltipElement && !this.tooltipElement.contains(e.target)) {
+                    this.destroyTooltip();
+                }
+            });
+        }
+        // Medidas e cálculo de posição
+        const margin = 8;
+        const hostRect = this.el.nativeElement.getBoundingClientRect();
+        const tooltipRect = this.tooltipElement.getBoundingClientRect();
+        const hasSpaceAbove = hostRect.top >= tooltipRect.height + margin;
+        const hasSpaceBelow = (window.innerHeight - hostRect.bottom) >= tooltipRect.height + margin;
+        const hasSpaceLeft = hostRect.left >= tooltipRect.width + margin;
+        const hasSpaceRight = (window.innerWidth - hostRect.right) >= tooltipRect.width + margin;
+        let chosenPosition = 'above';
+        if (this.preferAbove && hasSpaceAbove) {
+            chosenPosition = 'above';
+        }
+        else if (this.preferBelow && hasSpaceBelow) {
+            chosenPosition = 'below';
+        }
+        else if (this.preferLeft && hasSpaceLeft) {
+            chosenPosition = 'left';
+        }
+        else if (this.preferRight && hasSpaceRight) {
+            chosenPosition = 'right';
+        }
+        else {
+            chosenPosition = hasSpaceAbove ? 'above' : (hasSpaceBelow ? 'below' : 'above');
+        }
+        let top = 0;
+        let left = 0;
+        switch (chosenPosition) {
+            case 'above':
+                top = hostRect.top + window.scrollY - tooltipRect.height - margin;
+                left = hostRect.left + window.scrollX + (hostRect.width - tooltipRect.width) / 2;
+                break;
+            case 'below':
+                top = hostRect.bottom + window.scrollY + margin;
+                left = hostRect.left + window.scrollX + (hostRect.width - tooltipRect.width) / 2;
+                break;
+            case 'left':
+                top = hostRect.top + window.scrollY + (hostRect.height - tooltipRect.height) / 2;
+                left = hostRect.left + window.scrollX - tooltipRect.width - margin;
+                break;
+            case 'right':
+                top = hostRect.top + window.scrollY + (hostRect.height - tooltipRect.height) / 2;
+                left = hostRect.right + window.scrollX + margin;
+                break;
+        }
+        if (left < margin) {
+            left = margin;
+        }
+        else if (left + tooltipRect.width > window.innerWidth - margin) {
+            left = window.innerWidth - tooltipRect.width - margin;
+        }
+        this.renderer.setStyle(this.tooltipElement, 'top', `${top}px`);
+        this.renderer.setStyle(this.tooltipElement, 'left', `${left}px`);
+        this.renderer.setStyle(this.tooltipElement, 'visibility', 'visible');
+        this.renderer.removeClass(this.tooltipElement, 'matcha-tooltip-content_below');
+        this.renderer.removeClass(this.tooltipElement, 'matcha-tooltip-content_left');
+        this.renderer.removeClass(this.tooltipElement, 'matcha-tooltip-content_right');
+        if (chosenPosition === 'below') {
+            this.renderer.addClass(this.tooltipElement, 'matcha-tooltip-content_below');
+        }
+        else if (chosenPosition === 'left') {
+            this.renderer.addClass(this.tooltipElement, 'matcha-tooltip-content_left');
+        }
+        else if (chosenPosition === 'right') {
+            this.renderer.addClass(this.tooltipElement, 'matcha-tooltip-content_right');
+        }
+    }
+    destroyTooltip() {
+        if (this.tooltipElement) {
+            this.renderer.removeChild(document.body, this.tooltipElement);
+            this.tooltipElement = null;
+        }
+        if (this.documentClickListener) {
+            this.documentClickListener();
+            this.documentClickListener = null;
+        }
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MatchaTooltipDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: MatchaTooltipDirective, selector: "[matchaTooltip]", ngImport: i0 }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: MatchaTooltipDirective, selector: "[matcha-tooltip]", inputs: { tooltipText: ["matcha-tooltip", "tooltipText"], tooltipDisabled: ["tooltip-disabled", "tooltipDisabled"], preferAbove: ["display-above", "preferAbove"], preferBelow: ["display-below", "preferBelow"], preferLeft: ["display-left", "preferLeft"], preferRight: ["display-right", "preferRight"], tooltipEnableClose: ["tooltip-enable-close", "tooltipEnableClose"] }, host: { listeners: { "mouseenter": "onMouseEnter()", "mouseleave": "onMouseLeave()", "click": "onClick($event)" } }, ngImport: i0 }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MatchaTooltipDirective, decorators: [{
             type: Directive,
             args: [{
-                    selector: '[matchaTooltip]'
+                    selector: '[matcha-tooltip]' // Usado como atributo
                 }]
-        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9vbHRpcC5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tYXRjaGEtY29tcG9uZW50cy9zcmMvbGliL21hdGNoYS10b29sdGlwL3Rvb2x0aXAuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQXlCLE1BQU0sZUFBZSxDQUFDOztBQUtqRSxNQUFNLE9BQU8sc0JBQXNCO0lBRS9CLFlBQ1ksV0FBdUIsRUFDdkIsU0FBb0I7UUFEcEIsZ0JBQVcsR0FBWCxXQUFXLENBQVk7UUFDdkIsY0FBUyxHQUFULFNBQVMsQ0FBVztRQUU1QixnRUFBZ0U7UUFDaEUsSUFBSSxDQUFDLFNBQVMsQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDLFdBQVcsQ0FBQyxhQUFhLEVBQUUsZ0JBQWdCLENBQUMsQ0FBQTtJQUM3RSxDQUFDOytHQVJRLHNCQUFzQjttR0FBdEIsc0JBQXNCOzs0RkFBdEIsc0JBQXNCO2tCQUhsQyxTQUFTO21CQUFDO29CQUNULFFBQVEsRUFBRSxpQkFBaUI7aUJBQzVCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGlyZWN0aXZlLCBFbGVtZW50UmVmLCBSZW5kZXJlcjIgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQERpcmVjdGl2ZSh7XG4gIHNlbGVjdG9yOiAnW21hdGNoYVRvb2x0aXBdJ1xufSlcbmV4cG9ydCBjbGFzcyBNYXRjaGFUb29sdGlwRGlyZWN0aXZlIHtcblxuICAgIGNvbnN0cnVjdG9yKFxuICAgICAgICBwcml2YXRlIF9lbGVtZW50UmVmOiBFbGVtZW50UmVmLFxuICAgICAgICBwcml2YXRlIF9yZW5kZXJlcjogUmVuZGVyZXIyXG4gICAgKSB7XG4gICAgICAgIC8vdGhpcy5fZWxlbWVudFJlZi5uYXRpdmVFbGVtZW50LnN0eWxlLmJhY2tncm91bmRDb2xvciA9ICdncmV5JztcbiAgICAgICAgdGhpcy5fcmVuZGVyZXIuYWRkQ2xhc3ModGhpcy5fZWxlbWVudFJlZi5uYXRpdmVFbGVtZW50LCAnbWF0Y2hhLXRvb2x0aXAnKVxuICAgIH1cblxufVxuIl19
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }], propDecorators: { tooltipText: [{
+                type: Input,
+                args: ['matcha-tooltip']
+            }], tooltipDisabled: [{
+                type: Input,
+                args: ['tooltip-disabled']
+            }], preferAbove: [{
+                type: Input,
+                args: ['display-above']
+            }], preferBelow: [{
+                type: Input,
+                args: ['display-below']
+            }], preferLeft: [{
+                type: Input,
+                args: ['display-left']
+            }], preferRight: [{
+                type: Input,
+                args: ['display-right']
+            }], tooltipEnableClose: [{
+                type: Input,
+                args: ['tooltip-enable-close']
+            }], onMouseEnter: [{
+                type: HostListener,
+                args: ['mouseenter']
+            }], onMouseLeave: [{
+                type: HostListener,
+                args: ['mouseleave']
+            }], onClick: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tooltip.directive.js","sourceRoot":"","sources":["../../../../../projects/matcha-components/src/lib/matcha-tooltip/tooltip.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, ElementRef, HostListener, Input, Renderer2 } from '@angular/core';\n\n@Directive({\n  selector: '[matcha-tooltip]' // Usado como atributo\n})\nexport class MatchaTooltipDirective {\n  @Input('matcha-tooltip') tooltipText: string = '';\n  @Input('tooltip-disabled') tooltipDisabled: boolean = false;\n\n  @Input('display-above') preferAbove: boolean = false;\n  @Input('display-below') preferBelow: boolean = false;\n  @Input('display-left') preferLeft: boolean = false;\n  @Input('display-right') preferRight: boolean = false;\n\n  @Input('tooltip-enable-close') tooltipEnableClose: boolean = false;\n\n  private tooltipElement: HTMLElement | null = null;\n  private documentClickListener: (() => void) | null = null;\n\n  constructor(private el: ElementRef, private renderer: Renderer2) {}\n\n  @HostListener('mouseenter')\n  onMouseEnter() {\n    if (this.tooltipEnableClose) {\n      // Em modo de clique/tap, não abre via hover\n      return;\n    }\n    if (this.tooltipDisabled || this.tooltipElement || !this.tooltipText) {\n      return;\n    }\n    this.createTooltip();\n  }\n\n  @HostListener('mouseleave')\n  onMouseLeave() {\n    if (!this.tooltipEnableClose && this.tooltipElement) {\n      this.destroyTooltip();\n    }\n  }\n\n  @HostListener('click', ['$event'])\n  onClick(event: Event) {\n    if (!this.tooltipEnableClose) {\n      return;\n    }\n    event.stopPropagation();\n    if (!this.tooltipElement && !this.tooltipDisabled && this.tooltipText) {\n      this.createTooltip();\n    }\n  }\n\n  private createTooltip() {\n    // Cria o tooltip e adiciona a classe base\n    this.tooltipElement = this.renderer.createElement('div');\n    this.renderer.addClass(this.tooltipElement, 'matcha-tooltip-content');\n\n    // Define o conteúdo do tooltip\n    this.tooltipElement!.textContent = this.tooltipText;\n\n    // Define estilos iniciais para medição\n    this.renderer.setStyle(this.tooltipElement, 'position', 'absolute');\n    this.renderer.setStyle(this.tooltipElement, 'top', '0');\n    this.renderer.setStyle(this.tooltipElement, 'left', '0');\n    this.renderer.setStyle(this.tooltipElement, 'visibility', 'hidden');\n    this.renderer.appendChild(document.body, this.tooltipElement);\n\n    // Se tooltipEnableClose estiver ativo, adiciona o botão de fechar\n    if (this.tooltipEnableClose) {\n      const closeButton = this.renderer.createElement('div');\n      this.renderer.addClass(closeButton, 'matcha-tooltip-close');\n      this.renderer.appendChild(this.tooltipElement, closeButton);\n      this.renderer.listen(closeButton, 'click', (e: Event) => {\n        e.stopPropagation();\n        this.destroyTooltip();\n      });\n      this.documentClickListener = this.renderer.listen('document', 'click', (e: Event) => {\n        if (this.tooltipElement && !this.tooltipElement.contains(e.target as Node)) {\n          this.destroyTooltip();\n        }\n      });\n    }\n\n    // Medidas e cálculo de posição\n    const margin = 8;\n    const hostRect = this.el.nativeElement.getBoundingClientRect();\n    const tooltipRect = this.tooltipElement!.getBoundingClientRect();\n\n    const hasSpaceAbove = hostRect.top >= tooltipRect.height + margin;\n    const hasSpaceBelow = (window.innerHeight - hostRect.bottom) >= tooltipRect.height + margin;\n    const hasSpaceLeft  = hostRect.left >= tooltipRect.width + margin;\n    const hasSpaceRight = (window.innerWidth - hostRect.right) >= tooltipRect.width + margin;\n\n    let chosenPosition: 'above' | 'below' | 'left' | 'right' = 'above';\n    if (this.preferAbove && hasSpaceAbove) {\n      chosenPosition = 'above';\n    } else if (this.preferBelow && hasSpaceBelow) {\n      chosenPosition = 'below';\n    } else if (this.preferLeft && hasSpaceLeft) {\n      chosenPosition = 'left';\n    } else if (this.preferRight && hasSpaceRight) {\n      chosenPosition = 'right';\n    } else {\n      chosenPosition = hasSpaceAbove ? 'above' : (hasSpaceBelow ? 'below' : 'above');\n    }\n\n    let top: number = 0;\n    let left: number = 0;\n    switch (chosenPosition) {\n      case 'above':\n        top = hostRect.top + window.scrollY - tooltipRect.height - margin;\n        left = hostRect.left + window.scrollX + (hostRect.width - tooltipRect.width) / 2;\n        break;\n      case 'below':\n        top = hostRect.bottom + window.scrollY + margin;\n        left = hostRect.left + window.scrollX + (hostRect.width - tooltipRect.width) / 2;\n        break;\n      case 'left':\n        top = hostRect.top + window.scrollY + (hostRect.height - tooltipRect.height) / 2;\n        left = hostRect.left + window.scrollX - tooltipRect.width - margin;\n        break;\n      case 'right':\n        top = hostRect.top + window.scrollY + (hostRect.height - tooltipRect.height) / 2;\n        left = hostRect.right + window.scrollX + margin;\n        break;\n    }\n\n    if (left < margin) {\n      left = margin;\n    } else if (left + tooltipRect.width > window.innerWidth - margin) {\n      left = window.innerWidth - tooltipRect.width - margin;\n    }\n\n    this.renderer.setStyle(this.tooltipElement, 'top', `${top}px`);\n    this.renderer.setStyle(this.tooltipElement, 'left', `${left}px`);\n    this.renderer.setStyle(this.tooltipElement, 'visibility', 'visible');\n\n    this.renderer.removeClass(this.tooltipElement, 'matcha-tooltip-content_below');\n    this.renderer.removeClass(this.tooltipElement, 'matcha-tooltip-content_left');\n    this.renderer.removeClass(this.tooltipElement, 'matcha-tooltip-content_right');\n    if (chosenPosition === 'below') {\n      this.renderer.addClass(this.tooltipElement, 'matcha-tooltip-content_below');\n    } else if (chosenPosition === 'left') {\n      this.renderer.addClass(this.tooltipElement, 'matcha-tooltip-content_left');\n    } else if (chosenPosition === 'right') {\n      this.renderer.addClass(this.tooltipElement, 'matcha-tooltip-content_right');\n    }\n  }\n\n  private destroyTooltip() {\n    if (this.tooltipElement) {\n      this.renderer.removeChild(document.body, this.tooltipElement);\n      this.tooltipElement = null;\n    }\n    if (this.documentClickListener) {\n      this.documentClickListener();\n      this.documentClickListener = null;\n    }\n  }\n}\n"]}

package/esm2022/lib/matcha-tooltip/tooltip.module.mjs

@@ -1,18 +1,19 @@
 import { NgModule } from '@angular/core';
 import { CommonModule } from '@angular/common';
+import { MatchaTooltipComponent } from './tooltip/tooltip.component';
 import { MatchaTooltipDirective } from './tooltip.directive';
 import * as i0 from "@angular/core";
 export class MatchaTooltipModule {
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MatchaTooltipModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: MatchaTooltipModule, declarations: [MatchaTooltipDirective], imports: [CommonModule], exports: [MatchaTooltipDirective] }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: MatchaTooltipModule, declarations: [MatchaTooltipComponent, MatchaTooltipDirective], imports: [CommonModule], exports: [MatchaTooltipComponent, MatchaTooltipDirective] }); }
     static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MatchaTooltipModule, imports: [CommonModule] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MatchaTooltipModule, decorators: [{
             type: NgModule,
             args: [{
-                    declarations: [MatchaTooltipDirective],
+                    declarations: [MatchaTooltipComponent, MatchaTooltipDirective],
                     imports: [CommonModule],
-                    exports: [MatchaTooltipDirective],
+                    exports: [MatchaTooltipComponent, MatchaTooltipDirective],
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9vbHRpcC5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tYXRjaGEtY29tcG9uZW50cy9zcmMvbGliL21hdGNoYS10b29sdGlwL3Rvb2x0aXAubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLHFCQUFxQixDQUFDOztBQU83RCxNQUFNLE9BQU8sbUJBQW1COytHQUFuQixtQkFBbUI7Z0hBQW5CLG1CQUFtQixpQkFKYixzQkFBc0IsYUFDM0IsWUFBWSxhQUNaLHNCQUFzQjtnSEFFdkIsbUJBQW1CLFlBSGxCLFlBQVk7OzRGQUdiLG1CQUFtQjtrQkFML0IsUUFBUTttQkFBQztvQkFDTixZQUFZLEVBQUUsQ0FBQyxzQkFBc0IsQ0FBQztvQkFDdEMsT0FBTyxFQUFFLENBQUMsWUFBWSxDQUFDO29CQUN2QixPQUFPLEVBQUUsQ0FBQyxzQkFBc0IsQ0FBQztpQkFDcEMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7IE1hdGNoYVRvb2x0aXBEaXJlY3RpdmUgfSBmcm9tICcuL3Rvb2x0aXAuZGlyZWN0aXZlJztcblxuQE5nTW9kdWxlKHtcbiAgICBkZWNsYXJhdGlvbnM6IFtNYXRjaGFUb29sdGlwRGlyZWN0aXZlXSxcbiAgICBpbXBvcnRzOiBbQ29tbW9uTW9kdWxlXSxcbiAgICBleHBvcnRzOiBbTWF0Y2hhVG9vbHRpcERpcmVjdGl2ZV0sXG59KVxuZXhwb3J0IGNsYXNzIE1hdGNoYVRvb2x0aXBNb2R1bGUge31cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9vbHRpcC5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tYXRjaGEtY29tcG9uZW50cy9zcmMvbGliL21hdGNoYS10b29sdGlwL3Rvb2x0aXAubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBQ3JFLE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLHFCQUFxQixDQUFDOztBQU83RCxNQUFNLE9BQU8sbUJBQW1COytHQUFuQixtQkFBbUI7Z0hBQW5CLG1CQUFtQixpQkFKYixzQkFBc0IsRUFBRSxzQkFBc0IsYUFDbkQsWUFBWSxhQUNaLHNCQUFzQixFQUFFLHNCQUFzQjtnSEFFL0MsbUJBQW1CLFlBSGxCLFlBQVk7OzRGQUdiLG1CQUFtQjtrQkFML0IsUUFBUTttQkFBQztvQkFDTixZQUFZLEVBQUUsQ0FBQyxzQkFBc0IsRUFBRSxzQkFBc0IsQ0FBQztvQkFDOUQsT0FBTyxFQUFFLENBQUMsWUFBWSxDQUFDO29CQUN2QixPQUFPLEVBQUUsQ0FBQyxzQkFBc0IsRUFBRSxzQkFBc0IsQ0FBQztpQkFDNUQiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7IE1hdGNoYVRvb2x0aXBDb21wb25lbnQgfSBmcm9tICcuL3Rvb2x0aXAvdG9vbHRpcC5jb21wb25lbnQnO1xuaW1wb3J0IHsgTWF0Y2hhVG9vbHRpcERpcmVjdGl2ZSB9IGZyb20gJy4vdG9vbHRpcC5kaXJlY3RpdmUnO1xuXG5ATmdNb2R1bGUoe1xuICAgIGRlY2xhcmF0aW9uczogW01hdGNoYVRvb2x0aXBDb21wb25lbnQsIE1hdGNoYVRvb2x0aXBEaXJlY3RpdmVdLFxuICAgIGltcG9ydHM6IFtDb21tb25Nb2R1bGVdLFxuICAgIGV4cG9ydHM6IFtNYXRjaGFUb29sdGlwQ29tcG9uZW50LCBNYXRjaGFUb29sdGlwRGlyZWN0aXZlXSxcbn0pXG5leHBvcnQgY2xhc3MgTWF0Y2hhVG9vbHRpcE1vZHVsZSB7fVxuIl19

package/esm2022/public-api.mjs

@@ -25,6 +25,7 @@ export * from './lib/matcha-modal/modal-footer/modal-footer.component';
 export * from './lib/matcha-modal/modal-options/modal-options.component';
 export * from './lib/matcha-modal/modal/modal.component';
 export * from './lib/matcha-menu/menu.component';
+export * from './lib/matcha-tooltip/tooltip/tooltip.component';
 // -----------------------------------------------------------
 // MODULES
 // -----------------------------------------------------------
@@ -33,6 +34,10 @@ export * from './lib/matcha-card/card.module';
 export * from './lib/matcha-masonry/masonry.module';
 export * from './lib/matcha-title/title.module';
 export * from './lib/matcha-button/button.module';
+export * from './lib/matcha-tooltip/tooltip.module';
+export * from './lib/matcha-divider/divider.module';
+export * from './lib/matcha-elevation/elevation.module';
+export * from './lib/matcha-grid/grid.module';
 export * from './lib/matcha-components.module';
 export * from './lib/matcha-autocomplete/autocomplete.module';
 export * from './lib/matcha-badge/badge.module';
@@ -42,11 +47,8 @@ export * from './lib/matcha-button-toggle/button-toggle.module';
 export * from './lib/matcha-checkbox/checkbox.module';
 export * from './lib/matcha-chips/chips.module';
 export * from './lib/matcha-datepicker/datepicker.module';
-export * from './lib/matcha-divider/divider.module';
-export * from './lib/matcha-elevation/elevation.module';
 export * from './lib/matcha-expansion/expansion.module';
 export * from './lib/matcha-forms/forms.module';
-export * from './lib/matcha-grid/grid.module';
 export * from './lib/matcha-icon/icon.module';
 export * from './lib/matcha-input/input.module';
 export * from './lib/matcha-list/list.module';
@@ -63,14 +65,13 @@ export * from './lib/matcha-snackbar/snack-bar.module';
 export * from './lib/matcha-sort-header/sort-header.module';
 export * from './lib/matcha-stepper/stepper.module';
 export * from './lib/matcha-table/table.module';
-export * from './lib/matcha-tooltip/tooltip.module';
 export * from './lib/matcha-tree/tree.module';
 // -----------------------------------------------------------
 // DIRECTIVES
 // -----------------------------------------------------------
+export * from './lib/matcha-tooltip/tooltip.directive';
 export * from './lib/matcha-input/input.directive';
 export * from './lib/matcha-tree/tree.directive';
-export * from './lib/matcha-tooltip/tooltip.directive';
 export * from './lib/matcha-table/table.directive';
 export * from './lib/matcha-stepper/stepper.directive';
 export * from './lib/matcha-sort-header/sort-header.directive';
@@ -97,4 +98,4 @@ export * from './lib/matcha-tabs/tabs.directive';
 export * from './lib/matcha-badge/badge.directive';
 export * from './lib/matcha-autocomplete/autocomplete-overview.directive';
 export * from './lib/matcha-autocomplete/autocomplete.directive';
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"public-api.js","sourceRoot":"","sources":["../../../projects/matcha-components/src/public-api.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Public API Surface of matcha-components\n */\n\n// -----------------------------------------------------------\n// COMPONENTS\n// -----------------------------------------------------------\n\n// // ATOMIC COMPONENTS\n// export * from './lib/matcha-button/matcha-button.component';\n\n// // BASE COMPONENT\n// export * from './lib/matcha-title/matcha-title.component';\n\n//\n// -----------------------------------------------------------\n// COMPONENTS\n// -----------------------------------------------------------\nexport * from './lib/matcha-button/button/button.component';\nexport * from './lib/matcha-card/card/card.component';\nexport * from './lib/matcha-divider/divider/divider.component';\nexport * from './lib/matcha-title/title/title.component';\nexport * from './lib/matcha-icon/icon.component';\nexport * from './lib/matcha-grid/grid.component';\nexport * from './lib/matcha-masonry/masonry/masonry.component';\nexport * from './lib/matcha-modal/modal-content/modal-content.component';\nexport * from './lib/matcha-modal/modal-header/modal-header.component';\nexport * from './lib/matcha-modal/modal-footer/modal-footer.component';\nexport * from './lib/matcha-modal/modal-options/modal-options.component';\nexport * from './lib/matcha-modal/modal/modal.component';\nexport * from './lib/matcha-menu/menu.component';\n\n\n// -----------------------------------------------------------\n// MODULES\n// -----------------------------------------------------------\nexport * from './lib/matcha-modal/matcha-modal.module';\nexport * from './lib/matcha-card/card.module';\nexport * from './lib/matcha-masonry/masonry.module';\nexport * from './lib/matcha-title/title.module';\nexport * from './lib/matcha-button/button.module';\n\nexport * from './lib/matcha-components.module';\nexport * from './lib/matcha-autocomplete/autocomplete.module';\nexport * from './lib/matcha-badge/badge.module';\nexport * from './lib/matcha-tabs/tabs.module';\nexport * from './lib/matcha-bottom-sheet/bottom-sheet.module';\nexport * from './lib/matcha-button-toggle/button-toggle.module';\nexport * from './lib/matcha-checkbox/checkbox.module';\nexport * from './lib/matcha-chips/chips.module';\nexport * from './lib/matcha-datepicker/datepicker.module';\nexport * from './lib/matcha-divider/divider.module';\nexport * from './lib/matcha-elevation/elevation.module';\nexport * from './lib/matcha-expansion/expansion.module';\nexport * from './lib/matcha-forms/forms.module';\nexport * from './lib/matcha-grid/grid.module';\nexport * from './lib/matcha-icon/icon.module';\nexport * from './lib/matcha-input/input.module';\nexport * from './lib/matcha-list/list.module';\nexport * from './lib/matcha-menu/menu.module';\nexport * from './lib/matcha-sidenav/sidenav.module';\nexport * from './lib/matcha-paginator/paginator.module';\nexport * from './lib/matcha-progress-bar/progress-bar.module';\nexport * from './lib/matcha-progress-spinner/progress-spinner.module';\nexport * from './lib/matcha-radio-button/radio-button.module';\nexport * from './lib/matcha-select/select.module';\nexport * from './lib/matcha-slide-toggle/slide-toggle.module';\nexport * from './lib/matcha-slider/slider.module';\nexport * from './lib/matcha-snackbar/snack-bar.module';\nexport * from './lib/matcha-sort-header/sort-header.module';\nexport * from './lib/matcha-stepper/stepper.module';\nexport * from './lib/matcha-table/table.module';\nexport * from './lib/matcha-tooltip/tooltip.module';\nexport * from './lib/matcha-tree/tree.module';\n\n// -----------------------------------------------------------\n// DIRECTIVES\n// -----------------------------------------------------------\n\nexport * from './lib/matcha-input/input.directive';\nexport * from './lib/matcha-tree/tree.directive';\nexport * from './lib/matcha-tooltip/tooltip.directive';\nexport * from './lib/matcha-table/table.directive';\nexport * from './lib/matcha-stepper/stepper.directive';\nexport * from './lib/matcha-sort-header/sort-header.directive';\nexport * from './lib/matcha-snackbar/snack-bar.directive';\nexport * from './lib/matcha-slider/matcha-slider.directive';\nexport * from './lib/matcha-slide-toggle/slide-toggle.directive';\nexport * from './lib/matcha-select/select.directive';\nexport * from './lib/matcha-radio-button/matcha-radio-button.directive';\nexport * from './lib/matcha-progress-spinner/progress-spinner.directive';\nexport * from './lib/matcha-progress-bar/progress-bar.directive';\nexport * from './lib/matcha-paginator/paginator.directive';\nexport * from './lib/matcha-sidenav/sidenav.directive';\nexport * from './lib/matcha-menu/menu.directive';\nexport * from './lib/matcha-list/list.directive';\nexport * from './lib/matcha-forms/form-field.directive';\nexport * from './lib/matcha-expansion/expansion.directive';\nexport * from './lib/matcha-elevation/elevation.directive';\nexport * from './lib/matcha-datepicker/datepicker.directive';\nexport * from './lib/matcha-chips/matcha-chips.directive';\nexport * from './lib/matcha-checkbox/checkbox.directive';\nexport * from './lib/matcha-button-toggle/matcha-button-toggle.directive';\nexport * from './lib/matcha-bottom-sheet/bottom-sheet.directive';\nexport * from './lib/matcha-tabs/tabs.directive';\nexport * from './lib/matcha-badge/badge.directive';\nexport * from './lib/matcha-autocomplete/autocomplete-overview.directive';\nexport * from './lib/matcha-autocomplete/autocomplete.directive';\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"public-api.js","sourceRoot":"","sources":["../../../projects/matcha-components/src/public-api.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Public API Surface of matcha-components\n */\n\n// -----------------------------------------------------------\n// COMPONENTS\n// -----------------------------------------------------------\n\n// // ATOMIC COMPONENTS\n// export * from './lib/matcha-button/matcha-button.component';\n\n// // BASE COMPONENT\n// export * from './lib/matcha-title/matcha-title.component';\n\n//\n// -----------------------------------------------------------\n// COMPONENTS\n// -----------------------------------------------------------\nexport * from './lib/matcha-button/button/button.component';\nexport * from './lib/matcha-card/card/card.component';\nexport * from './lib/matcha-divider/divider/divider.component';\nexport * from './lib/matcha-title/title/title.component';\nexport * from './lib/matcha-icon/icon.component';\nexport * from './lib/matcha-grid/grid.component';\nexport * from './lib/matcha-masonry/masonry/masonry.component';\nexport * from './lib/matcha-modal/modal-content/modal-content.component';\nexport * from './lib/matcha-modal/modal-header/modal-header.component';\nexport * from './lib/matcha-modal/modal-footer/modal-footer.component';\nexport * from './lib/matcha-modal/modal-options/modal-options.component';\nexport * from './lib/matcha-modal/modal/modal.component';\nexport * from './lib/matcha-menu/menu.component';\nexport * from './lib/matcha-tooltip/tooltip/tooltip.component';\n\n\n// -----------------------------------------------------------\n// MODULES\n// -----------------------------------------------------------\nexport * from './lib/matcha-modal/matcha-modal.module';\nexport * from './lib/matcha-card/card.module';\nexport * from './lib/matcha-masonry/masonry.module';\nexport * from './lib/matcha-title/title.module';\nexport * from './lib/matcha-button/button.module';\nexport * from './lib/matcha-tooltip/tooltip.module';\nexport * from './lib/matcha-divider/divider.module';\nexport * from './lib/matcha-elevation/elevation.module';\nexport * from './lib/matcha-grid/grid.module';\n\nexport * from './lib/matcha-components.module';\nexport * from './lib/matcha-autocomplete/autocomplete.module';\nexport * from './lib/matcha-badge/badge.module';\nexport * from './lib/matcha-tabs/tabs.module';\nexport * from './lib/matcha-bottom-sheet/bottom-sheet.module';\nexport * from './lib/matcha-button-toggle/button-toggle.module';\nexport * from './lib/matcha-checkbox/checkbox.module';\nexport * from './lib/matcha-chips/chips.module';\nexport * from './lib/matcha-datepicker/datepicker.module';\nexport * from './lib/matcha-expansion/expansion.module';\nexport * from './lib/matcha-forms/forms.module';\nexport * from './lib/matcha-icon/icon.module';\nexport * from './lib/matcha-input/input.module';\nexport * from './lib/matcha-list/list.module';\nexport * from './lib/matcha-menu/menu.module';\nexport * from './lib/matcha-sidenav/sidenav.module';\nexport * from './lib/matcha-paginator/paginator.module';\nexport * from './lib/matcha-progress-bar/progress-bar.module';\nexport * from './lib/matcha-progress-spinner/progress-spinner.module';\nexport * from './lib/matcha-radio-button/radio-button.module';\nexport * from './lib/matcha-select/select.module';\nexport * from './lib/matcha-slide-toggle/slide-toggle.module';\nexport * from './lib/matcha-slider/slider.module';\nexport * from './lib/matcha-snackbar/snack-bar.module';\nexport * from './lib/matcha-sort-header/sort-header.module';\nexport * from './lib/matcha-stepper/stepper.module';\nexport * from './lib/matcha-table/table.module';\nexport * from './lib/matcha-tree/tree.module';\n\n// -----------------------------------------------------------\n// DIRECTIVES\n// -----------------------------------------------------------\n\nexport * from './lib/matcha-tooltip/tooltip.directive';\n\nexport * from './lib/matcha-input/input.directive';\nexport * from './lib/matcha-tree/tree.directive';\nexport * from './lib/matcha-table/table.directive';\nexport * from './lib/matcha-stepper/stepper.directive';\nexport * from './lib/matcha-sort-header/sort-header.directive';\nexport * from './lib/matcha-snackbar/snack-bar.directive';\nexport * from './lib/matcha-slider/matcha-slider.directive';\nexport * from './lib/matcha-slide-toggle/slide-toggle.directive';\nexport * from './lib/matcha-select/select.directive';\nexport * from './lib/matcha-radio-button/matcha-radio-button.directive';\nexport * from './lib/matcha-progress-spinner/progress-spinner.directive';\nexport * from './lib/matcha-progress-bar/progress-bar.directive';\nexport * from './lib/matcha-paginator/paginator.directive';\nexport * from './lib/matcha-sidenav/sidenav.directive';\nexport * from './lib/matcha-menu/menu.directive';\nexport * from './lib/matcha-list/list.directive';\nexport * from './lib/matcha-forms/form-field.directive';\nexport * from './lib/matcha-expansion/expansion.directive';\nexport * from './lib/matcha-elevation/elevation.directive';\nexport * from './lib/matcha-datepicker/datepicker.directive';\nexport * from './lib/matcha-chips/matcha-chips.directive';\nexport * from './lib/matcha-checkbox/checkbox.directive';\nexport * from './lib/matcha-button-toggle/matcha-button-toggle.directive';\nexport * from './lib/matcha-bottom-sheet/bottom-sheet.directive';\nexport * from './lib/matcha-tabs/tabs.directive';\nexport * from './lib/matcha-badge/badge.directive';\nexport * from './lib/matcha-autocomplete/autocomplete-overview.directive';\nexport * from './lib/matcha-autocomplete/autocomplete.directive';\n"]}