@schenkerjon/ng-govbr-tw 0.4.0 → 1.0.0

package/esm2022/lib/animations/animate.directive.mjs

@@ -0,0 +1,239 @@
+import { Directive, ElementRef, Input, Output, EventEmitter, inject, effect, } from '@angular/core';
+import { BrAnimationService } from './animation.service';
+import * as i0 from "@angular/core";
+/**
+ * Diretiva para aplicar animações a qualquer elemento
+ *
+ * @example
+ * <!-- Animação imediata -->
+ * <div brAnimate="fadeInUp">Conteúdo</div>
+ *
+ * <!-- Animação quando visível -->
+ * <div brAnimate="fadeInUp" brAnimateTrigger="visible">Conteúdo</div>
+ *
+ * <!-- Com configurações -->
+ * <div brAnimate="scaleIn" [brAnimateDuration]="300" brAnimateEasing="easeOutBack">
+ *   Conteúdo
+ * </div>
+ *
+ * <!-- Stagger em lista -->
+ * <ul>
+ *   <li *ngFor="let item of items; let i = index"
+ *       brAnimate="fadeInUp"
+ *       [brAnimateDelay]="i * 50">
+ *     {{ item }}
+ *   </li>
+ * </ul>
+ */
+export class BrAnimateDirective {
+    constructor() {
+        this.el = inject(ElementRef);
+        this.animationService = inject(BrAnimationService);
+        /** Tipo de animação */
+        this.animation = 'fadeIn';
+        /** Trigger que inicia a animação */
+        this.brAnimateTrigger = 'immediate';
+        /** Threshold para Intersection Observer (0-1) */
+        this.brAnimateThreshold = 0.1;
+        /** Se deve animar apenas uma vez */
+        this.brAnimateOnce = true;
+        /** Se a animação está habilitada */
+        this.brAnimateEnabled = true;
+        /** Evento emitido no início da animação */
+        this.brAnimateStart = new EventEmitter();
+        /** Evento emitido no fim da animação */
+        this.brAnimateEnd = new EventEmitter();
+        this.hasAnimated = false;
+        this.boundHandleAnimationEnd = this.handleAnimationEnd.bind(this);
+        this.boundHandleHover = this.handleHover.bind(this);
+        this.boundHandleHoverOut = this.handleHoverOut.bind(this);
+        this.boundHandleFocus = this.handleFocus.bind(this);
+        this.boundHandleBlur = this.handleBlur.bind(this);
+        this.boundHandleClick = this.handleClick.bind(this);
+        // Reage a mudanças no serviço de animação
+        effect(() => {
+            if (!this.animationService.isEnabled()) {
+                this.clearAnimation();
+            }
+        });
+    }
+    ngOnInit() {
+        if (!this.brAnimateEnabled)
+            return;
+        this.setupTrigger();
+    }
+    ngOnDestroy() {
+        this.cleanup();
+    }
+    /**
+     * Inicia a animação programaticamente
+     */
+    play() {
+        if (!this.canAnimate())
+            return;
+        this.applyAnimation();
+    }
+    /**
+     * Reseta a animação para poder rodar novamente
+     */
+    reset() {
+        this.hasAnimated = false;
+        this.clearAnimation();
+    }
+    setupTrigger() {
+        const element = this.el.nativeElement;
+        switch (this.brAnimateTrigger) {
+            case 'immediate':
+                // Pequeno delay para garantir que o elemento está no DOM
+                requestAnimationFrame(() => this.play());
+                break;
+            case 'visible':
+                this.setupIntersectionObserver();
+                break;
+            case 'hover':
+                element.addEventListener('mouseenter', this.boundHandleHover);
+                element.addEventListener('mouseleave', this.boundHandleHoverOut);
+                break;
+            case 'focus':
+                element.addEventListener('focus', this.boundHandleFocus);
+                element.addEventListener('blur', this.boundHandleBlur);
+                break;
+            case 'click':
+                element.addEventListener('click', this.boundHandleClick);
+                break;
+            case 'manual':
+                // Não faz nada, espera chamada programática
+                break;
+        }
+        // Listener para fim da animação
+        element.addEventListener('animationend', this.boundHandleAnimationEnd);
+    }
+    setupIntersectionObserver() {
+        if (typeof IntersectionObserver === 'undefined') {
+            // Fallback: anima imediatamente
+            this.play();
+            return;
+        }
+        this.observer = new IntersectionObserver((entries) => {
+            entries.forEach((entry) => {
+                if (entry.isIntersecting && this.canAnimate()) {
+                    this.applyAnimation();
+                    if (this.brAnimateOnce) {
+                        this.observer?.disconnect();
+                    }
+                }
+            });
+        }, { threshold: this.brAnimateThreshold });
+        this.observer.observe(this.el.nativeElement);
+    }
+    canAnimate() {
+        if (!this.brAnimateEnabled)
+            return false;
+        if (!this.animationService.isEnabled())
+            return false;
+        if (this.brAnimateOnce && this.hasAnimated)
+            return false;
+        return true;
+    }
+    applyAnimation() {
+        const element = this.el.nativeElement;
+        const duration = this.animationService.resolveDuration(this.brAnimateDuration);
+        const easing = this.animationService.resolveEasing(this.brAnimateEasing);
+        const delay = this.brAnimateDelay || 0;
+        // Emite evento de início
+        this.brAnimateStart.emit({
+            type: this.animation,
+            phase: 'start',
+            element,
+            timestamp: Date.now(),
+        });
+        // Aplica a animação
+        element.style.animation = `br-${this.animation} ${duration}ms ${easing} ${delay}ms both`;
+        this.hasAnimated = true;
+    }
+    clearAnimation() {
+        const element = this.el.nativeElement;
+        element.style.animation = '';
+    }
+    handleAnimationEnd() {
+        const element = this.el.nativeElement;
+        this.brAnimateEnd.emit({
+            type: this.animation,
+            phase: 'end',
+            element,
+            timestamp: Date.now(),
+        });
+        // Para triggers de hover/focus, limpa para poder repetir
+        if (this.brAnimateTrigger === 'hover' || this.brAnimateTrigger === 'focus') {
+            this.clearAnimation();
+        }
+    }
+    handleHover() {
+        if (this.canAnimate() || this.brAnimateTrigger === 'hover') {
+            this.hasAnimated = false; // Permite repetir no hover
+            this.applyAnimation();
+        }
+    }
+    handleHoverOut() {
+        this.clearAnimation();
+    }
+    handleFocus() {
+        if (this.canAnimate() || this.brAnimateTrigger === 'focus') {
+            this.hasAnimated = false;
+            this.applyAnimation();
+        }
+    }
+    handleBlur() {
+        this.clearAnimation();
+    }
+    handleClick() {
+        if (this.canAnimate() || this.brAnimateTrigger === 'click') {
+            this.hasAnimated = false;
+            this.clearAnimation();
+            // Força reflow para reiniciar a animação
+            this.el.nativeElement.getBoundingClientRect();
+            this.applyAnimation();
+        }
+    }
+    cleanup() {
+        const element = this.el.nativeElement;
+        this.observer?.disconnect();
+        element.removeEventListener('animationend', this.boundHandleAnimationEnd);
+        element.removeEventListener('mouseenter', this.boundHandleHover);
+        element.removeEventListener('mouseleave', this.boundHandleHoverOut);
+        element.removeEventListener('focus', this.boundHandleFocus);
+        element.removeEventListener('blur', this.boundHandleBlur);
+        element.removeEventListener('click', this.boundHandleClick);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BrAnimateDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: BrAnimateDirective, isStandalone: true, selector: "[brAnimate]", inputs: { animation: ["brAnimate", "animation"], brAnimateTrigger: "brAnimateTrigger", brAnimateDuration: "brAnimateDuration", brAnimateDelay: "brAnimateDelay", brAnimateEasing: "brAnimateEasing", brAnimateThreshold: "brAnimateThreshold", brAnimateOnce: "brAnimateOnce", brAnimateEnabled: "brAnimateEnabled" }, outputs: { brAnimateStart: "brAnimateStart", brAnimateEnd: "brAnimateEnd" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BrAnimateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[brAnimate]',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [], propDecorators: { animation: [{
+                type: Input,
+                args: ['brAnimate']
+            }], brAnimateTrigger: [{
+                type: Input
+            }], brAnimateDuration: [{
+                type: Input
+            }], brAnimateDelay: [{
+                type: Input
+            }], brAnimateEasing: [{
+                type: Input
+            }], brAnimateThreshold: [{
+                type: Input
+            }], brAnimateOnce: [{
+                type: Input
+            }], brAnimateEnabled: [{
+                type: Input
+            }], brAnimateStart: [{
+                type: Output
+            }], brAnimateEnd: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"animate.directive.js","sourceRoot":"","sources":["../../../../../projects/ng-govbr-tw/src/lib/animations/animate.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  Directive,\r\n  ElementRef,\r\n  Input,\r\n  OnInit,\r\n  OnDestroy,\r\n  Output,\r\n  EventEmitter,\r\n  inject,\r\n  effect,\r\n} from '@angular/core';\r\nimport { BrAnimationService } from './animation.service';\r\nimport {\r\n  BrAnimationType,\r\n  BrAnimationDuration,\r\n  BrAnimationEasing,\r\n  BrAnimationTrigger,\r\n  BrAnimationEvent,\r\n} from './animation.types';\r\n\r\n/**\r\n * Diretiva para aplicar animações a qualquer elemento\r\n *\r\n * @example\r\n * <!-- Animação imediata -->\r\n * <div brAnimate=\"fadeInUp\">Conteúdo</div>\r\n *\r\n * <!-- Animação quando visível -->\r\n * <div brAnimate=\"fadeInUp\" brAnimateTrigger=\"visible\">Conteúdo</div>\r\n *\r\n * <!-- Com configurações -->\r\n * <div brAnimate=\"scaleIn\" [brAnimateDuration]=\"300\" brAnimateEasing=\"easeOutBack\">\r\n *   Conteúdo\r\n * </div>\r\n *\r\n * <!-- Stagger em lista -->\r\n * <ul>\r\n *   <li *ngFor=\"let item of items; let i = index\"\r\n *       brAnimate=\"fadeInUp\"\r\n *       [brAnimateDelay]=\"i * 50\">\r\n *     {{ item }}\r\n *   </li>\r\n * </ul>\r\n */\r\n@Directive({\r\n  selector: '[brAnimate]',\r\n  standalone: true,\r\n})\r\nexport class BrAnimateDirective implements OnInit, OnDestroy {\r\n  private readonly el = inject(ElementRef);\r\n  private readonly animationService = inject(BrAnimationService);\r\n\r\n  /** Tipo de animação */\r\n  @Input('brAnimate') animation: BrAnimationType = 'fadeIn';\r\n\r\n  /** Trigger que inicia a animação */\r\n  @Input() brAnimateTrigger: BrAnimationTrigger = 'immediate';\r\n\r\n  /** Duração da animação */\r\n  @Input() brAnimateDuration?: number | BrAnimationDuration;\r\n\r\n  /** Delay antes de iniciar */\r\n  @Input() brAnimateDelay?: number;\r\n\r\n  /** Curva de easing */\r\n  @Input() brAnimateEasing?: BrAnimationEasing;\r\n\r\n  /** Threshold para Intersection Observer (0-1) */\r\n  @Input() brAnimateThreshold = 0.1;\r\n\r\n  /** Se deve animar apenas uma vez */\r\n  @Input() brAnimateOnce = true;\r\n\r\n  /** Se a animação está habilitada */\r\n  @Input() brAnimateEnabled = true;\r\n\r\n  /** Evento emitido no início da animação */\r\n  @Output() brAnimateStart = new EventEmitter<BrAnimationEvent>();\r\n\r\n  /** Evento emitido no fim da animação */\r\n  @Output() brAnimateEnd = new EventEmitter<BrAnimationEvent>();\r\n\r\n  private observer?: IntersectionObserver;\r\n  private hasAnimated = false;\r\n  private boundHandleAnimationEnd = this.handleAnimationEnd.bind(this);\r\n  private boundHandleHover = this.handleHover.bind(this);\r\n  private boundHandleHoverOut = this.handleHoverOut.bind(this);\r\n  private boundHandleFocus = this.handleFocus.bind(this);\r\n  private boundHandleBlur = this.handleBlur.bind(this);\r\n  private boundHandleClick = this.handleClick.bind(this);\r\n\r\n  constructor() {\r\n    // Reage a mudanças no serviço de animação\r\n    effect(() => {\r\n      if (!this.animationService.isEnabled()) {\r\n        this.clearAnimation();\r\n      }\r\n    });\r\n  }\r\n\r\n  ngOnInit(): void {\r\n    if (!this.brAnimateEnabled) return;\r\n\r\n    this.setupTrigger();\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this.cleanup();\r\n  }\r\n\r\n  /**\r\n   * Inicia a animação programaticamente\r\n   */\r\n  play(): void {\r\n    if (!this.canAnimate()) return;\r\n    this.applyAnimation();\r\n  }\r\n\r\n  /**\r\n   * Reseta a animação para poder rodar novamente\r\n   */\r\n  reset(): void {\r\n    this.hasAnimated = false;\r\n    this.clearAnimation();\r\n  }\r\n\r\n  private setupTrigger(): void {\r\n    const element = this.el.nativeElement as HTMLElement;\r\n\r\n    switch (this.brAnimateTrigger) {\r\n      case 'immediate':\r\n        // Pequeno delay para garantir que o elemento está no DOM\r\n        requestAnimationFrame(() => this.play());\r\n        break;\r\n\r\n      case 'visible':\r\n        this.setupIntersectionObserver();\r\n        break;\r\n\r\n      case 'hover':\r\n        element.addEventListener('mouseenter', this.boundHandleHover);\r\n        element.addEventListener('mouseleave', this.boundHandleHoverOut);\r\n        break;\r\n\r\n      case 'focus':\r\n        element.addEventListener('focus', this.boundHandleFocus);\r\n        element.addEventListener('blur', this.boundHandleBlur);\r\n        break;\r\n\r\n      case 'click':\r\n        element.addEventListener('click', this.boundHandleClick);\r\n        break;\r\n\r\n      case 'manual':\r\n        // Não faz nada, espera chamada programática\r\n        break;\r\n    }\r\n\r\n    // Listener para fim da animação\r\n    element.addEventListener('animationend', this.boundHandleAnimationEnd);\r\n  }\r\n\r\n  private setupIntersectionObserver(): void {\r\n    if (typeof IntersectionObserver === 'undefined') {\r\n      // Fallback: anima imediatamente\r\n      this.play();\r\n      return;\r\n    }\r\n\r\n    this.observer = new IntersectionObserver(\r\n      (entries) => {\r\n        entries.forEach((entry) => {\r\n          if (entry.isIntersecting && this.canAnimate()) {\r\n            this.applyAnimation();\r\n\r\n            if (this.brAnimateOnce) {\r\n              this.observer?.disconnect();\r\n            }\r\n          }\r\n        });\r\n      },\r\n      { threshold: this.brAnimateThreshold }\r\n    );\r\n\r\n    this.observer.observe(this.el.nativeElement);\r\n  }\r\n\r\n  private canAnimate(): boolean {\r\n    if (!this.brAnimateEnabled) return false;\r\n    if (!this.animationService.isEnabled()) return false;\r\n    if (this.brAnimateOnce && this.hasAnimated) return false;\r\n    return true;\r\n  }\r\n\r\n  private applyAnimation(): void {\r\n    const element = this.el.nativeElement as HTMLElement;\r\n    const duration = this.animationService.resolveDuration(this.brAnimateDuration);\r\n    const easing = this.animationService.resolveEasing(this.brAnimateEasing);\r\n    const delay = this.brAnimateDelay || 0;\r\n\r\n    // Emite evento de início\r\n    this.brAnimateStart.emit({\r\n      type: this.animation,\r\n      phase: 'start',\r\n      element,\r\n      timestamp: Date.now(),\r\n    });\r\n\r\n    // Aplica a animação\r\n    element.style.animation = `br-${this.animation} ${duration}ms ${easing} ${delay}ms both`;\r\n\r\n    this.hasAnimated = true;\r\n  }\r\n\r\n  private clearAnimation(): void {\r\n    const element = this.el.nativeElement as HTMLElement;\r\n    element.style.animation = '';\r\n  }\r\n\r\n  private handleAnimationEnd(): void {\r\n    const element = this.el.nativeElement as HTMLElement;\r\n\r\n    this.brAnimateEnd.emit({\r\n      type: this.animation,\r\n      phase: 'end',\r\n      element,\r\n      timestamp: Date.now(),\r\n    });\r\n\r\n    // Para triggers de hover/focus, limpa para poder repetir\r\n    if (this.brAnimateTrigger === 'hover' || this.brAnimateTrigger === 'focus') {\r\n      this.clearAnimation();\r\n    }\r\n  }\r\n\r\n  private handleHover(): void {\r\n    if (this.canAnimate() || this.brAnimateTrigger === 'hover') {\r\n      this.hasAnimated = false; // Permite repetir no hover\r\n      this.applyAnimation();\r\n    }\r\n  }\r\n\r\n  private handleHoverOut(): void {\r\n    this.clearAnimation();\r\n  }\r\n\r\n  private handleFocus(): void {\r\n    if (this.canAnimate() || this.brAnimateTrigger === 'focus') {\r\n      this.hasAnimated = false;\r\n      this.applyAnimation();\r\n    }\r\n  }\r\n\r\n  private handleBlur(): void {\r\n    this.clearAnimation();\r\n  }\r\n\r\n  private handleClick(): void {\r\n    if (this.canAnimate() || this.brAnimateTrigger === 'click') {\r\n      this.hasAnimated = false;\r\n      this.clearAnimation();\r\n      // Força reflow para reiniciar a animação\r\n      this.el.nativeElement.getBoundingClientRect();\r\n      this.applyAnimation();\r\n    }\r\n  }\r\n\r\n  private cleanup(): void {\r\n    const element = this.el.nativeElement as HTMLElement;\r\n\r\n    this.observer?.disconnect();\r\n\r\n    element.removeEventListener('animationend', this.boundHandleAnimationEnd);\r\n    element.removeEventListener('mouseenter', this.boundHandleHover);\r\n    element.removeEventListener('mouseleave', this.boundHandleHoverOut);\r\n    element.removeEventListener('focus', this.boundHandleFocus);\r\n    element.removeEventListener('blur', this.boundHandleBlur);\r\n    element.removeEventListener('click', this.boundHandleClick);\r\n  }\r\n}\r\n"]}

package/esm2022/lib/animations/animation.service.mjs

@@ -0,0 +1,178 @@
+import { Injectable, signal, computed, inject, InjectionToken } from '@angular/core';
+import { BR_ANIMATION_DEFAULT_CONFIG, BR_ANIMATION_DURATION_MAP, BR_ANIMATION_EASING_MAP, } from './animation.types';
+import * as i0 from "@angular/core";
+/** Token para injetar configuração customizada */
+export const BR_ANIMATION_CONFIG = new InjectionToken('BR_ANIMATION_CONFIG');
+/**
+ * Serviço de animações Gov.br
+ * @description Gerencia configuração global e estado das animações
+ *
+ * @example
+ * // No módulo/componente principal
+ * providers: [
+ *   {
+ *     provide: BR_ANIMATION_CONFIG,
+ *     useValue: { enabled: true, defaultDuration: 'fast' }
+ *   }
+ * ]
+ *
+ * // No componente
+ * constructor(private animationService: BrAnimationService) {
+ *   this.animationService.enable();
+ * }
+ */
+export class BrAnimationService {
+    constructor() {
+        /** Configuração global reativa */
+        this._config = signal({ ...BR_ANIMATION_DEFAULT_CONFIG });
+        /** Se animações estão habilitadas (considera reduced motion) */
+        this.isEnabled = computed(() => {
+            const config = this._config();
+            if (!config.enabled)
+                return false;
+            if (config.respectReducedMotion && this._prefersReducedMotion())
+                return false;
+            return true;
+        });
+        /** Configuração atual (readonly) */
+        this.config = computed(() => this._config());
+        /** Cache de media query */
+        this._reducedMotionQuery = null;
+        /** Custom config injected optionally */
+        this._customConfig = inject(BR_ANIMATION_CONFIG, { optional: true });
+        // Merge com configuração customizada
+        if (this._customConfig) {
+            this._config.update(current => ({ ...current, ...this._customConfig }));
+        }
+        // Setup listener para prefers-reduced-motion
+        this._setupReducedMotionListener();
+    }
+    /**
+     * Habilita animações globalmente
+     */
+    enable() {
+        this._config.update(config => ({ ...config, enabled: true }));
+    }
+    /**
+     * Desabilita animações globalmente
+     */
+    disable() {
+        this._config.update(config => ({ ...config, enabled: false }));
+    }
+    /**
+     * Toggle do estado de animações
+     */
+    toggle() {
+        this._config.update(config => ({ ...config, enabled: !config.enabled }));
+    }
+    /**
+     * Atualiza configuração global
+     */
+    configure(config) {
+        this._config.update(current => ({ ...current, ...config }));
+    }
+    /**
+     * Define duração padrão
+     */
+    setDefaultDuration(duration) {
+        this._config.update(config => ({ ...config, defaultDuration: duration }));
+    }
+    /**
+     * Define easing padrão
+     */
+    setDefaultEasing(easing) {
+        this._config.update(config => ({ ...config, defaultEasing: easing }));
+    }
+    /**
+     * Resolve duração para valor em ms
+     */
+    resolveDuration(duration) {
+        if (duration === undefined) {
+            const defaultDur = this._config().defaultDuration;
+            return typeof defaultDur === 'number' ? defaultDur : BR_ANIMATION_DURATION_MAP[defaultDur];
+        }
+        return typeof duration === 'number' ? duration : BR_ANIMATION_DURATION_MAP[duration];
+    }
+    /**
+     * Resolve easing para valor CSS
+     */
+    resolveEasing(easing) {
+        const resolvedEasing = easing || this._config().defaultEasing;
+        return BR_ANIMATION_EASING_MAP[resolvedEasing];
+    }
+    /**
+     * Gera string de animação CSS
+     */
+    getAnimationString(config) {
+        if (!this.isEnabled())
+            return 'none';
+        const duration = this.resolveDuration(config.duration);
+        const easing = this.resolveEasing(config.easing);
+        const delay = config.delay || 0;
+        const iterations = config.iterations === 'infinite' ? 'infinite' : (config.iterations || 1);
+        const direction = config.direction || 'normal';
+        const fillMode = config.fillMode || 'both';
+        return `br-${config.type} ${duration}ms ${easing} ${delay}ms ${iterations} ${direction} ${fillMode}`;
+    }
+    /**
+     * Aplica animação a um elemento
+     */
+    animate(element, config) {
+        return new Promise((resolve, reject) => {
+            if (!this.isEnabled()) {
+                resolve();
+                return;
+            }
+            const animationString = this.getAnimationString(config);
+            element.style.animation = animationString;
+            const handleEnd = () => {
+                element.removeEventListener('animationend', handleEnd);
+                element.removeEventListener('animationcancel', handleCancel);
+                resolve();
+            };
+            const handleCancel = () => {
+                element.removeEventListener('animationend', handleEnd);
+                element.removeEventListener('animationcancel', handleCancel);
+                reject(new Error('Animation cancelled'));
+            };
+            element.addEventListener('animationend', handleEnd);
+            element.addEventListener('animationcancel', handleCancel);
+        });
+    }
+    /**
+     * Remove animação de um elemento
+     */
+    clearAnimation(element) {
+        element.style.animation = '';
+    }
+    /**
+     * Verifica se usuário prefere movimento reduzido
+     */
+    _prefersReducedMotion() {
+        if (typeof window === 'undefined')
+            return false;
+        return this._reducedMotionQuery?.matches ?? false;
+    }
+    /**
+     * Configura listener para mudanças de preferência
+     */
+    _setupReducedMotionListener() {
+        if (typeof window === 'undefined')
+            return;
+        this._reducedMotionQuery = window.matchMedia('(prefers-reduced-motion: reduce)');
+        // Força re-avaliação quando preferência muda
+        this._reducedMotionQuery.addEventListener('change', () => {
+            // Trigger recomputation via signal update
+            this._config.update(config => ({ ...config }));
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BrAnimationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BrAnimationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BrAnimationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"animation.service.js","sourceRoot":"","sources":["../../../../../projects/ng-govbr-tw/src/lib/animations/animation.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, signal, computed, inject, InjectionToken } from '@angular/core';\r\nimport {\r\n  BrAnimationGlobalConfig,\r\n  BrAnimationDuration,\r\n  BrAnimationEasing,\r\n  BrAnimationConfig,\r\n  BR_ANIMATION_DEFAULT_CONFIG,\r\n  BR_ANIMATION_DURATION_MAP,\r\n  BR_ANIMATION_EASING_MAP,\r\n} from './animation.types';\r\n\r\n/** Token para injetar configuração customizada */\r\nexport const BR_ANIMATION_CONFIG = new InjectionToken<Partial<BrAnimationGlobalConfig>>(\r\n  'BR_ANIMATION_CONFIG'\r\n);\r\n\r\n/**\r\n * Serviço de animações Gov.br\r\n * @description Gerencia configuração global e estado das animações\r\n *\r\n * @example\r\n * // No módulo/componente principal\r\n * providers: [\r\n *   {\r\n *     provide: BR_ANIMATION_CONFIG,\r\n *     useValue: { enabled: true, defaultDuration: 'fast' }\r\n *   }\r\n * ]\r\n *\r\n * // No componente\r\n * constructor(private animationService: BrAnimationService) {\r\n *   this.animationService.enable();\r\n * }\r\n */\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class BrAnimationService {\r\n  /** Configuração global reativa */\r\n  private readonly _config = signal<BrAnimationGlobalConfig>({ ...BR_ANIMATION_DEFAULT_CONFIG });\r\n\r\n  /** Se animações estão habilitadas (considera reduced motion) */\r\n  readonly isEnabled = computed(() => {\r\n    const config = this._config();\r\n    if (!config.enabled) return false;\r\n    if (config.respectReducedMotion && this._prefersReducedMotion()) return false;\r\n    return true;\r\n  });\r\n\r\n  /** Configuração atual (readonly) */\r\n  readonly config = computed(() => this._config());\r\n\r\n  /** Cache de media query */\r\n  private _reducedMotionQuery: MediaQueryList | null = null;\r\n\r\n  /** Custom config injected optionally */\r\n  private readonly _customConfig = inject(BR_ANIMATION_CONFIG, { optional: true });\r\n\r\n  constructor() {\r\n    // Merge com configuração customizada\r\n    if (this._customConfig) {\r\n      this._config.update(current => ({ ...current, ...this._customConfig }));\r\n    }\r\n\r\n    // Setup listener para prefers-reduced-motion\r\n    this._setupReducedMotionListener();\r\n  }\r\n\r\n  /**\r\n   * Habilita animações globalmente\r\n   */\r\n  enable(): void {\r\n    this._config.update(config => ({ ...config, enabled: true }));\r\n  }\r\n\r\n  /**\r\n   * Desabilita animações globalmente\r\n   */\r\n  disable(): void {\r\n    this._config.update(config => ({ ...config, enabled: false }));\r\n  }\r\n\r\n  /**\r\n   * Toggle do estado de animações\r\n   */\r\n  toggle(): void {\r\n    this._config.update(config => ({ ...config, enabled: !config.enabled }));\r\n  }\r\n\r\n  /**\r\n   * Atualiza configuração global\r\n   */\r\n  configure(config: Partial<BrAnimationGlobalConfig>): void {\r\n    this._config.update(current => ({ ...current, ...config }));\r\n  }\r\n\r\n  /**\r\n   * Define duração padrão\r\n   */\r\n  setDefaultDuration(duration: number | BrAnimationDuration): void {\r\n    this._config.update(config => ({ ...config, defaultDuration: duration }));\r\n  }\r\n\r\n  /**\r\n   * Define easing padrão\r\n   */\r\n  setDefaultEasing(easing: BrAnimationEasing): void {\r\n    this._config.update(config => ({ ...config, defaultEasing: easing }));\r\n  }\r\n\r\n  /**\r\n   * Resolve duração para valor em ms\r\n   */\r\n  resolveDuration(duration?: number | BrAnimationDuration): number {\r\n    if (duration === undefined) {\r\n      const defaultDur = this._config().defaultDuration;\r\n      return typeof defaultDur === 'number' ? defaultDur : BR_ANIMATION_DURATION_MAP[defaultDur];\r\n    }\r\n    return typeof duration === 'number' ? duration : BR_ANIMATION_DURATION_MAP[duration];\r\n  }\r\n\r\n  /**\r\n   * Resolve easing para valor CSS\r\n   */\r\n  resolveEasing(easing?: BrAnimationEasing): string {\r\n    const resolvedEasing = easing || this._config().defaultEasing;\r\n    return BR_ANIMATION_EASING_MAP[resolvedEasing];\r\n  }\r\n\r\n  /**\r\n   * Gera string de animação CSS\r\n   */\r\n  getAnimationString(config: BrAnimationConfig): string {\r\n    if (!this.isEnabled()) return 'none';\r\n\r\n    const duration = this.resolveDuration(config.duration);\r\n    const easing = this.resolveEasing(config.easing);\r\n    const delay = config.delay || 0;\r\n    const iterations = config.iterations === 'infinite' ? 'infinite' : (config.iterations || 1);\r\n    const direction = config.direction || 'normal';\r\n    const fillMode = config.fillMode || 'both';\r\n\r\n    return `br-${config.type} ${duration}ms ${easing} ${delay}ms ${iterations} ${direction} ${fillMode}`;\r\n  }\r\n\r\n  /**\r\n   * Aplica animação a um elemento\r\n   */\r\n  animate(element: HTMLElement, config: BrAnimationConfig): Promise<void> {\r\n    return new Promise((resolve, reject) => {\r\n      if (!this.isEnabled()) {\r\n        resolve();\r\n        return;\r\n      }\r\n\r\n      const animationString = this.getAnimationString(config);\r\n      element.style.animation = animationString;\r\n\r\n      const handleEnd = () => {\r\n        element.removeEventListener('animationend', handleEnd);\r\n        element.removeEventListener('animationcancel', handleCancel);\r\n        resolve();\r\n      };\r\n\r\n      const handleCancel = () => {\r\n        element.removeEventListener('animationend', handleEnd);\r\n        element.removeEventListener('animationcancel', handleCancel);\r\n        reject(new Error('Animation cancelled'));\r\n      };\r\n\r\n      element.addEventListener('animationend', handleEnd);\r\n      element.addEventListener('animationcancel', handleCancel);\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Remove animação de um elemento\r\n   */\r\n  clearAnimation(element: HTMLElement): void {\r\n    element.style.animation = '';\r\n  }\r\n\r\n  /**\r\n   * Verifica se usuário prefere movimento reduzido\r\n   */\r\n  private _prefersReducedMotion(): boolean {\r\n    if (typeof window === 'undefined') return false;\r\n    return this._reducedMotionQuery?.matches ?? false;\r\n  }\r\n\r\n  /**\r\n   * Configura listener para mudanças de preferência\r\n   */\r\n  private _setupReducedMotionListener(): void {\r\n    if (typeof window === 'undefined') return;\r\n\r\n    this._reducedMotionQuery = window.matchMedia('(prefers-reduced-motion: reduce)');\r\n\r\n    // Força re-avaliação quando preferência muda\r\n    this._reducedMotionQuery.addEventListener('change', () => {\r\n      // Trigger recomputation via signal update\r\n      this._config.update(config => ({ ...config }));\r\n    });\r\n  }\r\n}\r\n"]}

package/esm2022/lib/animations/animation.types.mjs

@@ -0,0 +1,34 @@
+/**
+ * Tipos e interfaces para o sistema de animações Gov.br
+ * @description Sistema de animações configurável e acessível
+ */
+/** Mapeamento de easing para valores CSS */
+export const BR_ANIMATION_EASING_MAP = {
+    linear: 'linear',
+    ease: 'ease',
+    easeIn: 'ease-in',
+    easeOut: 'ease-out',
+    easeInOut: 'ease-in-out',
+    easeInBack: 'cubic-bezier(0.6, -0.28, 0.735, 0.045)',
+    easeOutBack: 'cubic-bezier(0.175, 0.885, 0.32, 1.275)',
+    easeInOutBack: 'cubic-bezier(0.68, -0.55, 0.265, 1.55)',
+    easeInElastic: 'cubic-bezier(0.5, -0.5, 0.75, 1.25)',
+    easeOutElastic: 'cubic-bezier(0.25, -0.25, 0.25, 1.5)',
+    easeOutBounce: 'cubic-bezier(0.34, 1.56, 0.64, 1)',
+};
+/** Mapeamento de duração para valores em ms */
+export const BR_ANIMATION_DURATION_MAP = {
+    instant: 100,
+    fast: 150,
+    normal: 250,
+    slow: 400,
+    slower: 600,
+};
+/** Configuração padrão global */
+export const BR_ANIMATION_DEFAULT_CONFIG = {
+    enabled: false, // Desabilitado por padrão
+    respectReducedMotion: true,
+    defaultDuration: 'normal',
+    defaultEasing: 'easeOut',
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"animation.types.js","sourceRoot":"","sources":["../../../../../projects/ng-govbr-tw/src/lib/animations/animation.types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AA0FH,4CAA4C;AAC5C,MAAM,CAAC,MAAM,uBAAuB,GAAsC;IACxE,MAAM,EAAE,QAAQ;IAChB,IAAI,EAAE,MAAM;IACZ,MAAM,EAAE,SAAS;IACjB,OAAO,EAAE,UAAU;IACnB,SAAS,EAAE,aAAa;IACxB,UAAU,EAAE,wCAAwC;IACpD,WAAW,EAAE,yCAAyC;IACtD,aAAa,EAAE,wCAAwC;IACvD,aAAa,EAAE,qCAAqC;IACpD,cAAc,EAAE,sCAAsC;IACtD,aAAa,EAAE,mCAAmC;CAC1C,CAAC;AAKX,+CAA+C;AAC/C,MAAM,CAAC,MAAM,yBAAyB,GAAwC;IAC5E,OAAO,EAAE,GAAG;IACZ,IAAI,EAAE,GAAG;IACT,MAAM,EAAE,GAAG;IACX,IAAI,EAAE,GAAG;IACT,MAAM,EAAE,GAAG;CACH,CAAC;AAwCX,iCAAiC;AACjC,MAAM,CAAC,MAAM,2BAA2B,GAA4B;IAClE,OAAO,EAAE,KAAK,EAAE,0BAA0B;IAC1C,oBAAoB,EAAE,IAAI;IAC1B,eAAe,EAAE,QAAQ;IACzB,aAAa,EAAE,SAAS;CAChB,CAAC","sourcesContent":["/**\r\n * Tipos e interfaces para o sistema de animações Gov.br\r\n * @description Sistema de animações configurável e acessível\r\n */\r\n\r\n/** Tipos de animação de entrada */\r\nexport type BrAnimationEnter =\r\n  | 'fadeIn'\r\n  | 'fadeInUp'\r\n  | 'fadeInDown'\r\n  | 'fadeInLeft'\r\n  | 'fadeInRight'\r\n  | 'scaleIn'\r\n  | 'slideInUp'\r\n  | 'slideInDown'\r\n  | 'slideInLeft'\r\n  | 'slideInRight'\r\n  | 'expandHeight'\r\n  | 'expandWidth';\r\n\r\n/** Tipos de animação de saída */\r\nexport type BrAnimationLeave =\r\n  | 'fadeOut'\r\n  | 'fadeOutUp'\r\n  | 'fadeOutDown'\r\n  | 'fadeOutLeft'\r\n  | 'fadeOutRight'\r\n  | 'scaleOut'\r\n  | 'slideOutUp'\r\n  | 'slideOutDown'\r\n  | 'slideOutLeft'\r\n  | 'slideOutRight'\r\n  | 'collapseHeight'\r\n  | 'collapseWidth';\r\n\r\n/** Tipos de animação de atenção/feedback */\r\nexport type BrAnimationAttention =\r\n  | 'pulse'\r\n  | 'shake'\r\n  | 'bounce'\r\n  | 'wiggle'\r\n  | 'flash'\r\n  | 'heartbeat'\r\n  | 'swing';\r\n\r\n/** Tipos de animação de loading */\r\nexport type BrAnimationLoading =\r\n  | 'spin'\r\n  | 'dots'\r\n  | 'bars'\r\n  | 'shimmer'\r\n  | 'wave'\r\n  | 'progressIndeterminate';\r\n\r\n/** Tipos de animação de hover */\r\nexport type BrAnimationHover =\r\n  | 'lift'\r\n  | 'grow'\r\n  | 'shrink'\r\n  | 'glow'\r\n  | 'underline'\r\n  | 'ripple';\r\n\r\n/** Tipos de animação de sucesso/feedback */\r\nexport type BrAnimationFeedback =\r\n  | 'checkmark'\r\n  | 'successPop'\r\n  | 'errorShake'\r\n  | 'warningPulse';\r\n\r\n/** União de todos os tipos de animação */\r\nexport type BrAnimationType =\r\n  | BrAnimationEnter\r\n  | BrAnimationLeave\r\n  | BrAnimationAttention\r\n  | BrAnimationLoading\r\n  | BrAnimationHover\r\n  | BrAnimationFeedback;\r\n\r\n/** Curvas de easing disponíveis */\r\nexport type BrAnimationEasing =\r\n  | 'linear'\r\n  | 'ease'\r\n  | 'easeIn'\r\n  | 'easeOut'\r\n  | 'easeInOut'\r\n  | 'easeInBack'\r\n  | 'easeOutBack'\r\n  | 'easeInOutBack'\r\n  | 'easeInElastic'\r\n  | 'easeOutElastic'\r\n  | 'easeOutBounce';\r\n\r\n/** Mapeamento de easing para valores CSS */\r\nexport const BR_ANIMATION_EASING_MAP: Record<BrAnimationEasing, string> = {\r\n  linear: 'linear',\r\n  ease: 'ease',\r\n  easeIn: 'ease-in',\r\n  easeOut: 'ease-out',\r\n  easeInOut: 'ease-in-out',\r\n  easeInBack: 'cubic-bezier(0.6, -0.28, 0.735, 0.045)',\r\n  easeOutBack: 'cubic-bezier(0.175, 0.885, 0.32, 1.275)',\r\n  easeInOutBack: 'cubic-bezier(0.68, -0.55, 0.265, 1.55)',\r\n  easeInElastic: 'cubic-bezier(0.5, -0.5, 0.75, 1.25)',\r\n  easeOutElastic: 'cubic-bezier(0.25, -0.25, 0.25, 1.5)',\r\n  easeOutBounce: 'cubic-bezier(0.34, 1.56, 0.64, 1)',\r\n} as const;\r\n\r\n/** Durações predefinidas */\r\nexport type BrAnimationDuration = 'instant' | 'fast' | 'normal' | 'slow' | 'slower';\r\n\r\n/** Mapeamento de duração para valores em ms */\r\nexport const BR_ANIMATION_DURATION_MAP: Record<BrAnimationDuration, number> = {\r\n  instant: 100,\r\n  fast: 150,\r\n  normal: 250,\r\n  slow: 400,\r\n  slower: 600,\r\n} as const;\r\n\r\n/** Configuração de uma animação individual */\r\nexport interface BrAnimationConfig {\r\n  /** Tipo da animação */\r\n  type: BrAnimationType;\r\n  /** Duração em ms ou predefinida */\r\n  duration?: number | BrAnimationDuration;\r\n  /** Delay antes de iniciar em ms */\r\n  delay?: number;\r\n  /** Curva de easing */\r\n  easing?: BrAnimationEasing;\r\n  /** Número de iterações (Infinity para loop) */\r\n  iterations?: number | 'infinite';\r\n  /** Direção da animação */\r\n  direction?: 'normal' | 'reverse' | 'alternate' | 'alternate-reverse';\r\n  /** Estado final após animação */\r\n  fillMode?: 'none' | 'forwards' | 'backwards' | 'both';\r\n}\r\n\r\n/** Configuração de animação de entrada/saída */\r\nexport interface BrTransitionConfig {\r\n  /** Animação de entrada */\r\n  enter?: BrAnimationConfig;\r\n  /** Animação de saída */\r\n  leave?: BrAnimationConfig;\r\n}\r\n\r\n/** Configuração global de animações */\r\nexport interface BrAnimationGlobalConfig {\r\n  /** Habilita/desabilita todas as animações globalmente */\r\n  enabled: boolean;\r\n  /** Respeita preferência do usuário (prefers-reduced-motion) */\r\n  respectReducedMotion: boolean;\r\n  /** Duração padrão para todas as animações */\r\n  defaultDuration: number | BrAnimationDuration;\r\n  /** Easing padrão para todas as animações */\r\n  defaultEasing: BrAnimationEasing;\r\n}\r\n\r\n/** Configuração padrão global */\r\nexport const BR_ANIMATION_DEFAULT_CONFIG: BrAnimationGlobalConfig = {\r\n  enabled: false, // Desabilitado por padrão\r\n  respectReducedMotion: true,\r\n  defaultDuration: 'normal',\r\n  defaultEasing: 'easeOut',\r\n} as const;\r\n\r\n/** Estado de uma animação em execução */\r\nexport interface BrAnimationState {\r\n  /** Se está animando */\r\n  isAnimating: boolean;\r\n  /** Tipo atual */\r\n  currentAnimation: BrAnimationType | null;\r\n  /** Se foi concluída */\r\n  isCompleted: boolean;\r\n  /** Se foi cancelada */\r\n  isCancelled: boolean;\r\n}\r\n\r\n/** Evento emitido durante animação */\r\nexport interface BrAnimationEvent {\r\n  /** Tipo da animação */\r\n  type: BrAnimationType;\r\n  /** Fase: início, fim, cancelamento */\r\n  phase: 'start' | 'end' | 'cancel';\r\n  /** Elemento alvo */\r\n  element: HTMLElement;\r\n  /** Timestamp do evento */\r\n  timestamp: number;\r\n}\r\n\r\n/** Trigger para iniciar animação */\r\nexport type BrAnimationTrigger =\r\n  | 'immediate'     // Imediatamente ao montar\r\n  | 'visible'       // Quando visível no viewport (Intersection Observer)\r\n  | 'hover'         // No hover\r\n  | 'focus'         // No focus\r\n  | 'click'         // No click\r\n  | 'manual';       // Controlado programaticamente\r\n\r\n/** Configuração para diretiva brAnimate */\r\nexport interface BrAnimateDirectiveConfig {\r\n  /** Animação a executar */\r\n  animation: BrAnimationType;\r\n  /** Trigger que inicia a animação */\r\n  trigger?: BrAnimationTrigger;\r\n  /** Duração */\r\n  duration?: number | BrAnimationDuration;\r\n  /** Delay */\r\n  delay?: number;\r\n  /** Easing */\r\n  easing?: BrAnimationEasing;\r\n  /** Threshold para Intersection Observer (0-1) */\r\n  visibilityThreshold?: number;\r\n  /** Se deve animar apenas uma vez */\r\n  once?: boolean;\r\n}\r\n\r\n/** Configuração para stagger (animação em sequência) */\r\nexport interface BrStaggerConfig {\r\n  /** Animação base */\r\n  animation: BrAnimationType;\r\n  /** Delay entre cada item em ms */\r\n  staggerDelay: number;\r\n  /** Delay inicial antes do primeiro item */\r\n  initialDelay?: number;\r\n  /** Duração de cada animação */\r\n  duration?: number | BrAnimationDuration;\r\n  /** Easing */\r\n  easing?: BrAnimationEasing;\r\n}\r\n"]}

package/esm2022/lib/animations/index.mjs

@@ -0,0 +1,13 @@
+/**
+ * Sistema de Animações Gov.br
+ * @description Animações configuráveis e acessíveis para componentes Angular
+ */
+// Types e interfaces
+export * from './animation.types';
+// Serviço principal
+export { BrAnimationService, BR_ANIMATION_CONFIG } from './animation.service';
+// Diretiva de animação
+export { BrAnimateDirective } from './animate.directive';
+// Componentes de feedback
+export { BrSuccessCheckComponent } from './success-check.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZy1nb3Zici10dy9zcmMvbGliL2FuaW1hdGlvbnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7OztHQUdHO0FBRUgscUJBQXFCO0FBQ3JCLGNBQWMsbUJBQW1CLENBQUM7QUFFbEMsb0JBQW9CO0FBQ3BCLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxtQkFBbUIsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBRTlFLHVCQUF1QjtBQUN2QixPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUV6RCwwQkFBMEI7QUFDMUIsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0sMkJBQTJCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcclxuICogU2lzdGVtYSBkZSBBbmltYcOnw7VlcyBHb3YuYnJcclxuICogQGRlc2NyaXB0aW9uIEFuaW1hw6fDtWVzIGNvbmZpZ3Vyw6F2ZWlzIGUgYWNlc3PDrXZlaXMgcGFyYSBjb21wb25lbnRlcyBBbmd1bGFyXHJcbiAqL1xyXG5cclxuLy8gVHlwZXMgZSBpbnRlcmZhY2VzXHJcbmV4cG9ydCAqIGZyb20gJy4vYW5pbWF0aW9uLnR5cGVzJztcclxuXHJcbi8vIFNlcnZpw6dvIHByaW5jaXBhbFxyXG5leHBvcnQgeyBCckFuaW1hdGlvblNlcnZpY2UsIEJSX0FOSU1BVElPTl9DT05GSUcgfSBmcm9tICcuL2FuaW1hdGlvbi5zZXJ2aWNlJztcclxuXHJcbi8vIERpcmV0aXZhIGRlIGFuaW1hw6fDo29cclxuZXhwb3J0IHsgQnJBbmltYXRlRGlyZWN0aXZlIH0gZnJvbSAnLi9hbmltYXRlLmRpcmVjdGl2ZSc7XHJcblxyXG4vLyBDb21wb25lbnRlcyBkZSBmZWVkYmFja1xyXG5leHBvcnQgeyBCclN1Y2Nlc3NDaGVja0NvbXBvbmVudCB9IGZyb20gJy4vc3VjY2Vzcy1jaGVjay5jb21wb25lbnQnO1xyXG4iXX0=