matcha-components 19.74.0 → 19.76.0

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

@@ -0,0 +1,46 @@
+import { Component, ContentChildren } from '@angular/core';
+import { MatchaOptionComponent } from '../../../public-api';
+import * as i0 from "@angular/core";
+import * as i1 from "../../matcha-option/matcha-option.service";
+import * as i2 from "@angular/common";
+export class MatchaAutocompleteComponent {
+    constructor(changeDetectorRef, matchaOptionService) {
+        this.changeDetectorRef = changeDetectorRef;
+        this.matchaOptionService = matchaOptionService;
+        this.isDisplayAutocomplete = false;
+        this.activeOption = 0;
+    }
+    ngOnInit() {
+        this.matchaOptionService.canShowOptions$.subscribe((canShowOptions) => {
+            if (!canShowOptions) {
+                this.matchaOptionService.resetActiveOption();
+            }
+            this.isDisplayAutocomplete = canShowOptions;
+        });
+    }
+    ngAfterContentInit() {
+        const options = this.options.toArray();
+        if (options.length > 0) {
+            options[0].setIsOptionActive(true, false);
+        }
+        this.matchaOptionService.updateOptions(options);
+        this.options.changes.subscribe((newOptions) => {
+            this.matchaOptionService.updateOptions(newOptions.toArray());
+            this.matchaOptionService.resetActiveOption();
+        });
+        this.matchaOptionService.activeOption$.subscribe((currentActiveOption) => {
+            this.activeOption = currentActiveOption;
+            this.changeDetectorRef.detectChanges();
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MatchaAutocompleteComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: i1.MatchaOptionService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: MatchaAutocompleteComponent, selector: "matcha-autocomplete", queries: [{ propertyName: "options", predicate: MatchaOptionComponent }], ngImport: i0, template: "<ng-container *ngIf=\"isDisplayAutocomplete\">\n    <div class=\"background-bg pt-24 position-absolute z-index-2 w-100-p\">\n        <ul class=\"background-surface m-0 radius-8 elevation-z-1 p-0\">\n            <ng-content></ng-content>\n        </ul>\n    </div>\n</ng-container>\n", styles: [""], dependencies: [{ kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MatchaAutocompleteComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'matcha-autocomplete', standalone: false, template: "<ng-container *ngIf=\"isDisplayAutocomplete\">\n    <div class=\"background-bg pt-24 position-absolute z-index-2 w-100-p\">\n        <ul class=\"background-surface m-0 radius-8 elevation-z-1 p-0\">\n            <ng-content></ng-content>\n        </ul>\n    </div>\n</ng-container>\n" }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i1.MatchaOptionService }], propDecorators: { options: [{
+                type: ContentChildren,
+                args: [MatchaOptionComponent]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,71 @@
+import { Directive, HostListener, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "../matcha-option/matcha-option.service";
+export class MatchaAutocompleteDirective {
+    displayAutocomplete() {
+        this.matchaOptionService.setCanShowOptions(true);
+    }
+    hideAutocomplete() {
+        setTimeout(() => {
+            const canShowAutocomplete = this.matchaOptionService.getCanShowOptions();
+            if (canShowAutocomplete) {
+                this.matchaOptionService.setCanShowOptions(false);
+            }
+        }, 300);
+    }
+    onArrowDown(event) {
+        switch (event.key) {
+            case 'ArrowDown':
+                this.matchaOptionService.changeActiveOption(1);
+                break;
+            case 'ArrowUp':
+                this.matchaOptionService.changeActiveOption(-1);
+                break;
+            case 'Enter':
+                this.matchaOptionService.selectActiveOption();
+                break;
+            default:
+                break;
+        }
+    }
+    constructor(ngControl, _elementRef, matchaOptionService) {
+        this.ngControl = ngControl;
+        this._elementRef = _elementRef;
+        this.matchaOptionService = matchaOptionService;
+    }
+    ngOnInit() {
+        this.matchaOptionService.selectedOption$.subscribe((option) => {
+            this._updateInputValue(option);
+        });
+    }
+    _updateInputValue(selectedOption) {
+        if (this.ngControl.control) {
+            this.ngControl.control.setValue(selectedOption);
+            this.ngControl.control.markAsDirty();
+            this.matchaOptionService.setCanShowOptions(false);
+            this._elementRef.nativeElement.blur();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MatchaAutocompleteDirective, deps: [{ token: i1.NgControl }, { token: i0.ElementRef }, { token: i2.MatchaOptionService }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: MatchaAutocompleteDirective, selector: "[matchaAutocomplete]", inputs: { matchaAutocomplete: "matchaAutocomplete" }, host: { listeners: { "focus": "displayAutocomplete()", "focusout": "hideAutocomplete()", "keydown": "onArrowDown($event)" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MatchaAutocompleteDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[matchaAutocomplete]',
+                    standalone: false,
+                }]
+        }], ctorParameters: () => [{ type: i1.NgControl }, { type: i0.ElementRef }, { type: i2.MatchaOptionService }], propDecorators: { matchaAutocomplete: [{
+                type: Input
+            }], displayAutocomplete: [{
+                type: HostListener,
+                args: ['focus']
+            }], hideAutocomplete: [{
+                type: HostListener,
+                args: ['focusout']
+            }], onArrowDown: [{
+                type: HostListener,
+                args: ['keydown', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,21 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { FormsModule } from '@angular/forms';
+import { MatchaOptionModule } from '../matcha-option/matcha-option.module';
+import { MatchaAutocompleteComponent } from './matcha-autocomplete/matcha-autocomplete.component';
+import { MatchaAutocompleteDirective } from './matcha-autocomplete.directive';
+import * as i0 from "@angular/core";
+export class MatchaAutocompleteModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MatchaAutocompleteModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: MatchaAutocompleteModule, declarations: [MatchaAutocompleteComponent, MatchaAutocompleteDirective], imports: [CommonModule, FormsModule, MatchaOptionModule], exports: [MatchaAutocompleteComponent, MatchaAutocompleteDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MatchaAutocompleteModule, imports: [CommonModule, FormsModule, MatchaOptionModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MatchaAutocompleteModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [MatchaAutocompleteComponent, MatchaAutocompleteDirective],
+                    imports: [CommonModule, FormsModule, MatchaOptionModule],
+                    exports: [MatchaAutocompleteComponent, MatchaAutocompleteDirective],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,20 @@
+import { Directive } from '@angular/core';
+import * as i0 from "@angular/core";
+export class MatchaBadgeDirective {
+    constructor(_elementRef, _renderer) {
+        this._elementRef = _elementRef;
+        this._renderer = _renderer;
+        //this._elementRef.nativeElement.style.backgroundColor = 'grey';
+        this._renderer.addClass(this._elementRef.nativeElement, 'matcha-badge');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MatchaBadgeDirective, 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: MatchaBadgeDirective, selector: "[matcha-badge]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MatchaBadgeDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[matcha-badge]',
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFkZ2UuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbWF0Y2hhLWNvbXBvbmVudHMvc3JjL2xpYi9tYXRjaGEtYmFkZ2UvYmFkZ2UuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQXlCLE1BQU0sZUFBZSxDQUFDOztBQU1qRSxNQUFNLE9BQU8sb0JBQW9CO0lBQzdCLFlBQW9CLFdBQXVCLEVBQVUsU0FBb0I7UUFBckQsZ0JBQVcsR0FBWCxXQUFXLENBQVk7UUFBVSxjQUFTLEdBQVQsU0FBUyxDQUFXO1FBQ3JFLGdFQUFnRTtRQUNoRSxJQUFJLENBQUMsU0FBUyxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsV0FBVyxDQUFDLGFBQWEsRUFBRSxjQUFjLENBQUMsQ0FBQztJQUM1RSxDQUFDOytHQUpRLG9CQUFvQjttR0FBcEIsb0JBQW9COzs0RkFBcEIsb0JBQW9CO2tCQUpoQyxTQUFTO21CQUFDO29CQUNQLFFBQVEsRUFBRSxnQkFBZ0I7b0JBQzFCLFVBQVUsRUFBRSxLQUFLO2lCQUNwQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSwgRWxlbWVudFJlZiwgUmVuZGVyZXIyIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbkBEaXJlY3RpdmUoe1xuICAgIHNlbGVjdG9yOiAnW21hdGNoYS1iYWRnZV0nLFxuICAgIHN0YW5kYWxvbmU6IGZhbHNlXG59KVxuZXhwb3J0IGNsYXNzIE1hdGNoYUJhZGdlRGlyZWN0aXZlIHtcbiAgICBjb25zdHJ1Y3Rvcihwcml2YXRlIF9lbGVtZW50UmVmOiBFbGVtZW50UmVmLCBwcml2YXRlIF9yZW5kZXJlcjogUmVuZGVyZXIyKSB7XG4gICAgICAgIC8vdGhpcy5fZWxlbWVudFJlZi5uYXRpdmVFbGVtZW50LnN0eWxlLmJhY2tncm91bmRDb2xvciA9ICdncmV5JztcbiAgICAgICAgdGhpcy5fcmVuZGVyZXIuYWRkQ2xhc3ModGhpcy5fZWxlbWVudFJlZi5uYXRpdmVFbGVtZW50LCAnbWF0Y2hhLWJhZGdlJyk7XG4gICAgfVxufVxuIl19

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

@@ -0,0 +1,17 @@
+import { NgModule } from '@angular/core';
+import { MatchaBadgeDirective } from './badge.directive';
+import * as i0 from "@angular/core";
+export class MatchaBadgeModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MatchaBadgeModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: MatchaBadgeModule, declarations: [MatchaBadgeDirective], exports: [MatchaBadgeDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MatchaBadgeModule }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MatchaBadgeModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [MatchaBadgeDirective],
+                    imports: [],
+                    exports: [MatchaBadgeDirective],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFkZ2UubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbWF0Y2hhLWNvbXBvbmVudHMvc3JjL2xpYi9tYXRjaGEtYmFkZ2UvYmFkZ2UubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sbUJBQW1CLENBQUM7O0FBT3pELE1BQU0sT0FBTyxpQkFBaUI7K0dBQWpCLGlCQUFpQjtnSEFBakIsaUJBQWlCLGlCQUpYLG9CQUFvQixhQUV6QixvQkFBb0I7Z0hBRXJCLGlCQUFpQjs7NEZBQWpCLGlCQUFpQjtrQkFMN0IsUUFBUTttQkFBQztvQkFDTixZQUFZLEVBQUUsQ0FBQyxvQkFBb0IsQ0FBQztvQkFDcEMsT0FBTyxFQUFFLEVBQUU7b0JBQ1gsT0FBTyxFQUFFLENBQUMsb0JBQW9CLENBQUM7aUJBQ2xDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IE1hdGNoYUJhZGdlRGlyZWN0aXZlIH0gZnJvbSAnLi9iYWRnZS5kaXJlY3RpdmUnO1xuXG5ATmdNb2R1bGUoe1xuICAgIGRlY2xhcmF0aW9uczogW01hdGNoYUJhZGdlRGlyZWN0aXZlXSxcbiAgICBpbXBvcnRzOiBbXSxcbiAgICBleHBvcnRzOiBbTWF0Y2hhQmFkZ2VEaXJlY3RpdmVdLFxufSlcbmV4cG9ydCBjbGFzcyBNYXRjaGFCYWRnZU1vZHVsZSB7fVxuIl19

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

@@ -0,0 +1,205 @@
+import { Component, ElementRef, HostBinding, Inject, Input, Renderer2 } from '@angular/core';
+import * as i0 from "@angular/core";
+export class MatchaButtonComponent {
+    get colorAttr() {
+        return this.color;
+    }
+    get basic() { return this._basic; }
+    set basic(v) { this._basic = v === 'false' ? false : !!v; }
+    get outline() { return this._outline; }
+    set outline(v) { this._outline = v === 'false' ? false : !!v; }
+    get alpha() { return this._alpha; }
+    set alpha(v) { this._alpha = v === 'false' ? false : !!v; }
+    get pill() { return this._pill; }
+    set pill(v) { this._pill = v === 'false' ? false : !!v; }
+    get link() { return this._link; }
+    set link(v) { this._link = v === 'false' ? false : !!v; }
+    get icon() { return this._icon; }
+    set icon(v) { this._icon = v === 'false' ? false : !!v; }
+    constructor(_elementRef, _renderer) {
+        this._elementRef = _elementRef;
+        this._renderer = _renderer;
+        this.size = null;
+        this.sizeXs = null;
+        this.sizeSm = null;
+        this.sizeMd = null;
+        this.sizeLg = null;
+        this.sizeXl = null;
+        this.color = 'basic';
+        this._basic = false;
+        this._outline = false;
+        this._alpha = false;
+        this._pill = false;
+        this._link = false;
+        this._icon = false;
+        this._config = {
+            sizeXs: 'tiny',
+            sizeSm: 'small',
+            sizeMd: 'medium',
+            sizeLg: 'large',
+            sizeXl: 'huge',
+            size: 'medium',
+            basic: false,
+            outline: false,
+            pill: false,
+            icon: false,
+            link: false
+        };
+    }
+    ngOnInit() {
+        this._renderer.addClass(this._elementRef.nativeElement, `matcha-button`);
+        this.setConfig();
+        // Adicione o evento de clique apenas a elementos com a classe "matcha-button"
+        const buttons = document.querySelectorAll('.matcha-button');
+        buttons.forEach(button => {
+            // mouse down event
+            button.addEventListener('mousedown', this.addRippleEffect, false);
+        });
+    }
+    ngOnChanges() {
+        this.setConfig();
+    }
+    clearConfig() {
+        //size
+        this._renderer.removeClass(this._elementRef.nativeElement, `matcha-button-${this._config.size}`);
+        this._renderer.removeClass(this._elementRef.nativeElement, `matcha-button-xs-${this._config.sizeXs}`);
+        this._renderer.removeClass(this._elementRef.nativeElement, `matcha-button-sm-${this._config.sizeSm}`);
+        this._renderer.removeClass(this._elementRef.nativeElement, `matcha-button-md-${this._config.sizeMd}`);
+        this._renderer.removeClass(this._elementRef.nativeElement, `matcha-button-lg-${this._config.sizeLg}`);
+        this._renderer.removeClass(this._elementRef.nativeElement, `matcha-button-xl-${this._config.sizeXl}`);
+        //basic
+        this._renderer.removeClass(this._elementRef.nativeElement, `matcha-button-icon`);
+        //outline
+        this._renderer.removeClass(this._elementRef.nativeElement, `matcha-button-outline`);
+        //pill
+        this._renderer.removeClass(this._elementRef.nativeElement, `matcha-button-pill`);
+        //icon
+        this._renderer.removeClass(this._elementRef.nativeElement, `matcha-button-basic`);
+        //link
+        this._renderer.removeClass(this._elementRef.nativeElement, `matcha-button-link`);
+    }
+    setConfig() {
+        this.clearConfig();
+        this.size ? this.setSize() : null;
+        (this.outline === true || this.outline === 'true') ? this.setOutline() : null;
+        (this.pill === true || this.pill === 'true') ? this.setPill() : null;
+        (this.link === true || this.link === 'true') ? this.setLink() : null;
+        (this.basic === true || this.basic === 'true') ? this.setBasic() : null;
+        (this.icon === true || this.icon === 'true') ? this.setIcon() : null;
+    }
+    setSize() {
+        this._renderer.addClass(this._elementRef.nativeElement, `matcha-button-${this.size}`);
+        this._config.size = this.size;
+        if (this.sizeXs) {
+            this._renderer.addClass(this._elementRef.nativeElement, `matcha-button-xs-${this.sizeXs}`);
+            this._config.sizeXs = this.sizeXs;
+        }
+        if (this.sizeSm) {
+            this._renderer.addClass(this._elementRef.nativeElement, `matcha-button-sm-${this.sizeSm}`);
+            this._config.sizeSm = this.sizeSm;
+        }
+        if (this.sizeMd) {
+            this._renderer.addClass(this._elementRef.nativeElement, `matcha-button-md-${this.sizeMd}`);
+            this._config.sizeMd = this.sizeMd;
+        }
+        if (this.sizeLg) {
+            this._renderer.addClass(this._elementRef.nativeElement, `matcha-button-lg-${this.sizeLg}`);
+            this._config.sizeLg = this.sizeLg;
+        }
+        if (this.sizeXl) {
+            this._renderer.addClass(this._elementRef.nativeElement, `matcha-button-xl-${this.sizeXl}`);
+            this._config.sizeXl = this.sizeXl;
+        }
+    }
+    setOutline() {
+        this._renderer.addClass(this._elementRef.nativeElement, `matcha-button-outline`);
+    }
+    setPill() {
+        this._renderer.addClass(this._elementRef.nativeElement, `matcha-button-pill`);
+    }
+    setLink() {
+        this._renderer.addClass(this._elementRef.nativeElement, `matcha-button-link`);
+    }
+    setBasic() {
+        this._renderer.addClass(this._elementRef.nativeElement, `matcha-button-basic`);
+        this._renderer.addClass(this._elementRef.nativeElement, `basic`);
+    }
+    setIcon() {
+        this._renderer.addClass(this._elementRef.nativeElement, `matcha-button-icon`);
+    }
+    addRippleEffect(e) {
+        var target = e.target;
+        if (target.tagName.toLowerCase() !== 'button')
+            return false;
+        var rect = target.getBoundingClientRect();
+        var ripple = target.querySelector('.ripple');
+        if (!ripple) {
+            ripple = document.createElement('span');
+            ripple.className = `ripple`;
+            ripple.style.height = ripple.style.width = target.offsetWidth + 'px';
+            target.appendChild(ripple);
+        }
+        ripple.classList.remove('show');
+        var top = e.pageY - rect.top - ripple.offsetHeight / 2 - window.scrollY;
+        var left = e.pageX - rect.left - ripple.offsetWidth / 2 - window.scrollX;
+        ripple.style.top = top + 'px';
+        ripple.style.left = left + 'px';
+        ripple.classList.add('show');
+        return false;
+    }
+    ngOnDestroy() {
+        const buttons = document.querySelectorAll('.matcha-button');
+        buttons.forEach(button => {
+            button.removeEventListener('click', this.addRippleEffect, false);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MatchaButtonComponent, deps: [{ token: ElementRef }, { token: Renderer2 }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: MatchaButtonComponent, selector: "[matcha-button]", inputs: { size: "size", sizeXs: ["size-xs", "sizeXs"], sizeSm: ["size-sm", "sizeSm"], sizeMd: ["size-md", "sizeMd"], sizeLg: ["size-lg", "sizeLg"], sizeXl: ["size-xl", "sizeXl"], color: "color", basic: "basic", outline: "outline", alpha: "alpha", pill: "pill", link: "link", icon: "icon" }, host: { properties: { "attr.color": "this.colorAttr" } }, usesOnChanges: true, ngImport: i0, template: "<ng-content></ng-content>\n", styles: [""] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MatchaButtonComponent, decorators: [{
+            type: Component,
+            args: [{ selector: '[matcha-button]', standalone: false, template: "<ng-content></ng-content>\n" }]
+        }], ctorParameters: () => [{ type: i0.ElementRef, decorators: [{
+                    type: Inject,
+                    args: [ElementRef]
+                }] }, { type: i0.Renderer2, decorators: [{
+                    type: Inject,
+                    args: [Renderer2]
+                }] }], propDecorators: { size: [{
+                type: Input,
+                args: ['size']
+            }], sizeXs: [{
+                type: Input,
+                args: ['size-xs']
+            }], sizeSm: [{
+                type: Input,
+                args: ['size-sm']
+            }], sizeMd: [{
+                type: Input,
+                args: ['size-md']
+            }], sizeLg: [{
+                type: Input,
+                args: ['size-lg']
+            }], sizeXl: [{
+                type: Input,
+                args: ['size-xl']
+            }], color: [{
+                type: Input,
+                args: ['color']
+            }], colorAttr: [{
+                type: HostBinding,
+                args: ['attr.color']
+            }], basic: [{
+                type: Input
+            }], outline: [{
+                type: Input
+            }], alpha: [{
+                type: Input
+            }], pill: [{
+                type: Input
+            }], link: [{
+                type: Input
+            }], icon: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"button.component.js","sourceRoot":"","sources":["../../../../../../projects/matcha-components/src/lib/matcha-button/button/button.component.ts","../../../../../../projects/matcha-components/src/lib/matcha-button/button/button.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,EAAE,KAAK,EAAqB,SAAS,EAAE,MAAM,eAAe,CAAC;;AAQhH,MAAM,OAAO,qBAAqB;IAW9B,IACI,SAAS;QACT,OAAO,IAAI,CAAC,KAAK,CAAC;IACtB,CAAC;IAGD,IAAa,KAAK,KAAK,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IAC5C,IAAI,KAAK,CAAC,CAAmB,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAG7E,IAAa,OAAO,KAAK,OAAO,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;IAChD,IAAI,OAAO,CAAC,CAAmB,IAAI,IAAI,CAAC,QAAQ,GAAG,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA,CAAC;IAGhF,IAAa,KAAK,KAAK,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IAC5C,IAAI,KAAK,CAAC,CAAmB,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA,CAAC;IAG5E,IAAa,IAAI,KAAK,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;IAC1C,IAAI,IAAI,CAAC,CAAmB,IAAI,IAAI,CAAC,KAAK,GAAG,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA,CAAC;IAG1E,IAAa,IAAI,KAAK,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;IAC1C,IAAI,IAAI,CAAC,CAAmB,IAAI,IAAI,CAAC,KAAK,GAAG,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA,CAAC;IAG1E,IAAa,IAAI,KAAK,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;IAC1C,IAAI,IAAI,CAAC,CAAmB,IAAI,IAAI,CAAC,KAAK,GAAG,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA,CAAC;IAE1E,YAAwC,WAAuB,EAA6B,SAAoB;QAAxE,gBAAW,GAAX,WAAW,CAAY;QAA6B,cAAS,GAAT,SAAS,CAAW;QAvCjG,SAAI,GAAkB,IAAI,CAAC;QAExB,WAAM,GAAkB,IAAI,CAAC;QAC7B,WAAM,GAAkB,IAAI,CAAC;QAC7B,WAAM,GAAkB,IAAI,CAAC;QAC7B,WAAM,GAAkB,IAAI,CAAC;QAC7B,WAAM,GAAkB,IAAI,CAAC;QAE/B,UAAK,GAAkB,OAAO,CAAC;QAOvC,WAAM,GAAG,KAAK,CAAC;QAIf,aAAQ,GAAG,KAAK,CAAC;QAIjB,WAAM,GAAG,KAAK,CAAC;QAIf,UAAK,GAAG,KAAK,CAAC;QAId,UAAK,GAAG,KAAK,CAAC;QAId,UAAK,GAAG,KAAK,CAAC;QAMd,YAAO,GAAQ;YACnB,MAAM,EAAE,MAAM;YACd,MAAM,EAAE,OAAO;YACf,MAAM,EAAE,QAAQ;YAChB,MAAM,EAAE,OAAO;YACf,MAAM,EAAE,MAAM;YACd,IAAI,EAAE,QAAQ;YACd,KAAK,EAAE,KAAK;YACZ,OAAO,EAAE,KAAK;YACd,IAAI,EAAE,KAAK;YACX,IAAI,EAAE,KAAK;YACX,IAAI,EAAE,KAAK;SACd,CAAC;IAdiH,CAAC;IAgBpH,QAAQ;QACJ,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE,eAAe,CAAC,CAAC;QACzE,IAAI,CAAC,SAAS,EAAE,CAAC;QACjB,8EAA8E;QAC9E,MAAM,OAAO,GAAG,QAAQ,CAAC,gBAAgB,CAAC,gBAAgB,CAAC,CAAC;QAC5D,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;YACrB,mBAAmB;YACnB,MAAM,CAAC,gBAAgB,CAAC,WAAW,EAAE,IAAI,CAAC,eAAe,EAAE,KAAK,CAAC,CAAC;QACtE,CAAC,CAAC,CAAC;IACP,CAAC;IAED,WAAW;QACP,IAAI,CAAC,SAAS,EAAE,CAAC;IACrB,CAAC;IAEO,WAAW;QACf,MAAM;QACN,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE,iBAAiB,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC;QACjG,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE,oBAAoB,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;QACtG,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE,oBAAoB,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;QACtG,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE,oBAAoB,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;QACtG,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE,oBAAoB,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;QACtG,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE,oBAAoB,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;QACtG,OAAO;QACP,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE,oBAAoB,CAAC,CAAC;QACjF,SAAS;QACT,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE,uBAAuB,CAAC,CAAC;QACpF,MAAM;QACN,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE,oBAAoB,CAAC,CAAC;QACjF,MAAM;QACN,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE,qBAAqB,CAAC,CAAC;QAClF,MAAM;QACN,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE,oBAAoB,CAAC,CAAC;IACrF,CAAC;IAEO,SAAS;QACb,IAAI,CAAC,WAAW,EAAE,CAAC;QACnB,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;QAClC,CAAC,IAAI,CAAC,OAAO,KAAK,IAAI,IAAI,IAAI,CAAC,OAAO,KAAK,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;QAC9E,CAAC,IAAI,CAAC,IAAI,KAAK,IAAI,IAAI,IAAI,CAAC,IAAI,KAAK,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;QACrE,CAAC,IAAI,CAAC,IAAI,KAAK,IAAI,IAAI,IAAI,CAAC,IAAI,KAAK,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;QACrE,CAAC,IAAI,CAAC,KAAK,KAAK,IAAI,IAAI,IAAI,CAAC,KAAK,KAAK,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;QACxE,CAAC,IAAI,CAAC,IAAI,KAAK,IAAI,IAAI,IAAI,CAAC,IAAI,KAAK,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;IACzE,CAAC;IAEO,OAAO;QACX,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE,iBAAiB,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;QACtF,IAAI,CAAC,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QAC9B,IAAG,IAAI,CAAC,MAAM,EAAE,CAAC;YACb,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE,oBAAoB,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;YAC3F,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;QACtC,CAAC;QACD,IAAG,IAAI,CAAC,MAAM,EAAE,CAAC;YACb,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE,oBAAoB,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;YAC3F,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;QACtC,CAAC;QACD,IAAG,IAAI,CAAC,MAAM,EAAE,CAAC;YACb,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE,oBAAoB,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;YAC3F,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;QACtC,CAAC;QACD,IAAG,IAAI,CAAC,MAAM,EAAE,CAAC;YACb,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE,oBAAoB,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;YAC3F,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;QACtC,CAAC;QACD,IAAG,IAAI,CAAC,MAAM,EAAE,CAAC;YACb,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE,oBAAoB,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;YAC3F,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;QACtC,CAAC;IACL,CAAC;IAEO,UAAU;QACd,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE,uBAAuB,CAAC,CAAC;IACrF,CAAC;IAEO,OAAO;QACX,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE,oBAAoB,CAAC,CAAC;IAClF,CAAC;IAEO,OAAO;QACX,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE,oBAAoB,CAAC,CAAC;IAClF,CAAC;IAEO,QAAQ;QACZ,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE,qBAAqB,CAAC,CAAC;QAC/E,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC;IACrE,CAAC;IAEO,OAAO;QACX,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE,oBAAoB,CAAC,CAAC;IAClF,CAAC;IAEO,eAAe,CAAC,CAAM;QAC1B,IAAI,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC;QACtB,IAAI,MAAM,CAAC,OAAO,CAAC,WAAW,EAAE,KAAK,QAAQ;YAAE,OAAO,KAAK,CAAC;QAC5D,IAAI,IAAI,GAAG,MAAM,CAAC,qBAAqB,EAAE,CAAC;QAC1C,IAAI,MAAM,GAAG,MAAM,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC;QAC7C,IAAI,CAAC,MAAM,EAAE,CAAC;YACV,MAAM,GAAG,QAAQ,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;YACxC,MAAM,CAAC,SAAS,GAAG,QAAQ,CAAC;YAC5B,MAAM,CAAC,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,KAAK,GAAG,MAAM,CAAC,WAAW,GAAG,IAAI,CAAC;YACrE,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;QAC/B,CAAC;QACD,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QAChC,IAAI,GAAG,GAAG,CAAC,CAAC,KAAK,GAAG,IAAI,CAAC,GAAG,GAAG,MAAM,CAAC,YAAY,GAAG,CAAC,GAAG,MAAM,CAAC,OAAO,CAAC;QACxE,IAAI,IAAI,GAAG,CAAC,CAAC,KAAK,GAAG,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC,WAAW,GAAG,CAAC,GAAG,MAAM,CAAC,OAAO,CAAC;QACzE,MAAM,CAAC,KAAK,CAAC,GAAG,GAAG,GAAG,GAAG,IAAI,CAAC;QAC9B,MAAM,CAAC,KAAK,CAAC,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;QAChC,MAAM,CAAC,SAAS,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QAC7B,OAAO,KAAK,CAAC;IACjB,CAAC;IAED,WAAW;QACP,MAAM,OAAO,GAAG,QAAQ,CAAC,gBAAgB,CAAC,gBAAgB,CAAC,CAAC;QAC5D,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;YACrB,MAAM,CAAC,mBAAmB,CAAC,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,KAAK,CAAC,CAAC;QACrE,CAAC,CAAC,CAAC;IACP,CAAC;+GA5KQ,qBAAqB,kBAwCV,UAAU,aAA2C,SAAS;mGAxCzE,qBAAqB,yaCRlC,6BACA;;4FDOa,qBAAqB;kBANjC,SAAS;+BACI,iBAAiB,cAGf,KAAK;;0BA0CJ,MAAM;2BAAC,UAAU;;0BAAoC,MAAM;2BAAC,SAAS;yCAvCnE,IAAI;sBAAlB,KAAK;uBAAC,MAAM;gBAEK,MAAM;sBAAvB,KAAK;uBAAC,SAAS;gBACE,MAAM;sBAAvB,KAAK;uBAAC,SAAS;gBACE,MAAM;sBAAvB,KAAK;uBAAC,SAAS;gBACE,MAAM;sBAAvB,KAAK;uBAAC,SAAS;gBACE,MAAM;sBAAvB,KAAK;uBAAC,SAAS;gBAEA,KAAK;sBAApB,KAAK;uBAAC,OAAO;gBAGV,SAAS;sBADZ,WAAW;uBAAC,YAAY;gBAMZ,KAAK;sBAAjB,KAAK;gBAIO,OAAO;sBAAnB,KAAK;gBAIO,KAAK;sBAAjB,KAAK;gBAIO,IAAI;sBAAhB,KAAK;gBAIO,IAAI;sBAAhB,KAAK;gBAIO,IAAI;sBAAhB,KAAK","sourcesContent":["import { Component, ElementRef, HostBinding, Inject, Input, OnChanges, OnInit, Renderer2 } from '@angular/core';\n\n@Component({\n    selector: '[matcha-button]',\n    templateUrl: './button.component.html',\n    styleUrls: ['./button.component.scss'],\n    standalone: false\n})\nexport class MatchaButtonComponent implements OnChanges, OnInit {\n    @Input('size') size: string | null = null;\n\n    @Input('size-xs') sizeXs: string | null = null;\n    @Input('size-sm') sizeSm: string | null = null;\n    @Input('size-md') sizeMd: string | null = null;\n    @Input('size-lg') sizeLg: string | null = null;\n    @Input('size-xl') sizeXl: string | null = null;\n\n    @Input('color') color: string | null = 'basic';\n\n    @HostBinding('attr.color')\n    get colorAttr(): string | null {\n        return this.color;\n    }\n\n    private _basic = false;\n    @Input() get basic() { return this._basic; }\n    set basic(v: boolean | string) { this._basic = v === 'false' ? false : !!v; }\n\n    private _outline = false;\n    @Input() get outline() { return this._outline; }\n    set outline(v: boolean | string) { this._outline = v === 'false' ? false : !!v;}\n\n    private _alpha = false;\n    @Input() get alpha() { return this._alpha; }\n    set alpha(v: boolean | string) { this._alpha = v === 'false' ? false : !!v;}\n\n    private _pill = false;\n    @Input() get pill() { return this._pill; }\n    set pill(v: boolean | string) { this._pill = v === 'false' ? false : !!v;}\n\n    private _link = false;\n    @Input() get link() { return this._link; }\n    set link(v: boolean | string) { this._link = v === 'false' ? false : !!v;}\n\n    private _icon = false;\n    @Input() get icon() { return this._icon; }\n    set icon(v: boolean | string) { this._icon = v === 'false' ? false : !!v;}\n\n    constructor(@Inject(ElementRef) private _elementRef: ElementRef, @Inject(Renderer2) private _renderer: Renderer2) {}\n\n    private _config: any = {\n        sizeXs: 'tiny',\n        sizeSm: 'small',\n        sizeMd: 'medium',\n        sizeLg: 'large',\n        sizeXl: 'huge',\n        size: 'medium',\n        basic: false,\n        outline: false,\n        pill: false,\n        icon: false,\n        link: false\n    };\n\n    ngOnInit() {\n        this._renderer.addClass(this._elementRef.nativeElement, `matcha-button`);\n        this.setConfig();\n        // Adicione o evento de clique apenas a elementos com a classe \"matcha-button\"\n        const buttons = document.querySelectorAll('.matcha-button');\n        buttons.forEach(button => {\n            // mouse down event\n            button.addEventListener('mousedown', this.addRippleEffect, false);\n        });\n    }\n\n    ngOnChanges() {\n        this.setConfig();\n    }\n\n    private clearConfig() {\n        //size\n        this._renderer.removeClass(this._elementRef.nativeElement, `matcha-button-${this._config.size}`);\n        this._renderer.removeClass(this._elementRef.nativeElement, `matcha-button-xs-${this._config.sizeXs}`);\n        this._renderer.removeClass(this._elementRef.nativeElement, `matcha-button-sm-${this._config.sizeSm}`);\n        this._renderer.removeClass(this._elementRef.nativeElement, `matcha-button-md-${this._config.sizeMd}`);\n        this._renderer.removeClass(this._elementRef.nativeElement, `matcha-button-lg-${this._config.sizeLg}`);\n        this._renderer.removeClass(this._elementRef.nativeElement, `matcha-button-xl-${this._config.sizeXl}`);\n        //basic\n        this._renderer.removeClass(this._elementRef.nativeElement, `matcha-button-icon`);\n        //outline\n        this._renderer.removeClass(this._elementRef.nativeElement, `matcha-button-outline`);\n        //pill\n        this._renderer.removeClass(this._elementRef.nativeElement, `matcha-button-pill`);\n        //icon\n        this._renderer.removeClass(this._elementRef.nativeElement, `matcha-button-basic`);\n        //link\n        this._renderer.removeClass(this._elementRef.nativeElement, `matcha-button-link`);\n    }\n\n    private setConfig() {\n        this.clearConfig();\n        this.size ? this.setSize() : null;\n        (this.outline === true || this.outline === 'true') ? this.setOutline() : null;\n        (this.pill === true || this.pill === 'true') ? this.setPill() : null;\n        (this.link === true || this.link === 'true') ? this.setLink() : null;\n        (this.basic === true || this.basic === 'true') ? this.setBasic() : null;\n        (this.icon === true || this.icon === 'true') ? this.setIcon() : null;\n    }\n\n    private setSize() {\n        this._renderer.addClass(this._elementRef.nativeElement, `matcha-button-${this.size}`);\n        this._config.size = this.size;\n        if(this.sizeXs) {\n            this._renderer.addClass(this._elementRef.nativeElement, `matcha-button-xs-${this.sizeXs}`);\n            this._config.sizeXs = this.sizeXs;\n        }\n        if(this.sizeSm) {\n            this._renderer.addClass(this._elementRef.nativeElement, `matcha-button-sm-${this.sizeSm}`);\n            this._config.sizeSm = this.sizeSm;\n        }\n        if(this.sizeMd) {\n            this._renderer.addClass(this._elementRef.nativeElement, `matcha-button-md-${this.sizeMd}`);\n            this._config.sizeMd = this.sizeMd;\n        }\n        if(this.sizeLg) {\n            this._renderer.addClass(this._elementRef.nativeElement, `matcha-button-lg-${this.sizeLg}`);\n            this._config.sizeLg = this.sizeLg;\n        }\n        if(this.sizeXl) {\n            this._renderer.addClass(this._elementRef.nativeElement, `matcha-button-xl-${this.sizeXl}`);\n            this._config.sizeXl = this.sizeXl;\n        }\n    }\n\n    private setOutline() {\n        this._renderer.addClass(this._elementRef.nativeElement, `matcha-button-outline`);\n    }\n\n    private setPill() {\n        this._renderer.addClass(this._elementRef.nativeElement, `matcha-button-pill`);\n    }\n\n    private setLink() {\n        this._renderer.addClass(this._elementRef.nativeElement, `matcha-button-link`);\n    }\n\n    private setBasic() {\n        this._renderer.addClass(this._elementRef.nativeElement, `matcha-button-basic`);\n        this._renderer.addClass(this._elementRef.nativeElement, `basic`);\n    }\n\n    private setIcon() {\n        this._renderer.addClass(this._elementRef.nativeElement, `matcha-button-icon`);\n    }\n\n    private addRippleEffect(e: any) {\n        var target = e.target;\n        if (target.tagName.toLowerCase() !== 'button') return false;\n        var rect = target.getBoundingClientRect();\n        var ripple = target.querySelector('.ripple');\n        if (!ripple) {\n            ripple = document.createElement('span');\n            ripple.className = `ripple`;\n            ripple.style.height = ripple.style.width = target.offsetWidth + 'px';\n            target.appendChild(ripple);\n        }\n        ripple.classList.remove('show');\n        var top = e.pageY - rect.top - ripple.offsetHeight / 2 - window.scrollY;\n        var left = e.pageX - rect.left - ripple.offsetWidth / 2 - window.scrollX;\n        ripple.style.top = top + 'px';\n        ripple.style.left = left + 'px';\n        ripple.classList.add('show');\n        return false;\n    }\n\n    ngOnDestroy() {\n        const buttons = document.querySelectorAll('.matcha-button');\n        buttons.forEach(button => {\n            button.removeEventListener('click', this.addRippleEffect, false);\n        });\n    }\n}\n","<ng-content></ng-content>\n"]}

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

@@ -0,0 +1,17 @@
+import { NgModule } from '@angular/core';
+import { MatchaButtonComponent } from './button/button.component';
+import * as i0 from "@angular/core";
+export class MatchaButtonModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MatchaButtonModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: MatchaButtonModule, declarations: [MatchaButtonComponent], exports: [MatchaButtonComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MatchaButtonModule }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MatchaButtonModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [MatchaButtonComponent],
+                    imports: [],
+                    exports: [MatchaButtonComponent],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnV0dG9uLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL21hdGNoYS1jb21wb25lbnRzL3NyYy9saWIvbWF0Y2hhLWJ1dHRvbi9idXR0b24ubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFekMsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sMkJBQTJCLENBQUM7O0FBT2xFLE1BQU0sT0FBTyxrQkFBa0I7K0dBQWxCLGtCQUFrQjtnSEFBbEIsa0JBQWtCLGlCQUpaLHFCQUFxQixhQUUxQixxQkFBcUI7Z0hBRXRCLGtCQUFrQjs7NEZBQWxCLGtCQUFrQjtrQkFMOUIsUUFBUTttQkFBQztvQkFDTixZQUFZLEVBQUUsQ0FBQyxxQkFBcUIsQ0FBQztvQkFDckMsT0FBTyxFQUFFLEVBQUU7b0JBQ1gsT0FBTyxFQUFFLENBQUMscUJBQXFCLENBQUM7aUJBQ25DIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHsgTWF0Y2hhQnV0dG9uQ29tcG9uZW50IH0gZnJvbSAnLi9idXR0b24vYnV0dG9uLmNvbXBvbmVudCc7XG5cbkBOZ01vZHVsZSh7XG4gICAgZGVjbGFyYXRpb25zOiBbTWF0Y2hhQnV0dG9uQ29tcG9uZW50XSxcbiAgICBpbXBvcnRzOiBbXSxcbiAgICBleHBvcnRzOiBbTWF0Y2hhQnV0dG9uQ29tcG9uZW50XSxcbn0pXG5leHBvcnQgY2xhc3MgTWF0Y2hhQnV0dG9uTW9kdWxlIHt9XG4iXX0=

package/esm2022/lib/matcha-button-toggle/button-toggle/button-toggle.component.mjs

@@ -0,0 +1,88 @@
+import { Component, ContentChildren, HostBinding, Input } from '@angular/core';
+import { MatchaButtonComponent } from '../../matcha-button/button/button.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class MatchaButtonToggleComponent {
+    get multiple() { return this._multiple; }
+    set multiple(v) { this._multiple = v === 'false' ? false : !!v; }
+    get disabled() { return this._disabled; }
+    set disabled(v) { this._disabled = v === 'false' ? false : !!v; }
+    get isDisabled() { return this.disabled || null; }
+    get required() { return this._required; }
+    set required(v) { this._required = v === 'false' ? false : !!v; }
+    set gap(v) { const n = +v; this._gap = isNaN(n) ? 16 : n; }
+    get gapClass() { return `gap-${this._gap}`; }
+    get gap() {
+        return this._gap;
+    }
+    constructor(elementRef) {
+        this.elementRef = elementRef;
+        this._multiple = false;
+        this._disabled = false;
+        this._required = false;
+        this.inactiveColor = 'primary';
+        this.inactiveType = 'solid';
+        this._gap = 16;
+    }
+    ngAfterContentInit() {
+        const buttons = this.elementRef.nativeElement.querySelectorAll('button[matcha-button]');
+        buttons.forEach((button, index) => {
+            const isActive = button.hasAttribute('active');
+            this.setButtonState(button, isActive);
+            button.addEventListener('click', () => this.onButtonSelected(button));
+        });
+    }
+    setButtonState(button, isActive) {
+        if (isActive) {
+            button.setAttribute('active', '');
+        }
+        else {
+            button.removeAttribute('active');
+        }
+    }
+    onButtonSelected(selectedButton) {
+        const buttons = this.elementRef.nativeElement.querySelectorAll('button[matcha-button]');
+        const activeButtons = Array.from(buttons).filter((button) => button.hasAttribute('active'));
+        if (this.required && activeButtons.length === 1 && activeButtons[0] === selectedButton) {
+            return;
+        }
+        if (this.multiple) {
+            const isActive = selectedButton.hasAttribute('active');
+            this.setButtonState(selectedButton, !isActive);
+            return;
+        }
+        if (selectedButton.hasAttribute('active')) {
+            this.setButtonState(selectedButton, false);
+        }
+        else {
+            buttons.forEach((button) => {
+                this.setButtonState(button, button === selectedButton);
+            });
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MatchaButtonToggleComponent, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: MatchaButtonToggleComponent, selector: "matcha-button-toggle", inputs: { multiple: "multiple", disabled: "disabled", required: "required", inactiveColor: "inactiveColor", inactiveType: "inactiveType", gap: "gap" }, host: { properties: { "attr.disabled": "this.isDisabled" } }, queries: [{ propertyName: "buttons", predicate: MatchaButtonComponent }], ngImport: i0, template: "<div\n  class=\"button-group d-flex\"\n  [ngClass]=\"gapClass\"\n  [class.flex-wrap]=\"gap !== 0\"\n  role=\"group\"\n>\n  <ng-content></ng-content>\n</div>\n", styles: [""], dependencies: [{ kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MatchaButtonToggleComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'matcha-button-toggle', standalone: false, template: "<div\n  class=\"button-group d-flex\"\n  [ngClass]=\"gapClass\"\n  [class.flex-wrap]=\"gap !== 0\"\n  role=\"group\"\n>\n  <ng-content></ng-content>\n</div>\n" }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }], propDecorators: { multiple: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], isDisabled: [{
+                type: HostBinding,
+                args: ['attr.disabled']
+            }], required: [{
+                type: Input
+            }], inactiveColor: [{
+                type: Input
+            }], inactiveType: [{
+                type: Input
+            }], gap: [{
+                type: Input
+            }], buttons: [{
+                type: ContentChildren,
+                args: [MatchaButtonComponent]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"button-toggle.component.js","sourceRoot":"","sources":["../../../../../../projects/matcha-components/src/lib/matcha-button-toggle/button-toggle/button-toggle.component.ts","../../../../../../projects/matcha-components/src/lib/matcha-button-toggle/button-toggle/button-toggle.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterContentInit, Component, ContentChildren, HostBinding,\n  Input, QueryList, ElementRef\n} from '@angular/core';\nimport { MatchaButtonComponent } from '../../matcha-button/button/button.component';\n\n@Component({\n  selector: 'matcha-button-toggle',\n  templateUrl: './button-toggle.component.html',\n  styleUrl: './button-toggle.component.scss',\n  standalone: false\n})\nexport class MatchaButtonToggleComponent implements AfterContentInit {\n\n    private _multiple = false;\n  @Input() get multiple() { return this._multiple; }\n  set multiple(v: boolean | string) { this._multiple = v === 'false' ? false : !!v; }\n\n  private _disabled = false;\n  @Input() get disabled() { return this._disabled; }\n  set disabled(v: boolean | string) { this._disabled = v === 'false' ? false : !!v; }\n  @HostBinding('attr.disabled') get isDisabled() { return this.disabled || null; }\n\n  private _required = false;\n  @Input() get required() { return this._required; }\n  set required(v: boolean | string) { this._required = v === 'false' ? false : !!v; }\n\n  @Input() inactiveColor = 'primary';\n\n  @Input() inactiveType: string = 'solid';\n\n  private _gap = 16;\n  @Input() set gap(v: string | number) { const n = +v; this._gap = isNaN(n) ? 16 : n; }\n  get gapClass() { return `gap-${this._gap}`; }\n\n  get gap(): number {\n    return this._gap;\n  }\n\n  @ContentChildren(MatchaButtonComponent)\n  buttons!: QueryList<MatchaButtonComponent>;\n\n  constructor(private elementRef: ElementRef) {}\n\n  ngAfterContentInit(): void {\n    const buttons = this.elementRef.nativeElement.querySelectorAll('button[matcha-button]');\n    buttons.forEach((button: Element, index: number) => {\n      const isActive = button.hasAttribute('active');\n      this.setButtonState(button as HTMLElement, isActive);\n\n      button.addEventListener('click', () => this.onButtonSelected(button as HTMLElement));\n    });\n  }\n\n  private setButtonState(button: HTMLElement, isActive: boolean): void {\n    if (isActive) {\n      button.setAttribute('active', '');\n    } else {\n      button.removeAttribute('active');\n    }\n  }\n\n  private onButtonSelected(selectedButton: HTMLElement): void {\n    const buttons = this.elementRef.nativeElement.querySelectorAll('button[matcha-button]');\n    const activeButtons = Array.from(buttons).filter((button: unknown) =>\n      (button as Element).hasAttribute('active')\n    );\n\n    if (this.required && activeButtons.length === 1 && activeButtons[0] === selectedButton) {\n      return;\n    }\n\n    if (this.multiple) {\n      const isActive = selectedButton.hasAttribute('active');\n      this.setButtonState(selectedButton, !isActive);\n      return;\n    }\n\n    if (selectedButton.hasAttribute('active')) {\n      this.setButtonState(selectedButton, false);\n    } else {\n      buttons.forEach((button: Element) => {\n        this.setButtonState(button as HTMLElement, button === selectedButton);\n      });\n    }\n  }\n}\n","<div\n  class=\"button-group d-flex\"\n  [ngClass]=\"gapClass\"\n  [class.flex-wrap]=\"gap !== 0\"\n  role=\"group\"\n>\n  <ng-content></ng-content>\n</div>\n"]}

package/esm2022/lib/matcha-button-toggle/button-toggle.module.mjs

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