@govbr-ds/webcomponents 2.1.0 → 2.1.1

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

@@ -0,0 +1,39 @@
+/*!
+ * Construído por SERPRO
+ * © https://serpro.gov.br/ - MIT License.
+ */
+/**
+ * Utilitário debounce para atrasar a execução de funções.
+ *
+ * Permite controlar a frequência de execução de funções, útil para otimizar eventos de input, resize, scroll, etc.
+ */
+import { isNil } from "./isNil";
+import { setRafTimeout } from "./setRafTimeout";
+/**
+ * Cria uma função com debounce.
+ *
+ * A execução de `func` é adiada até que o intervalo `wait` termine após a última invocação.
+ *
+ * @param func Função que será executada com debounce.
+ * @param wait Tempo de espera em milissegundos.
+ * @param immediate Quando `true`, executa imediatamente na primeira chamada e aguarda o intervalo para novas execuções.
+ * @returns Função com debounce e método `cancel`.
+ */
+export const debounce = (func, wait = 0, immediate = false) => {
+    let cancel;
+    function debounceHandler(...args) {
+        cancel?.();
+        function timeoutHandler(fn, context, ...args) {
+            fn.apply(context, args);
+        }
+        if (immediate && isNil(cancel)) {
+            func.apply(this, args);
+        }
+        cancel = setRafTimeout(timeoutHandler, wait, func, this, ...args);
+    }
+    return Object.assign(debounceHandler, {
+        cancel: () => {
+            cancel?.();
+        },
+    });
+};

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

@@ -0,0 +1,55 @@
+/*!
+ * Construído por SERPRO
+ * © https://serpro.gov.br/ - MIT License.
+ */
+export const getEventPath = (event) => {
+    if (typeof event.composedPath === 'function')
+        return event.composedPath();
+    return event.target ? [event.target] : [];
+};
+export const getEventTarget = (event) => {
+    return getEventPath(event)[0] ?? null;
+};
+export const isEventTargetInside = (event, element) => {
+    return !!element && getEventPath(event).includes(element);
+};
+export const isEventTargetOutside = (event, ...elements) => {
+    return elements.every((element) => !isEventTargetInside(event, element));
+};
+export const findEventPathIndex = (event, predicate) => {
+    return getEventPath(event).findIndex(predicate);
+};
+/**
+ * @deprecated Use `isEventTargetInside`.
+ */
+export const isEventTargetChildOfElement = (event, hostElement) => {
+    return isEventTargetInside(event, hostElement);
+};
+/**
+ * Emite no host um evento de formulário real, impedindo que o evento originado
+ * dentro do Shadow DOM seja observado duas vezes pelo consumidor.
+ */
+export const redispatchNativeEvent = (host, source, type = source.type, init = {
+    bubbles: source.bubbles,
+    composed: source.composed,
+    cancelable: source.cancelable,
+}) => {
+    source.stopPropagation();
+    const event = type === 'input' && typeof InputEvent !== 'undefined'
+        ? new InputEvent(type, {
+            ...init,
+            data: source instanceof InputEvent ? source.data : null,
+            inputType: source instanceof InputEvent ? source.inputType : '',
+        })
+        : typeof ToggleEvent !== 'undefined' && source instanceof ToggleEvent
+            ? new ToggleEvent(type, { ...init, newState: source.newState, oldState: source.oldState })
+            : new Event(type, init);
+    return host.dispatchEvent(event);
+};
+export const redispatchNativeFormEvent = (host, source, type = source.type) => redispatchNativeEvent(host, source, type, { bubbles: true, composed: true, cancelable: false });
+/** Emite um evento nativo de formulário para interações sem evento DOM de origem. */
+export const dispatchNativeFormEvent = (host, type) => {
+    const init = { bubbles: true, composed: true, cancelable: false };
+    const event = type === 'input' && typeof InputEvent !== 'undefined' ? new InputEvent(type, init) : new Event(type, init);
+    return host.dispatchEvent(event);
+};

package/dist/collection/shared/utils/floating-surface-dismiss.js

@@ -0,0 +1,59 @@
+/*!
+ * Construído por SERPRO
+ * © https://serpro.gov.br/ - MIT License.
+ */
+const BLOCKING_SURFACE_OPEN_EVENTS = ['brScrimOpen', 'brCookiebarShow', 'brMenuOpenChange'];
+const registries = new WeakMap();
+const isOpeningEvent = (event) => event.type !== 'brMenuOpenChange' || event.detail?.open === true;
+const notifySubscriptions = (registry, event) => {
+    const blocker = event.target;
+    for (const subscription of [...registry.subscriptions]) {
+        if (!subscription.host.isConnected) {
+            registry.subscriptions.delete(subscription);
+            continue;
+        }
+        if (blocker instanceof Element && (blocker === subscription.host || blocker.contains(subscription.host)))
+            continue;
+        subscription.dismiss();
+    }
+};
+/** Fecha uma superfície flutuante quando um bloqueador externo é aberto. */
+export const listenForExternalBlockingSurface = (host, dismiss) => {
+    const ownerDocument = host.ownerDocument;
+    let registry = registries.get(ownerDocument);
+    if (registry === undefined) {
+        const subscriptions = new Set();
+        const handlers = new Map();
+        registry = { subscriptions, handlers };
+        BLOCKING_SURFACE_OPEN_EVENTS.forEach((eventName) => {
+            const handler = (event) => {
+                if (!isOpeningEvent(event))
+                    return;
+                const current = registries.get(ownerDocument);
+                if (current !== undefined)
+                    notifySubscriptions(current, event);
+            };
+            handlers.set(eventName, handler);
+            ownerDocument.addEventListener(eventName, handler);
+        });
+        registries.set(ownerDocument, registry);
+    }
+    const subscription = { host, dismiss };
+    registry.subscriptions.add(subscription);
+    let active = true;
+    return () => {
+        if (!active)
+            return;
+        active = false;
+        const current = registries.get(ownerDocument);
+        if (current === undefined)
+            return;
+        current.subscriptions.delete(subscription);
+        if (current.subscriptions.size > 0)
+            return;
+        current.handlers.forEach((handler, eventName) => {
+            ownerDocument.removeEventListener(eventName, handler);
+        });
+        registries.delete(ownerDocument);
+    };
+};

package/dist/collection/shared/utils/floating-ui.js

@@ -0,0 +1,131 @@
+/*!
+ * Construído por SERPRO
+ * © https://serpro.gov.br/ - MIT License.
+ */
+/**
+ * Utilitários para gerenciamento de posicionamento flutuante (Floating UI).
+ *
+ * Inclui classe e tipos para facilitar tooltips, popovers e overlays usando a biblioteca Floating UI.
+ */
+import { arrow, autoUpdate, computePosition, flip, hide, offset, shift, } from "@floating-ui/dom";
+/**
+ * FloatingUIManager é uma classe utilitária que gerencia o posicionamento de elementos flutuantes
+ * como tooltips ou popovers em relação a um elemento de disparo (trigger).
+ * Ela utiliza a biblioteca Floating UI para calcular posições e lidar com atualizações.
+ */
+export class FloatingUIManager {
+    constructor(options) {
+        this.triggerElement = options.triggerElement;
+        this.contentElement = options.contentElement;
+        this.arrowElement = options.arrowElement;
+        this.placement = options.placement ?? 'top';
+        this.strategy = options.strategy ?? 'absolute';
+        this.boundary = options.boundary ?? 'clippingAncestors';
+        this.offsetDistance = options.offset ?? 8;
+        this.onUpdate = options.onUpdate;
+    }
+    /**
+     * Inicia o gerenciador Floating UI configurando a atualização automática da posição.
+     */
+    start() {
+        this.stop();
+        this.contentElement.style.position = this.strategy;
+        this.cleanupAutoUpdate = autoUpdate(this.triggerElement, this.contentElement, () => this.updatePosition());
+    }
+    /**
+     * Para o gerenciador Floating UI e limpa os recursos utilizados.
+     */
+    stop() {
+        const cleanup = this.cleanupAutoUpdate;
+        this.cleanupAutoUpdate = undefined;
+        cleanup?.();
+    }
+    /**
+     * Atualiza a posição do elemento flutuante com base no elemento disparador e no elemento de conteúdo.
+     * Esta função é chamada automaticamente quando o gerenciador está ativo.
+     * Ela calcula a nova posição usando a biblioteca Floating UI e aplica as transformações necessárias.
+     * Também atualiza a posição da seta, se fornecida.
+     * Além disso, define o atributo de dados `data-placement` no elemento de conteúdo para refletir a posição atual.
+     * @returns {Promise<void>} Uma promessa que resolve quando a posição é atualizada.
+     */
+    async updatePosition() {
+        const data = await computePosition(this.triggerElement, this.contentElement, {
+            placement: this.placement,
+            strategy: this.strategy,
+            middleware: this.buildMiddleware(),
+        });
+        this.updateTooltipPosition(data);
+        this.updateArrowPosition(data);
+        this.setPlacementDataAttribute(data);
+        this.onUpdate?.(data);
+    }
+    /**
+     * Constrói os middlewares necessários para o Floating UI.
+     * Esses middlewares são usados para ajustar o posicionamento do elemento flutuante,
+     * incluindo offset, flip, shift e hide. Se uma seta for fornecida, o middleware de seta também é adicionado.
+     * @returns {Middleware[]} Retorna um array de middlewares configurados para o Floating UI.
+     */
+    buildMiddleware() {
+        const middleware = [
+            offset(this.offsetDistance),
+            flip({ boundary: this.boundary }),
+            shift({ boundary: this.boundary, padding: 5 }),
+            hide({ boundary: this.boundary }),
+        ];
+        if (this.arrowElement != null) {
+            middleware.push(arrow({ element: this.arrowElement }));
+        }
+        return middleware;
+    }
+    /**
+     * Adiciona o estilo necessário para posicionar o tooltip com base nas coordenadas fornecidas.
+     * Esta função é chamada após o cálculo da posição do tooltip.
+     * Ela aplica as propriedades CSS `left` e `top` ao elemento de conteúdo do tooltip.
+     * @param data Contém as coordenadas x e y para posicionar o tooltip.
+     */
+    updateTooltipPosition(data) {
+        const { x, y } = data;
+        Object.assign(this.contentElement.style, {
+            left: `${x}px`,
+            top: `${y}px`,
+            position: this.strategy,
+        });
+    }
+    /**
+     * Adiciona o estilo necessário para posicionar a seta do tooltip com base nos dados de middleware.
+     * Esta função é chamada após o cálculo da posição do tooltip.
+     * Ela aplica as propriedades CSS `left`, `top`, `right`, `bottom` e a posição estática da seta.
+     * A posição estática é determinada com base na colocação do tooltip (top, right, bottom, left).
+     * Se a seta não estiver presente ou os dados de middleware não contiverem informações sobre a seta, nada será feito.
+     * @param data Contém a posição da seta e os dados de middleware.
+     */
+    updateArrowPosition(data) {
+        if (this.arrowElement == null || data.middlewareData.arrow == null)
+            return;
+        const { x: arrowX, y: arrowY } = data.middlewareData.arrow;
+        const basePlacement = data.placement.split('-')[0];
+        const staticSide = {
+            top: 'bottom',
+            right: 'left',
+            bottom: 'top',
+            left: 'right',
+        }[basePlacement];
+        Object.assign(this.arrowElement.style, {
+            left: arrowX == null ? '' : `${arrowX}px`,
+            top: arrowY == null ? '' : `${arrowY}px`,
+            right: '',
+            bottom: '',
+            [staticSide]: '-4px',
+        });
+    }
+    /**
+     * Define o atributo de dados `data-placement` no elemento de conteúdo.
+     * Este atributo é usado para indicar a posição atual do tooltip ou popover.
+     * Ele é útil para fins de acessibilidade e para permitir que estilos CSS sejam aplicados com base na posição.
+     * @param data Objeto contendo a propriedade `placement` que define a posição do tooltip ou popover.
+     *            A propriedade `placement` deve ser uma string representando a posição, como 'top', 'bottom', 'left', 'right', etc.
+     */
+    setPlacementDataAttribute(data) {
+        this.contentElement.setAttribute('data-placement', data.placement);
+    }
+}

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

@@ -0,0 +1,24 @@
+/*!
+ * Construído por SERPRO
+ * © https://serpro.gov.br/ - MIT License.
+ */
+/** Captura o elemento que deve recuperar o foco após uma superfície fechar. */
+export const captureFocus = (ownerDocument = document) => {
+    const activeElement = ownerDocument.activeElement;
+    return activeElement instanceof HTMLElement ? activeElement : null;
+};
+/** Recupera o foco apenas quando o alvo ainda pertence ao documento. */
+export const restoreFocus = (target) => {
+    if (!target?.isConnected)
+        return;
+    requestAnimationFrame(() => {
+        if (target.isConnected)
+            target.focus({ preventScroll: true });
+    });
+};
+/** Retorna o elemento ativo mais profundo através de Shadow DOM aninhado. */
+export const getDeepActiveElement = (root = document) => {
+    const activeElement = root.activeElement;
+    const shadowRoot = activeElement && 'shadowRoot' in activeElement ? activeElement.shadowRoot : null;
+    return shadowRoot?.activeElement ? getDeepActiveElement(shadowRoot) : activeElement;
+};

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

@@ -0,0 +1,82 @@
+/*!
+ * 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.
+ */
+import { isDefined } from "./isDefined";
+/**
+ * Atualiza o estado de validade de elementos customizados associados a formulário.
+ *
+ * Regras aplicadas:
+ * - Se `required` e sem valor: marca como inválido (`valueMissing`)
+ * - Caso contrário: marca como válido
+ *
+ * @param options Opções de validação do campo.
+ */
+export const updateFormValidity = ({ internals, required, value, inputElem, validationMessage, defaultMessage = 'Please fill out this field', }) => {
+    if (!internals)
+        return;
+    if (required && !isDefined(value)) {
+        internals.setValidity({ valueMissing: true }, validationMessage ?? defaultMessage, inputElem);
+        return;
+    }
+    internals.setValidity({});
+};
+export const safeSetFormValue = (internals, value, state) => {
+    try {
+        internals?.setFormValue(value, state);
+    }
+    catch {
+        // Alguns ambientes não implementam completamente ElementInternals.
+    }
+};
+export 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. */
+export 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. */
+export 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');
+};
+export const isFormControlDisabled = (disabled, formDisabled) => {
+    return disabled || formDisabled;
+};
+export const getCheckableFormValue = (checked, value, fallback = 'on') => {
+    return checked ? value || fallback : null;
+};
+export const getCheckableRestoreState = (checked) => {
+    return checked ? 'checked' : 'unchecked';
+};

package/dist/collection/shared/utils/format-bytes.js

@@ -0,0 +1,20 @@
+/*!
+ * Construído por SERPRO
+ * © https://serpro.gov.br/ - MIT License.
+ */
+/**
+ * Formata um valor numérico em bytes para uma representação legível para humanos (ex.: KB, MB, GB).
+ *
+ * @param bytes Quantidade em bytes a ser formatada.
+ * @param decimals Número de casas decimais (padrão: 2).
+ * @returns String formatada com o valor e a unidade correspondente.
+ */
+export function formatBytes(bytes, decimals = 2) {
+    if (bytes === 0)
+        return '0 Bytes';
+    const k = 1024;
+    const dm = decimals < 0 ? 0 : decimals;
+    const units = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${Number.parseFloat((bytes / k ** i).toFixed(dm))} ${units[i]}`;
+}

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

@@ -0,0 +1,30 @@
+/*!
+ * Construído por SERPRO
+ * © https://serpro.gov.br/ - MIT License.
+ */
+export const getNextElementIndex = (elements, startAt = 0, direction = 'forward', isEnabled = () => true) => {
+    if (elements.length === 0)
+        return -1;
+    let elementIndex = startAt;
+    for (let checked = 0; checked < elements.length - 1; checked++) {
+        elementIndex = getNextIndex(elementIndex, elements.length, direction);
+        if (isEnabled(elements[elementIndex]))
+            return elementIndex;
+    }
+    return isEnabled(elements[startAt]) ? startAt : -1;
+};
+export const getNextElement = (elements, startAt = 0, direction = 'forward') => {
+    const index = getNextElementIndex(elements, startAt, direction, (element) => !element.disabled);
+    return index >= 0 ? elements[index] : elements[startAt];
+};
+export const getNextEnabledElement = (elements, current, direction = 'forward', isEnabled = () => true) => {
+    const startAt = elements.indexOf(current);
+    if (startAt === -1)
+        return undefined;
+    const index = getNextElementIndex(elements, startAt, direction, isEnabled);
+    return index >= 0 ? elements[index] : undefined;
+};
+const getNextIndex = (currentIndex, length, direction) => {
+    const nextIndex = currentIndex + (direction === 'forward' ? 1 : -1);
+    return (length + nextIndex) % length;
+};

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

@@ -0,0 +1,27 @@
+/*!
+ * Construído por SERPRO
+ * © https://serpro.gov.br/ - MIT License.
+ */
+/**
+ * Utilitário para sorteio de itens aleatórios de um array.
+ *
+ * Retorna `n` itens aleatórios de um array.
+ *
+ * @param arr Array fonte.
+ * @param n Quantidade de itens aleatórios desejada.
+ * @returns Novo array com os itens sorteados.
+ * @throws {RangeError} Quando `n` é maior que o tamanho do array.
+ */
+export const getRandomFromArray = (arr, n) => {
+    let length = arr.length;
+    const result = new Array(n);
+    const taken = new Array(length);
+    if (n > length)
+        throw new RangeError('getRandom: more elements taken than available');
+    while (n--) {
+        const x = Date.now() % length;
+        result[n] = arr[x in taken ? taken[x] : x];
+        taken[x] = --length in taken ? taken[length] : length;
+    }
+    return result;
+};

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

@@ -0,0 +1,31 @@
+/*!
+ * Construído por SERPRO
+ * © https://serpro.gov.br/ - MIT License.
+ */
+/**
+ * Utilitários Helpers com funções auxiliares para geração de IDs e formatação de bytes.
+ * Mantemos um `default` export com a API compatível para não quebrar importações existentes.
+ */
+export function generateUniqueId(prefix) {
+    const time = Date.now().toString(36);
+    const rand = Math.random().toString(36).substring(2, 10);
+    const id = (time + rand).substring(0, 16);
+    return prefix ? `${prefix}-${id}` : id;
+}
+/**
+ * Formata um valor em bytes para uma representação humana (KB, MB, GB...).
+ * @param bytes Quantidade em bytes.
+ * @param decimals Número de casas decimais (padrão: 2).
+ * @returns Valor formatado com unidade.
+ */
+export function formatBytes(bytes, decimals = 2) {
+    if (bytes === 0)
+        return '0 Bytes';
+    const k = 1024;
+    const dm = decimals < 0 ? 0 : decimals;
+    const units = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${Number.parseFloat((bytes / k ** i).toFixed(dm))} ${units[i]}`;
+}
+const Helpers = { generateUniqueId, formatBytes };
+export default Helpers;

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

@@ -0,0 +1,16 @@
+/*!
+ * Construído por SERPRO
+ * © https://serpro.gov.br/ - MIT License.
+ */
+/**
+ * Utilitário para geração de IDs únicos para Web Components.
+ *
+ * Utiliza um contador sequencial em memória combinado com um sufixo aleatório em base36
+ * para oferecer alta performance O(1) e garantia de unicidade sem colisões.
+ *
+ * @returns String de ID único compatível com seletores CSS (ex.: "b0k9f2z").
+ */
+let idCounter = 0;
+export function generateUniqueId() {
+    return `b${(idCounter++).toString(36)}${Math.random().toString(36).slice(2, 7)}`;
+}

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

@@ -0,0 +1,60 @@
+/*!
+ * Construído por SERPRO
+ * © https://serpro.gov.br/ - MIT License.
+ */
+/**
+ * Barrel de utilitários compartilhados do pacote de webcomponents.
+ *
+ * Reexporta funções, tipos e helpers para uso em componentes e testes.
+ *
+ * Módulos exportados:
+ * - `breakpoint-observer` — Detecção de breakpoints responsivos via MediaQuery
+ * - `clamp`             — Restrição de valores numéricos a um intervalo
+ * - `date`              — Parsing, validação e formatação de datas
+ * - `debounce`          — Atraso de execução de funções (debounce)
+ * - `event`             — Verificação de relação entre alvo de evento e host
+ * - `floating-ui`       — Posicionamento flutuante (tooltips, popovers)
+ * - `floating-surface-dismiss` — Fechamento diante de bloqueadores externos
+ * - `focus`             — Captura e restauração de foco em superfícies
+ * - `form`              — Atualização de validade em formulários customizados
+ * - `getNextElement`    — Navegação circular entre elementos habilitados
+ * - `format-bytes`      — Formatação de valores numéricos em bytes
+ * - `id`                — Geração de IDs únicos para Web Components
+ * - `interfaces`        — Tipos e interfaces utilitários compartilhados
+ * - `isClient`          — Detecção de ambiente navegador
+ * - `isDefined`         — Verificação de valores definidos
+ * - `isNil`             — Verificação de valores nulos ou indefinidos
+ * - `parts`             — Exposição confiável de CSS parts em custom elements filhos
+ * - `props`             — Validação de propriedades de elementos customizados
+ * - `scrollLock`        — Bloqueio/desbloqueio de scroll do body
+ * - `setRafTimeout`     — Agendamento eficiente via RAF + setTimeout
+ * - `slot`              — Leitura de conteúdo de slots em web components
+ * - `swipe`             — Detecção de gestos de swipe
+ * - `transition`        — Transições de entrada e saída com classes CSS
+ */
+export * from './breakpoint-observer';
+export * from './clamp';
+export * from './date';
+export * from './debounce';
+export * from './event';
+export * from './floating-surface-dismiss';
+export * from './floating-ui';
+export * from './focus';
+export * from './form';
+export * from './format-bytes';
+export * from './getNextElement';
+export * from './id';
+export * from './interfaces';
+export * from './isClient';
+export * from './isDefined';
+export * from './isNil';
+export * from './native-dialog';
+export * from './parts';
+export * from './props';
+export * from './raf-batcher';
+export * from './scrollLock';
+export * from './setRafTimeout';
+export * from './slot';
+export * from './ssr-date';
+export * from './swipe';
+export * from './transition';

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,14 @@
+/*!
+ * Construído por SERPRO
+ * © https://serpro.gov.br/ - MIT License.
+ */
+/**
+ * Utilitário para detecção de ambiente de execução (browser/client).
+ *
+ * Verifica se o código está sendo executado no ambiente do navegador.
+ *
+ * @returns `true` quando `window` e `document` estão disponíveis.
+ */
+export const isClient = () => {
+    return typeof window !== 'undefined' && typeof document !== 'undefined';
+};

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

@@ -0,0 +1,19 @@
+/*!
+ * Construído por SERPRO
+ * © https://serpro.gov.br/ - MIT License.
+ */
+/**
+ * Utilitário para validação de valores definidos.
+ *
+ * Verifica se um valor deve ser considerado "definido" para uso em validações.
+ *
+ * Regras:
+ * - `string`: retorna `true` apenas quando possui conteúdo (`length > 0`)
+ * - demais tipos: utiliza coerção booleana (`Boolean(value)`)
+ *
+ * @param value Valor a ser avaliado.
+ * @returns `true` quando o valor é considerado definido.
+ */
+export const isDefined = (value) => {
+    return typeof value === 'string' ? value.length !== 0 : Boolean(value);
+};

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

@@ -0,0 +1,30 @@
+/*!
+ * Construído por SERPRO
+ * © https://serpro.gov.br/ - MIT License.
+ */
+/**
+ * Utilitário para verificar se coleções estão vazias.
+ *
+ * Suporta Map, Set, Array, Record, null e undefined.
+ */
+import { isDefined } from "./isDefined";
+import { isNil } from "./isNil";
+/**
+ * Verifica se uma coleção está vazia.
+ *
+ * Tipos suportados: `Map`, `Set`, `Array`, `Record`, `null` e `undefined`.
+ *
+ * @param value Coleção a ser avaliada.
+ * @returns `true` quando a coleção não possui conteúdo.
+ */
+export const isEmpty = (value) => {
+    if (isNil(value)) {
+        return true;
+    }
+    else if ('size' in value) {
+        return !isDefined(value.size);
+    }
+    else {
+        return !isDefined(Object.values(value).length);
+    }
+};

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

@@ -0,0 +1,16 @@
+/*!
+ * Construído por SERPRO
+ * © https://serpro.gov.br/ - MIT License.
+ */
+/**
+ * Utilitário para validação de elementos HTML por tag.
+ *
+ * Verifica se o alvo é um elemento HTML de uma tag específica.
+ *
+ * @param target Valor a ser validado.
+ * @param tag Nome da tag esperada.
+ * @returns `true` quando o alvo é um elemento da tag informada.
+ */
+export const isHTMLElement = (target, tag) => {
+    return target instanceof Node && target.nodeName.toLowerCase() === tag.toLowerCase();
+};