@govbr-ds/webcomponents 2.1.0 → 2.1.1

package/dist/collection/shared/utils/isNil.js

@@ -0,0 +1,15 @@
+/*!
+ * Construído por SERPRO
+ * © https://serpro.gov.br/ - MIT License.
+ */
+/**
+ * Utilitário para validação de valores nulos ou indefinidos.
+ *
+ * Verifica se o valor é `null` ou `undefined`.
+ *
+ * @param value Valor a ser avaliado.
+ * @returns `true` quando o valor é nulo.
+ */
+export const isNil = (value) => {
+    return value === null || value === undefined;
+};

package/dist/collection/shared/utils/isString.js

@@ -0,0 +1,20 @@
+/*!
+ * Construído por SERPRO
+ * © https://serpro.gov.br/ - MIT License.
+ */
+/**
+ * Utilitário para validação de strings.
+ *
+ * Verifica se um valor é uma string primitiva ou objeto `String`.
+ *
+ * @param value Valor a ser avaliado.
+ * @returns `true` quando o valor representa uma string.
+ */
+export const isString = (value) => {
+    const type = typeof value;
+    return (type === 'string' ||
+        (type === 'object' &&
+            value != null &&
+            !Array.isArray(value) &&
+            Object.prototype.toString.call(value) === '[object String]'));
+};

package/dist/collection/shared/utils/native-dialog.js

@@ -0,0 +1,44 @@
+/*!
+ * Construído por SERPRO
+ * © https://serpro.gov.br/ - MIT License.
+ */
+/**
+ * Sincroniza um `<dialog>` modal e mantém `open` como fallback em navegadores
+ * sem `showModal()`. Retorna `true` quando a top layer nativa foi utilizada.
+ */
+export const supportsNativeModalDialog = () => typeof HTMLDialogElement !== 'undefined' && typeof HTMLDialogElement.prototype.showModal === 'function';
+const closeNativeDialog = (dialog) => {
+    if (dialog.open || dialog.hasAttribute('open')) {
+        try {
+            if (typeof dialog.close === 'function')
+                dialog.close();
+            else
+                dialog.removeAttribute('open');
+        }
+        catch {
+            dialog.removeAttribute('open');
+        }
+    }
+};
+export const syncNativeModalDialog = (dialog, shouldOpen) => {
+    if (dialog === null || !dialog.isConnected)
+        return false;
+    if (!shouldOpen) {
+        closeNativeDialog(dialog);
+        return false;
+    }
+    if (dialog.open)
+        return typeof dialog.showModal === 'function';
+    if (typeof dialog.showModal === 'function') {
+        try {
+            dialog.showModal();
+            return true;
+        }
+        catch {
+            dialog.setAttribute('open', '');
+            return false;
+        }
+    }
+    dialog.setAttribute('open', '');
+    return false;
+};

package/dist/collection/shared/utils/navigation.js

@@ -0,0 +1,21 @@
+/*!
+ * Construído por SERPRO
+ * © https://serpro.gov.br/ - MIT License.
+ */
+export const shouldIgnoreNavigationClick = (event) => event.button !== 0 || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey;
+export const handleNavigationClick = ({ event, href, target, navigationMode = 'native', brNavigate, }) => {
+    if (!href || shouldIgnoreNavigationClick(event)) {
+        return false;
+    }
+    if (target && target !== '_self') {
+        return false;
+    }
+    if (navigationMode !== 'event') {
+        return false;
+    }
+    if (brNavigate?.emit({ event, href })?.defaultPrevented) {
+        event.preventDefault();
+        return true;
+    }
+    return false;
+};

package/dist/collection/shared/utils/parts.js

@@ -0,0 +1,15 @@
+/*!
+ * Construído por SERPRO
+ * © https://serpro.gov.br/ - MIT License.
+ */
+export function setPartAttributes(el, part, exportparts) {
+    if (el === undefined || el === null)
+        return;
+    if (part !== undefined) {
+        el.setAttribute('part', part);
+        el.part.add(...part.split(/\s+/).filter(Boolean));
+    }
+    if (exportparts !== undefined) {
+        el.setAttribute('exportparts', exportparts);
+    }
+}

package/dist/collection/shared/utils/prop-warning.js

@@ -0,0 +1,7 @@
+/*!
+ * Construído por SERPRO
+ * © https://serpro.gov.br/ - MIT License.
+ */
+export function warnInvalidPropValue(componentTag, propName, receivedValue, defaultValue) {
+    console.warn(`[${componentTag}]: valor invalido para "${propName}": "${String(receivedValue)}". Usando valor padrao "${defaultValue}".`);
+}

package/dist/collection/shared/utils/props.js

@@ -0,0 +1,37 @@
+/*!
+ * Construído por SERPRO
+ * © https://serpro.gov.br/ - MIT License.
+ */
+/**
+ * Utilitários para validação de propriedades de elementos customizados.
+ *
+ * Inclui tipos auxiliares e função para validar valores permitidos em props.
+ */
+export const isValidPropValue = (value, acceptedValues) => {
+    return acceptedValues.includes(value);
+};
+export const normalizePropValue = (value, acceptedValues, fallbackValue, warning) => {
+    if (isValidPropValue(value, acceptedValues))
+        return value;
+    if (warning) {
+        console.warn(`[${warning.component}] Atenção: "${warning.property}" deve ser um dos valores: ${acceptedValues.join('|')}`);
+    }
+    return fallbackValue;
+};
+/**
+ * Valida se uma propriedade do elemento possui um valor permitido.
+ *
+ * Quando o valor atual não estiver na lista de aceitos, aplica `fallbackValue`
+ * e registra um aviso no console para auxiliar o desenvolvimento.
+ *
+ * @param ACCEPTED_VALUES Lista de valores válidos.
+ * @param fallbackValue Valor de fallback aplicado em caso de valor inválido.
+ * @param element Referência do elemento que contém a propriedade.
+ * @param propertyName Nome da propriedade a validar.
+ */
+export const validatePropValue = (ACCEPTED_VALUES, fallbackValue, element, propertyName) => {
+    element[propertyName] = normalizePropValue(element[propertyName], ACCEPTED_VALUES, fallbackValue, {
+        component: element.tagName.toLowerCase(),
+        property: String(propertyName),
+    });
+};

package/dist/collection/shared/utils/raf-batcher.js

@@ -0,0 +1,51 @@
+/*!
+ * Construído por SERPRO
+ * © https://serpro.gov.br/ - MIT License.
+ */
+/**
+ * Agenda apenas o último valor recebido para o próximo frame.
+ */
+export function createRafBatcher(callback) {
+    let frame = null;
+    let pending;
+    let hasPending = false;
+    const run = () => {
+        frame = null;
+        if (!hasPending)
+            return;
+        const value = pending;
+        pending = undefined;
+        hasPending = false;
+        callback(value);
+    };
+    return {
+        schedule(value) {
+            pending = value;
+            hasPending = true;
+            if (frame !== null)
+                return;
+            frame = typeof requestAnimationFrame === 'function' ? requestAnimationFrame(run) : window.setTimeout(run, 16);
+        },
+        flush() {
+            if (frame !== null) {
+                if (typeof cancelAnimationFrame === 'function')
+                    cancelAnimationFrame(frame);
+                else
+                    clearTimeout(frame);
+                frame = null;
+            }
+            run();
+        },
+        cancel() {
+            if (frame !== null) {
+                if (typeof cancelAnimationFrame === 'function')
+                    cancelAnimationFrame(frame);
+                else
+                    clearTimeout(frame);
+            }
+            frame = null;
+            pending = undefined;
+            hasPending = false;
+        },
+    };
+}

package/dist/collection/shared/utils/scrollLock.js

@@ -0,0 +1,141 @@
+/*!
+ * Construído por SERPRO
+ * © https://serpro.gov.br/ - MIT License.
+ */
+/**
+ * Utilitários para bloqueio e liberação de scroll global na página.
+ *
+ * Permite controlar o scroll do body, útil para modais, overlays e menus.
+ */
+import { isClient } from "./isClient";
+/**
+ * Estado global compartilhado do controle de lock de scroll.
+ */
+const state = {
+    // O lockCount registra quantos componentes solicitaram bloqueio simultaneamente.
+    lockCount: 0,
+    config: {
+        debug: false,
+        bodyClassName: 'bq-body--scroll-lock',
+        preserveScrollPosition: true,
+    },
+    scrollY: 0,
+    previousBodyStyle: {},
+    previousDocumentOverflow: '',
+};
+/**
+ * Emite mensagens de debug quando o modo está ativado.
+ *
+ * @param message Mensagem a ser registrada.
+ */
+const logDebug = (message) => {
+    if (!state.config.debug)
+        return;
+    console.log(`[WBC ScrollLock] ${message}`);
+};
+/**
+ * Aplica ou remove a classe CSS de bloqueio de scroll.
+ *
+ * @param shouldLock `true` para aplicar o lock; `false` para remover.
+ */
+const toggleScrollLockClass = (shouldLock) => {
+    const action = shouldLock ? 'add' : 'remove';
+    document.body.classList[action](state.config.bodyClassName);
+};
+const applyFixedBodyLock = () => {
+    state.scrollY = window.scrollY || window.pageYOffset || 0;
+    state.previousBodyStyle = {
+        left: document.body.style.left,
+        position: document.body.style.position,
+        right: document.body.style.right,
+        top: document.body.style.top,
+        width: document.body.style.width,
+    };
+    state.previousDocumentOverflow = document.documentElement.style.overflow;
+    document.body.style.position = 'fixed';
+    document.body.style.top = `-${state.scrollY}px`;
+    document.body.style.left = '0';
+    document.body.style.right = '0';
+    document.body.style.width = '100%';
+    document.documentElement.style.overflow = 'hidden';
+};
+const restoreFixedBodyLock = () => {
+    document.body.style.position = state.previousBodyStyle.position ?? '';
+    document.body.style.top = state.previousBodyStyle.top ?? '';
+    document.body.style.left = state.previousBodyStyle.left ?? '';
+    document.body.style.right = state.previousBodyStyle.right ?? '';
+    document.body.style.width = state.previousBodyStyle.width ?? '';
+    document.documentElement.style.overflow = state.previousDocumentOverflow;
+    window.scrollTo(0, state.scrollY);
+};
+/**
+ * Configura o comportamento global do scroll lock.
+ *
+ * @param config Configuração parcial para sobrescrever os padrões.
+ */
+export const configureScrollLock = (config) => {
+    state.config = { ...state.config, ...config };
+};
+/**
+ * Retorna o número atual de locks ativos.
+ */
+export const getScrollLockCount = () => {
+    return state.lockCount;
+};
+/**
+ * Indica se o scroll do body está bloqueado neste momento.
+ */
+export const isBodyScrollLocked = () => {
+    return state.lockCount > 0;
+};
+/**
+ * Bloqueia o scroll do body com contagem de referência.
+ *
+ * Múltiplas chamadas exigem o mesmo número de `unlockBodyScroll`.
+ */
+export const lockBodyScroll = () => {
+    if (!isClient())
+        return;
+    state.lockCount++;
+    // Só aplica classe na primeira solicitação.
+    if (state.lockCount !== 1)
+        return;
+    toggleScrollLockClass(true);
+    if (state.config.preserveScrollPosition)
+        applyFixedBodyLock();
+    logDebug(`Scroll do body bloqueado (contagem: ${state.lockCount})`);
+};
+/**
+ * Remove o lock do body com contagem de referência.
+ *
+ * É seguro chamar mesmo quando nenhum lock está ativo.
+ */
+export const unlockBodyScroll = () => {
+    if (!isClient())
+        return;
+    if (state.lockCount === 0)
+        return;
+    state.lockCount = Math.max(0, state.lockCount - 1);
+    // Só remove classe quando todos os locks forem liberados.
+    if (state.lockCount !== 0)
+        return;
+    if (state.config.preserveScrollPosition)
+        restoreFixedBodyLock();
+    toggleScrollLockClass(false);
+    logDebug(`Scroll do body desbloqueado (contagem: ${state.lockCount})`);
+};
+/**
+ * Força a remoção de todos os locks ativos (utilitário de limpeza).
+ */
+export const forceUnlockAllBodyScroll = () => {
+    if (!isClient())
+        return;
+    if (state.lockCount === 0)
+        return;
+    state.lockCount = 0;
+    if (state.config.preserveScrollPosition)
+        restoreFixedBodyLock();
+    toggleScrollLockClass(false);
+    logDebug('Todos os bloqueios de scroll do body foram removidos');
+};
+export const getBodyScrollLockPosition = () => state.scrollY;

package/dist/collection/shared/utils/setRafTimeout.js

@@ -0,0 +1,38 @@
+/*!
+ * Construído por SERPRO
+ * © https://serpro.gov.br/ - MIT License.
+ */
+/**
+ * Utilitário para agendar execução de funções usando requestAnimationFrame ou setTimeout.
+ *
+ * Permite atrasar a execução de funções de forma eficiente para animações ou debounce.
+ *
+ * @param func Função a ser executada.
+ * @param wait Tempo de espera em milissegundos.
+ * @param args Argumentos repassados para `func`.
+ * @returns Função de cancelamento da execução agendada.
+ */
+export const setRafTimeout = (func, wait, ...args) => {
+    const invokeFunc = () => func(...args);
+    if (wait === 0) {
+        const timeoutId = setTimeout(invokeFunc, wait);
+        return () => clearTimeout(timeoutId);
+    }
+    else {
+        let rafId;
+        const currentTime = performance.now();
+        const cancel = () => cancelAnimationFrame(rafId);
+        const handleRequestAnimationFrame = (time) => {
+            const delta = time - currentTime;
+            cancel();
+            if (delta < wait) {
+                rafId = requestAnimationFrame(handleRequestAnimationFrame);
+            }
+            else {
+                invokeFunc();
+            }
+        };
+        rafId = requestAnimationFrame(handleRequestAnimationFrame);
+        return cancel;
+    }
+};

package/dist/collection/shared/utils/slot.js

@@ -0,0 +1,113 @@
+/*!
+ * Construído por SERPRO
+ * © https://serpro.gov.br/ - MIT License.
+ */
+/*=========================================================================================
+= Credit:                                                                                =
+= https://github.com/shoelace-style/shoelace/blob/next/src/utilities/slot.ts             =
+=========================================================================================*/
+/**
+ * Utilitários para manipulação e leitura de slots em Web Components.
+ *
+ * Funções para extrair texto, HTML e navegar por nós atribuídos a slots.
+ */
+function isElementNode(node) {
+    return node.nodeType === Node.ELEMENT_NODE;
+}
+function isTextNode(node) {
+    return node.nodeType === Node.TEXT_NODE;
+}
+function getText(node, currentLevel = 1, maxLevel = Infinity) {
+    let text = '';
+    if (currentLevel <= maxLevel) {
+        if (isTextNode(node)) {
+            text += node.textContent;
+        }
+        else if (isElementNode(node) && node.hasChildNodes()) {
+            const nextLevel = currentLevel + 1;
+            node.childNodes.forEach((node) => {
+                text += getText(node, nextLevel, maxLevel);
+            });
+        }
+    }
+    return text;
+}
+/**
+ * Concatena o HTML dos nós atribuídos a um slot.
+ *
+ * Inclui nós de elemento (via `outerHTML`) e nós de texto (via `textContent`).
+ *
+ * @param slot Elemento de slot a ser lido.
+ * @returns HTML concatenado dos nós atribuídos.
+ */
+export function getInnerHTML(slot) {
+    const nodes = slot.assignedNodes({ flatten: true });
+    let html = '';
+    Array.from(nodes).forEach((node) => {
+        if (isElementNode(node)) {
+            html += node.outerHTML;
+        }
+        if (isTextNode(node)) {
+            html += node.textContent;
+        }
+    });
+    return html;
+}
+export function getTextContent(slot, options) {
+    const nodes = slot.assignedNodes({ flatten: true });
+    const { recurse = false, maxLevel } = options ?? {};
+    let text = '';
+    Array.from(nodes).forEach((node) => {
+        text += getText(node, 1, recurse ? maxLevel : 1);
+    });
+    return text.trim();
+}
+/**
+ * Verifica se um elemento possui conteúdo atribuído para um slot específico.
+ *
+ * @param el Elemento host que contém os nós com atributo `slot`.
+ * @param name Nome do slot que será verificado.
+ * @returns `true` quando há pelo menos um nó atribuído ao slot informado.
+ */
+export function hasSlot(el, name) {
+    return (Array.from(el.querySelectorAll('[slot]')).filter((slottedEl) => slottedEl.slot === name).length > 0);
+}
+/**
+ * Verifica se um slot do shadow DOM possui elementos atribuídos.
+ *
+ * @param el Elemento que contém o slot no shadow DOM.
+ * @param name Nome opcional do slot. Quando omitido, usa o slot padrão.
+ * @returns `true` quando o slot possui elementos atribuídos.
+ */
+export function hasSlotContent(el, name) {
+    if (!el)
+        return false;
+    const slotSelector = name ? `[name='${name}']` : '';
+    const slotContent = el.querySelector(`slot${slotSelector}`)?.assignedElements({ flatten: true });
+    if (!(slotContent && Array.isArray(slotContent)))
+        return false;
+    return !!slotContent.length;
+}
+/**
+ * Recalcula se um slot possui conteúdo efetivamente atribuído.
+ * Elementos e textos não vazios contam; espaços em branco isolados não contam.
+ */
+export function hasAssignedSlotContent(slot) {
+    return slot.assignedNodes({ flatten: true }).some((node) => {
+        if (isElementNode(node))
+            return true;
+        return isTextNode(node) && node.textContent.trim() !== '';
+    });
+}
+export function hasNamedLightDomSlot(el, name) {
+    return Array.from(el.children).some((child) => child.getAttribute('slot') === name);
+}
+export function hasDefaultLightDomContent(el) {
+    return Array.from(el.childNodes).some((node) => {
+        if (isElementNode(node) && node.hasAttribute('slot'))
+            return false;
+        if (isTextNode(node))
+            return node.textContent.trim() !== '';
+        return isElementNode(node);
+    });
+}

package/dist/collection/shared/utils/ssr-date.js

@@ -0,0 +1,33 @@
+/*!
+ * Construído por SERPRO
+ * © https://serpro.gov.br/ - MIT License.
+ */
+const SSR_MOMENT_ATTRIBUTE = 'data-br-ssr-moment';
+function serializeLocalDate(date) {
+    return [
+        date.getFullYear(),
+        date.getMonth(),
+        date.getDate(),
+        date.getHours(),
+        date.getMinutes(),
+        date.getSeconds(),
+        date.getMilliseconds(),
+    ].join('-');
+}
+function parseLocalDate(value) {
+    const parts = value.split('-').map(Number);
+    if (parts.length !== 7 || parts.some((part) => !Number.isFinite(part)))
+        return null;
+    const [year, month, day, hours, minutes, seconds, milliseconds] = parts;
+    const date = new Date(year, month, day, hours, minutes, seconds, milliseconds);
+    return Number.isNaN(date.getTime()) ? null : date;
+}
+/** Mantém defaults baseados no relógio idênticos entre SSR e hidratação. */
+export function resolveSsrLocalDate(host, fallback) {
+    const hydrated = parseLocalDate(host.getAttribute(SSR_MOMENT_ATTRIBUTE) ?? '');
+    if (hydrated)
+        return hydrated;
+    if (!Number.isNaN(fallback.getTime()))
+        host.setAttribute(SSR_MOMENT_ATTRIBUTE, serializeLocalDate(fallback));
+    return fallback;
+}

package/dist/collection/shared/utils/stringToArray.js

@@ -0,0 +1,29 @@
+/*!
+ * Construído por SERPRO
+ * © https://serpro.gov.br/ - MIT License.
+ */
+/**
+ * Utilitário para conversão de string JSON ou array em array de strings.
+ *
+ * Facilita o tratamento de props que aceitam múltiplos valores em formato string ou array.
+ */
+import { isDefined } from "./isDefined";
+import { isString } from "./isString";
+/**
+ * Converte uma string JSON ou um array em um array de strings.
+ *
+ * @param value Valor de entrada (`string` JSON ou `string[]`).
+ * @returns Array de strings normalizado.
+ * @throws Error Quando a string informada não for um JSON de array válido.
+ */
+export const stringToArray = (value) => {
+    if (isString(value) && isDefined(value)) {
+        try {
+            return Array.from(JSON.parse(String(value)));
+        }
+        catch (error) {
+            throw new Error(`Failed to parse string to array. Input must be a valid JSON array string. Details: ${error.message}`);
+        }
+    }
+    return Array.isArray(value) ? value : [];
+};