@govbr-ds/webcomponents 2.1.0 → 2.1.2

package/dist/esm/swipe-Dmfk7eEe.js

@@ -0,0 +1,343 @@
+/*!
+ * Construído por SERPRO
+ * © https://serpro.gov.br/ - MIT License.
+ */
+/**
+ * UniversalSwipe - Detecção de gestos de swipe com suporte universal.
+ *
+ * Estratégia de detecção (prioridade):
+ * 1. Pointer Events - API moderna universal (Chrome 55+, Firefox 59+, Safari 13+, Edge 12+)
+ * 2. Touch Events - Fallback para dispositivos móveis sem Pointer Events
+ * 3. Mouse Events - Fallback para navegadores antigos
+ *
+ * Compatibilidade:
+ * - ✅ Firefox Desktop (mouse events)
+ * - ✅ Chrome Desktop/Mobile (pointer/touch events)
+ * - ✅ Safari Desktop/Mobile (pointer/touch events)
+ * - ✅ Edge (pointer events)
+ * - ✅ Navegadores antigos (touch/mouse events)
+ *
+ */
+class UniversalSwipe {
+    /**
+     * Cria uma nova instância de UniversalSwipe.
+     * @constructor
+     * @param {HTMLElement} element - Elemento HTML que receberá os gestos de swipe
+     * @param {Object} [options] - Opções de configuração
+     * @param {SwipeDirection} [options.direction='both'] - Direção do swipe a ser detectado
+     */
+    constructor(element, options) {
+        /**
+         * Mapa de eventos e seus callbacks.
+         */
+        this.evtMap = {
+            SWIPE_UP: [],
+            SWIPE_DOWN: [],
+            SWIPE_LEFT: [],
+            SWIPE_RIGHT: [],
+        };
+        /**
+         * Posição inicial do gesto.
+         */
+        this.startPoint = null;
+        /**
+         * Tipo de evento sendo usado (pointer, touch ou mouse).
+         */
+        this.eventType = 'touch';
+        /**
+         * Flag indicando se o gesto está ativo.
+         */
+        this.isActive = false;
+        /**
+         * Pointer ID para captura de eventos (usado com Pointer Events).
+         */
+        this.pointerId = null;
+        /**
+         * Limiar mínimo de movimento para detectar swipe (em pixels).
+         */
+        this.threshold = 30;
+        /**
+         * Direção do swipe esperado ('horizontal' | 'vertical' | 'both').
+         */
+        this.swipeDirection = 'both';
+        this.element = element;
+        this.swipeDirection = options?.direction || 'both';
+        this.boundHandleStart = this.handleStart.bind(this);
+        this.boundHandleEnd = this.handleEnd.bind(this);
+        this.boundHandleCancel = this.handleCancel.bind(this);
+        this.applyCSSFix();
+        this.detectAndAttachListeners();
+    }
+    /**
+     * Aplica CSS touch-action para prevenir gestos nativos do browser.
+     * Usa 'pan-y' para permitir scroll vertical enquanto detecta swipes horizontais.
+     * Usa 'pan-x' para permitir scroll horizontal enquanto detecta swipes verticais.
+     * @private
+     * @returns {void}
+     */
+    applyCSSFix() {
+        // Configura touch-action baseado na direção do swipe
+        if (this.swipeDirection === 'horizontal') {
+            // Permite scroll vertical, bloqueia horizontal para detectar SWIPE_LEFT/RIGHT
+            this.element.style.touchAction = 'pan-y';
+        }
+        else if (this.swipeDirection === 'vertical') {
+            // Permite scroll horizontal, bloqueia vertical para detectar SWIPE_UP/DOWN
+            this.element.style.touchAction = 'pan-x';
+        }
+        else {
+            // Bloqueia scroll em ambas direções para detectar qualquer swipe
+            // Use 'manipulation' se houver elementos clicáveis dentro
+            this.element.style.touchAction = 'manipulation';
+        }
+    }
+    /**
+     * Detecta qual tipo de evento usar e anexa os listeners apropriados.
+     * Estratégia: Prioriza Pointer Events (universal), depois Touch, depois Mouse.
+     * @private
+     * @returns {void}
+     */
+    detectAndAttachListeners() {
+        // 1. Pointer Events: API moderna e universal (Chrome 55+, Firefox 59+, Safari 13+)
+        if (window.PointerEvent) {
+            this.eventType = 'pointer';
+            this.element.addEventListener('pointerdown', this.boundHandleStart);
+            this.element.addEventListener('pointerup', this.boundHandleEnd);
+            this.element.addEventListener('pointercancel', this.boundHandleCancel);
+        }
+        // 2. Touch Events: Fallback para navegadores sem Pointer Events
+        else if ('ontouchstart' in window && navigator.maxTouchPoints > 0) {
+            this.eventType = 'touch';
+            // Passive: false permite preventDefault()
+            this.element.addEventListener('touchstart', this.boundHandleStart, { passive: false });
+            this.element.addEventListener('touchend', this.boundHandleEnd, { passive: false });
+            this.element.addEventListener('touchcancel', this.boundHandleCancel, { passive: false });
+        }
+        // 3. Mouse Events: Fallback final para navegadores antigos
+        else {
+            this.eventType = 'mouse';
+            this.element.addEventListener('mousedown', this.boundHandleStart);
+            // mousemove e mouseup são adicionados ao document no handleStart
+        }
+    }
+    /**
+     * Remove todos os event listeners do elemento.
+     * @private
+     * @returns {void}
+     */
+    detachListeners() {
+        if (this.eventType === 'pointer') {
+            this.element.removeEventListener('pointerdown', this.boundHandleStart);
+            this.element.removeEventListener('pointerup', this.boundHandleEnd);
+            this.element.removeEventListener('pointercancel', this.boundHandleCancel);
+        }
+        else if (this.eventType === 'touch') {
+            this.element.removeEventListener('touchstart', this.boundHandleStart);
+            this.element.removeEventListener('touchend', this.boundHandleEnd);
+            this.element.removeEventListener('touchcancel', this.boundHandleCancel);
+        }
+        else {
+            this.element.removeEventListener('mousedown', this.boundHandleStart);
+            this.removeDocumentMouseListeners();
+        }
+    }
+    /**
+     * Adiciona listeners de mouse ao document (necessário para rastrear fora do elemento).
+     * @private
+     * @returns {void}
+     */
+    addDocumentMouseListeners() {
+        document.addEventListener('mouseup', this.boundHandleEnd);
+        document.addEventListener('mouseleave', this.boundHandleCancel);
+    }
+    /**
+     * Remove listeners de mouse do document.
+     * @private
+     * @returns {void}
+     */
+    removeDocumentMouseListeners() {
+        document.removeEventListener('mouseup', this.boundHandleEnd);
+        document.removeEventListener('mouseleave', this.boundHandleCancel);
+    }
+    /**
+     * Extrai coordenadas do evento independente do tipo.
+     * @private
+     * @param {PointerEvent|TouchEvent|MouseEvent} evt - Evento de pointer, touch ou mouse
+     * @returns {Point} Coordenadas {x, y} do evento
+     */
+    getCoordinates(evt) {
+        if ('touches' in evt && evt.touches.length > 0) {
+            // Touch Event
+            return {
+                x: evt.touches[0].clientX,
+                y: evt.touches[0].clientY,
+            };
+        }
+        if ('changedTouches' in evt && evt.changedTouches.length > 0) {
+            // Touch Event (touchend)
+            return {
+                x: evt.changedTouches[0].clientX,
+                y: evt.changedTouches[0].clientY,
+            };
+        }
+        if ('clientX' in evt && 'clientY' in evt) {
+            // Pointer Event ou Mouse Event
+            return {
+                x: evt.clientX,
+                y: evt.clientY,
+            };
+        }
+        return { x: 0, y: 0 };
+    }
+    /**
+     * Handler do início do gesto (pointerdown, touchstart, mousedown).
+     * @private
+     * @param {PointerEvent|TouchEvent|MouseEvent} evt - Evento do browser
+     * @returns {void}
+     */
+    handleStart(evt) {
+        this.isActive = true;
+        this.startPoint = this.getCoordinates(evt);
+        // Para Pointer Events, captura o pointer para rastrear fora do elemento
+        if (this.eventType === 'pointer' && 'pointerId' in evt) {
+            this.pointerId = evt.pointerId;
+            try {
+                this.element.setPointerCapture(evt.pointerId);
+            }
+            catch {
+                // Ignora erro se captura não for suportada
+            }
+        }
+        // Para Mouse Events, adiciona listeners ao document
+        if (this.eventType === 'mouse') {
+            this.addDocumentMouseListeners();
+        }
+    }
+    /**
+     * Handler do fim do gesto (pointerup, touchend, mouseup).
+     * @private
+     * @param {PointerEvent|TouchEvent|MouseEvent} evt - Evento do browser
+     * @returns {void}
+     */
+    handleEnd(evt) {
+        if (!this.isActive || this.startPoint === null) {
+            return;
+        }
+        const endPoint = this.getCoordinates(evt);
+        const deltaX = endPoint.x - this.startPoint.x;
+        const deltaY = endPoint.y - this.startPoint.y;
+        // Threshold para evitar detecção acidental
+        const absDeltaX = Math.abs(deltaX);
+        const absDeltaY = Math.abs(deltaY);
+        // Só dispara swipe se movimento for maior que threshold
+        if (absDeltaX < this.threshold && absDeltaY < this.threshold) {
+            this.cleanup();
+            return;
+        }
+        // Determina direção do swipe baseado no maior delta
+        if (absDeltaX > absDeltaY) {
+            // Swipe horizontal
+            if (deltaX < 0) {
+                this.trigger('SWIPE_LEFT');
+            }
+            else {
+                this.trigger('SWIPE_RIGHT');
+            }
+        }
+        else {
+            // Swipe vertical
+            if (deltaY < 0) {
+                this.trigger('SWIPE_UP');
+            }
+            else {
+                this.trigger('SWIPE_DOWN');
+            }
+        }
+        this.cleanup();
+    }
+    /**
+     * Handler de cancelamento do gesto (pointercancel, touchcancel, mouseleave).
+     * @private
+     * @param {PointerEvent|TouchEvent|MouseEvent} _evt - Evento do browser (não utilizado)
+     * @returns {void}
+     */
+    handleCancel(_evt) {
+        this.cleanup();
+    }
+    /**
+     * Limpa o estado do gesto e remove listeners temporários.
+     * @private
+     * @returns {void}
+     */
+    cleanup() {
+        this.isActive = false;
+        this.startPoint = null;
+        // Para Pointer Events, libera a captura
+        if (this.eventType === 'pointer' && this.pointerId !== null) {
+            try {
+                this.element.releasePointerCapture(this.pointerId);
+            }
+            catch {
+                // Ignora erro se pointer já foi liberado
+            }
+            this.pointerId = null;
+        }
+        if (this.eventType === 'mouse') {
+            this.removeDocumentMouseListeners();
+        }
+    }
+    /**
+     * Registra um callback para um evento de swipe.
+     * @param evt - Nome do evento ('SWIPE_UP', 'SWIPE_DOWN', 'SWIPE_LEFT', 'SWIPE_RIGHT')
+     * @param cb - Função callback a ser executada quando o evento ocorrer
+     */
+    on(evt, cb) {
+        this.evtMap[evt].push(cb);
+    }
+    /**
+     * Remove um callback de um evento de swipe.
+     * @param evt - Nome do evento
+     * @param cb - Função callback a ser removida
+     */
+    off(evt, cb) {
+        this.evtMap[evt] = this.evtMap[evt].filter((callback) => callback !== cb);
+    }
+    /**
+     * Dispara um evento de swipe, executando todos os callbacks registrados.
+     * @private
+     * @param {SwipeEvent} evt - Nome do evento a ser disparado
+     * @param {unknown} [data] - Dados opcionais a serem passados aos callbacks
+     * @returns {void}
+     */
+    trigger(evt, data) {
+        this.evtMap[evt].forEach((handler) => {
+            handler(data);
+        });
+    }
+    /**
+     * Destrói a instância, removendo todos os event listeners.
+     * Deve ser chamado quando o elemento for removido do DOM.
+     * Remove o CSS touch-action aplicado no construtor.
+     * @public
+     * @returns {void}
+     * @example
+     * ```typescript
+     * disconnectedCallback() {
+     *   this.swipe?.destroy();
+     * }
+     * ```
+     */
+    destroy() {
+        this.cleanup();
+        this.detachListeners();
+        this.element.style.touchAction = '';
+        this.evtMap = {
+            SWIPE_UP: [],
+            SWIPE_DOWN: [],
+            SWIPE_LEFT: [],
+            SWIPE_RIGHT: [],
+        };
+    }
+}
+
+export { UniversalSwipe as U };

package/dist/esm/table-constants-CXMwM9m4.js

@@ -0,0 +1,170 @@
+/*!
+ * Construído por SERPRO
+ * © https://serpro.gov.br/ - MIT License.
+ */
+/**
+ * Valores semânticos para largura de coluna.
+ *
+ * Representam intenções de layout, abstraindo valores CSS concretos.
+ *
+ * @remarks
+ * - FILL: ocupa o espaço disponível (1fr)
+ * - CONTENT: ajusta ao conteúdo (max-content)
+ */
+const COLUMN_WIDTH_SEMANTICS = {
+    FILL: 'fill',
+    CONTENT: 'content',
+};
+/**
+ * Mapeia larguras semânticas para valores CSS reais.
+ */
+const COLUMN_WIDTH_MAP = {
+    [COLUMN_WIDTH_SEMANTICS.FILL]: '1fr',
+    [COLUMN_WIDTH_SEMANTICS.CONTENT]: 'max-content',
+};
+/**
+ * Densidades disponíveis para controle de espaçamento da tabela.
+ *
+ * @remarks
+ * - SMALL: compacto
+ * - MEDIUM: padrão
+ * - LARGE: espaçado
+ */
+const TABLE_DENSITY = {
+    SMALL: 'small',
+    MEDIUM: 'medium',
+    LARGE: 'large',
+};
+/**
+ * Mapeia densidades para valores CSS de espaçamento.
+ */
+const TABLE_DENSITY_MAP = {
+    [TABLE_DENSITY.SMALL]: '8px',
+    [TABLE_DENSITY.MEDIUM]: '16px',
+    [TABLE_DENSITY.LARGE]: '24px',
+};
+/**
+ * Opções de alinhamento do conteúdo nas células.
+ *
+ * @remarks
+ * - START
+ * - CENTER
+ * - END
+ */
+const TABLE_ALIGNMENT = {
+    START: 'start',
+    CENTER: 'center',
+    END: 'end',
+};
+/**
+ * Mapeia alinhamentos para valores CSS de posicionamento.
+ */
+const TABLE_ALIGNMENT_MAP = {
+    [TABLE_ALIGNMENT.START]: 'flex-start',
+    [TABLE_ALIGNMENT.CENTER]: 'center',
+    [TABLE_ALIGNMENT.END]: 'flex-end',
+};
+/**
+ * Estilos visuais disponíveis para divisores.
+ *
+ * @remarks
+ * - SOLID
+ * - DASHED
+ */
+const TABLE_DIVIDER_STYLE = {
+    SOLID: 'solid',
+    DASHED: 'dashed',
+};
+/**
+ * Mapeia estilos de divisor para valores CSS reais.
+ */
+const TABLE_DIVIDER_STYLE_MAP = {
+    [TABLE_DIVIDER_STYLE.SOLID]: 'solid',
+    [TABLE_DIVIDER_STYLE.DASHED]: 'dashed',
+};
+/**
+ * Opções de comportamento de overflow para células.
+ *
+ * @remarks
+ * - HIDDEN: oculta o conteúdo que ultrapassa os limites da célula
+ * - VISIBLE: permite que o conteúdo ultrapasse os limites da célula
+ */
+const TABLE_CELL_OVERFLOW = {
+    HIDDEN: 'hidden',
+    VISIBLE: 'visible',
+};
+/**
+ * Opções de comportamento de overflow para texto dentro das células.
+ *
+ * @remarks
+ * - ELLIPSIS: exibe reticências (...) quando o texto ultrapassa os limites da célula
+ * - CLIP: corta o texto que ultrapassa os limites da célula
+ */
+const TABLE_CELL_TEXT_OVERFLOW = {
+    ELLIPSIS: 'ellipsis',
+    CLIP: 'clip',
+};
+/**
+ * Opções de controle de quebra de linha para células.
+ *
+ * @remarks
+ * - NOWRAP: impede que o texto quebre em múltiplas linhas
+ * - NORMAL: permite que o texto quebre normalmente
+ */
+const TABLE_CELL_WHITE_SPACE = {
+    NOWRAP: 'nowrap',
+    NORMAL: 'normal',
+};
+/**
+ * Opções de controle de truncagem para células.
+ *
+ * @remarks
+ * - TRUNCATE: exibe reticências (...) quando o texto ultrapassa os limites da célula
+ * - WRAP: permite que o texto quebre em múltiplas linhas
+ */
+const TABLE_OVERFLOW = {
+    TRUNCATE: 'truncate',
+    WRAP: 'wrap',
+};
+/**
+ * Estados semânticos disponíveis para o tooltip das células.
+ *
+ * @remarks
+ * - INFO
+ * - WARNING
+ * - DANGER
+ * - SUCCESS
+ */
+const TABLE_TOOLTIP_STATE = {
+    INFO: 'info',
+    DANGER: 'danger'};
+/**
+ * Modos de resolução do tooltip nas células.
+ *
+ * @remarks
+ * - INHERIT: continua a resolução hierárquica
+ * - ENABLED: habilita o tooltip explicitamente
+ * - DISABLED: desabilita o tooltip explicitamente
+ */
+const TABLE_TOOLTIP_MODE = {
+    INHERIT: 'inherit',
+    ENABLED: 'enabled',
+    DISABLED: 'disabled',
+};
+/**
+ * Mapeia opções de controle de truncagem para configurações CSS correspondentes.
+ */
+const TABLE_OVERFLOW_MAP = {
+    [TABLE_OVERFLOW.TRUNCATE]: {
+        overflow: TABLE_CELL_OVERFLOW.HIDDEN,
+        textOverflow: TABLE_CELL_TEXT_OVERFLOW.ELLIPSIS,
+        whiteSpace: TABLE_CELL_WHITE_SPACE.NOWRAP,
+    },
+    [TABLE_OVERFLOW.WRAP]: {
+        overflow: TABLE_CELL_OVERFLOW.VISIBLE,
+        textOverflow: TABLE_CELL_TEXT_OVERFLOW.CLIP,
+        whiteSpace: TABLE_CELL_WHITE_SPACE.NORMAL,
+    },
+};
+
+export { COLUMN_WIDTH_MAP as C, TABLE_TOOLTIP_MODE as T, TABLE_TOOLTIP_STATE as a, TABLE_OVERFLOW as b, COLUMN_WIDTH_SEMANTICS as c, TABLE_ALIGNMENT_MAP as d, TABLE_ALIGNMENT as e, TABLE_OVERFLOW_MAP as f, TABLE_DENSITY_MAP as g, TABLE_DENSITY as h, TABLE_DIVIDER_STYLE_MAP as i, TABLE_DIVIDER_STYLE as j };

package/dist/esm/validator-D3tVP32U.js

@@ -0,0 +1,113 @@
+/*!
+ * Construído por SERPRO
+ * © https://serpro.gov.br/ - MIT License.
+ */
+/**
+ * Utilitários para manipulação e validação de formulários customizados.
+ *
+ * Inclui tipos e funções para atualização de validade e integração com ElementInternals.
+ */
+const safeSetFormValue = (internals, value, state) => {
+    try {
+        internals?.setFormValue(value, state);
+    }
+    catch {
+        // Alguns ambientes não implementam completamente ElementInternals.
+    }
+};
+const syncNativeFormValidity = (internals, nativeControl) => {
+    if (!nativeControl?.validity || !internals || typeof internals.setValidity !== 'function')
+        return;
+    internals.setValidity(nativeControl.validity, nativeControl.validationMessage, nativeControl);
+    nativeControl.setAttribute('aria-invalid', nativeControl.validity.valid ? 'false' : 'true');
+};
+/** Retorna um objeto simples, seguro para wrappers e builds lazy do Stencil. */
+const getFormValidationState = (internals) => {
+    const validity = internals?.validity;
+    const valid = validity?.valid ?? true;
+    return {
+        badInput: validity?.badInput ?? false,
+        customError: validity?.customError ?? false,
+        patternMismatch: validity?.patternMismatch ?? false,
+        rangeOverflow: validity?.rangeOverflow ?? false,
+        rangeUnderflow: validity?.rangeUnderflow ?? false,
+        stepMismatch: validity?.stepMismatch ?? false,
+        tooLong: validity?.tooLong ?? false,
+        tooShort: validity?.tooShort ?? false,
+        typeMismatch: validity?.typeMismatch ?? false,
+        valid,
+        validationMessage: internals?.validationMessage ?? '',
+        valueMissing: validity?.valueMissing ?? false,
+        willValidate: internals?.willValidate ?? false,
+    };
+};
+/** Aplica uma validade calculada por controles sem equivalente nativo direto. */
+const setFormValidity = (internals, flags, message = '', anchor) => {
+    if (!internals)
+        return;
+    const invalid = Object.values(flags).some(Boolean);
+    if (invalid)
+        internals.setValidity(flags, message || 'Valor inválido.', anchor);
+    else
+        internals.setValidity({});
+    anchor?.setAttribute('aria-invalid', invalid ? 'true' : 'false');
+};
+const isFormControlDisabled = (disabled, formDisabled) => {
+    return disabled || formDisabled;
+};
+const getCheckableFormValue = (checked, value, fallback = 'on') => {
+    return checked ? value || fallback : null;
+};
+const getCheckableRestoreState = (checked) => {
+    return checked ? 'checked' : 'unchecked';
+};
+
+const GLOBAL_IDENTIFIER = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*$/;
+const SAFE_INLINE_EXPRESSION = /^\(?\s*([A-Za-z_$][\w$]*)\s*\)?\s*=>\s*\1\s*(===|!==)\s*(['"])(.*?)\3\s*\?\s*(['"])(.*?)\5\s*:\s*(null|undefined|''|"")\s*$/s;
+const decodeLiteral = (value, quote) => quote === '"' ? JSON.parse(`"${value}"`) : value.replace(/\\(['\\])/g, '$1');
+/**
+ * Mantém a forma inline legada mais simples sem interpretar JavaScript.
+ * Expressões fora deste subconjunto devem migrar para função ou nome global.
+ */
+const resolveSafeInlineExpression = (expression) => {
+    const match = SAFE_INLINE_EXPRESSION.exec(expression);
+    if (!match)
+        return null;
+    const [, , operator, compareQuote, compareValue, messageQuote, messageValue] = match;
+    const expected = decodeLiteral(compareValue, compareQuote);
+    const message = decodeLiteral(messageValue, messageQuote);
+    return (value) => operator === '===' ? (value === expected ? message : null) : value !== expected ? message : null;
+};
+const resolveGlobalFunction = (name) => {
+    if (!GLOBAL_IDENTIFIER.test(name))
+        return null;
+    let current = globalThis;
+    for (const segment of name.split('.')) {
+        if (segment === '__proto__' || segment === 'prototype' || segment === 'constructor')
+            return null;
+        if (typeof current !== 'object' || current === null || !Reflect.ownKeys(current).includes(segment)) {
+            return null;
+        }
+        current = current[segment];
+    }
+    return typeof current === 'function' ? current : null;
+};
+/** Resolve validators recebidos por property binding ou por nome global legado. */
+function resolveFormValidator(validator) {
+    if (typeof validator === 'function')
+        return validator;
+    if (typeof validator !== 'string' || !validator.trim())
+        return null;
+    const name = validator.trim();
+    return resolveGlobalFunction(name) ?? resolveSafeInlineExpression(name);
+}
+async function runFormValidator(validator, value) {
+    try {
+        return (await validator(value)) || null;
+    }
+    catch {
+        return 'Não foi possível validar o campo.';
+    }
+}
+
+export { runFormValidator as a, getCheckableFormValue as b, setFormValidity as c, getCheckableRestoreState as d, syncNativeFormValidity as e, getFormValidationState as g, isFormControlDisabled as i, resolveFormValidator as r, safeSetFormValue as s };