@1doc/1ds-react 2.7.2 → 2.9.0

package/dist/teste/Stack.test.js

@@ -0,0 +1,57 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { describe, expect, it, vi } from "vitest";
+import { fireEvent, render, screen } from "@testing-library/react";
+import Stack from "../components/Stack/Stack";
+const TAGS = ["div", "span", "ul", "ol", "li", "section", "nav", "header", "footer", "form"];
+describe("Stack", () => {
+    it("sem props continua um div vertical com gap xxxs", () => {
+        const { container } = render(_jsx(Stack, { children: "x" }));
+        const el = container.firstElementChild;
+        expect(el.tagName).toBe("DIV");
+        expect(el.className).toBe("umds-stack umds-stack--vertical umds-stack--gap-xxxs");
+    });
+    it("aceita gap none", () => {
+        const { container } = render(_jsx(Stack, { gap: "none", children: "x" }));
+        expect(container.firstElementChild).toHaveClass("umds-stack--gap-none");
+    });
+    it.each(TAGS)("as=%s renderiza o elemento certo", (tag) => {
+        const { container } = render(_jsx(Stack, { as: tag, children: "x" }));
+        expect(container.firstElementChild?.tagName.toLowerCase()).toBe(tag);
+    });
+    it("ul e ol mantêm a semântica de lista", () => {
+        const { container } = render(_jsx(Stack, { as: "ul", "aria-label": "Itens", children: _jsx(Stack, { as: "li", children: "um" }) }));
+        expect(screen.getByRole("list", { name: "Itens" })).toBeInTheDocument();
+        expect(container.querySelectorAll("li")).toHaveLength(1);
+    });
+    it("repassa id, aria-label, title e style ao elemento raiz", () => {
+        const { container } = render(_jsx(Stack, { as: "nav", id: "menu", "aria-label": "Principal", title: "Dica", style: { marginTop: 4 }, children: "x" }));
+        const el = container.firstElementChild;
+        expect(el.id).toBe("menu");
+        expect(el.getAttribute("aria-label")).toBe("Principal");
+        expect(el.getAttribute("title")).toBe("Dica");
+        expect(el.style.marginTop).toBe("4px");
+        expect(screen.getByRole("navigation", { name: "Principal" })).toBe(el);
+    });
+    it("as=form chama onSubmit", () => {
+        const aoEnviar = vi.fn((e) => e.preventDefault());
+        const { container } = render(_jsx(Stack, { as: "form", onSubmit: aoEnviar, children: _jsx("button", { type: "submit", children: "Enviar" }) }));
+        fireEvent.submit(container.querySelector("form"));
+        expect(aoEnviar).toHaveBeenCalledTimes(1);
+    });
+    it("escreve as classes de item flex", () => {
+        const { container } = render(_jsx(Stack, { grow: true, shrink: "0", basis: "50", minWidth: "auto", overflow: "hidden", overflowY: "auto", fullHeight: true, children: "x" }));
+        const el = container.firstElementChild;
+        for (const c of [
+            "umds-stack--grow",
+            "umds-stack--shrink-0",
+            "umds-stack--basis-50",
+            "umds-stack--min-w-auto",
+            "umds-stack--overflow-hidden",
+            "umds-stack--overflow-y-auto",
+            "umds-stack--full-height",
+        ]) {
+            expect(el).toHaveClass(c);
+        }
+        expect(el).not.toHaveClass("umds-stack--full-width");
+    });
+});

package/dist/teste/StatCardRotuloTopo.test.d.ts

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

package/dist/teste/StatCardRotuloTopo.test.js

@@ -0,0 +1,34 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { describe, expect, it } from "vitest";
+import { render, screen } from "@testing-library/react";
+import StatCard from "../components/StatCard/StatCard";
+const raiz = (c) => c.firstElementChild;
+describe("StatCard · labelPosition", () => {
+    it("top escreve a classe; sem a prop o cartão é o de antes", () => {
+        const { container } = render(_jsxs(_Fragment, { children: [_jsx(StatCard, { value: 44, label: "N\u00E3o lidos", labelPosition: "top" }), _jsx(StatCard, { value: 44, label: "N\u00E3o lidos" })] }));
+        expect(container.children[0]).toHaveClass("umds-stat-card--rotulo-topo");
+        expect(container.children[1]).not.toHaveClass("umds-stat-card--rotulo-topo");
+    });
+    it("o número continua antes do rótulo no HTML (ordem do leitor de tela)", () => {
+        const { container } = render(_jsx(StatCard, { value: 44, label: "N\u00E3o lidos", labelPosition: "top" }));
+        const valor = container.querySelector(".umds-stat-card__valor");
+        const rotulo = container.querySelector(".umds-stat-card__rotulo");
+        expect(valor.compareDocumentPosition(rotulo) & Node.DOCUMENT_POSITION_FOLLOWING).toBeTruthy();
+    });
+});
+describe("StatCard · infoTooltip", () => {
+    it("mostra o ⓘ como botão nomeado, dentro do rótulo, descrito pelo texto de ajuda", () => {
+        const { container } = render(_jsx(StatCard, { value: 44, label: "N\u00E3o lidos", infoTooltip: "Ainda n\u00E3o abertos por voc\u00EA." }));
+        const info = screen.getByRole("button", { name: "Mais informações" });
+        expect(container.querySelector(".umds-stat-card__rotulo")?.contains(info)).toBe(true);
+        expect(info).toHaveAccessibleDescription("Ainda não abertos por você.");
+    });
+    it("infoLabel traduz o nome do ⓘ", () => {
+        render(_jsx(StatCard, { value: 1, label: "Unread", infoTooltip: "Not opened yet.", infoLabel: "More info" }));
+        expect(screen.getByRole("button", { name: "More info" })).toBeInTheDocument();
+    });
+    it("sem infoTooltip não há botão", () => {
+        render(_jsx(StatCard, { value: 1, label: "x" }));
+        expect(screen.queryByRole("button")).toBeNull();
+    });
+});

package/dist/teste/TabsContadorFechavel.test.d.ts

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

package/dist/teste/TabsContadorFechavel.test.js

@@ -0,0 +1,79 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { describe, expect, it, vi } from "vitest";
+import { fireEvent, render, screen } from "@testing-library/react";
+import Tabs from "../components/Tabs/Tabs";
+import Tab from "../components/Tabs/Tab";
+describe("Tab · count", () => {
+    it("mostra o contador em pílula e ele entra no nome da aba", () => {
+        render(_jsxs(Tabs, { value: "0", ariaLabel: "Tarefas", children: [_jsx(Tab, { label: "Todas", index: "0", count: 31 }), _jsx(Tab, { label: "Atribu\u00EDdas", index: "1", count: 9 })] }));
+        expect(screen.getByRole("tab", { name: "Todas 31" })).toBeInTheDocument();
+        expect(screen.getByRole("tab", { name: "Atribuídas 9" })).toBeInTheDocument();
+    });
+    it("o 0 aparece; sem count, não há pílula", () => {
+        const { container } = render(_jsxs(Tabs, { value: "0", children: [_jsx(Tab, { label: "Conclu\u00EDdas", index: "0", count: 0 }), _jsx(Tab, { label: "Sem contador", index: "1" })] }));
+        const pilulas = container.querySelectorAll(".umds-tabs__count");
+        expect(pilulas).toHaveLength(1);
+        expect(pilulas[0].textContent).toBe("0");
+    });
+    it("a pílula fica dentro da aba selecionada (que a pinta de azul pelo CSS)", () => {
+        const { container } = render(_jsxs(Tabs, { value: "1", children: [_jsx(Tab, { label: "A", index: "0", count: 1 }), _jsx(Tab, { label: "B", index: "1", count: 2 })] }));
+        const selecionada = container.querySelector(".umds-tabs__tab--selected");
+        expect(selecionada?.querySelector(".umds-tabs__count")?.textContent).toBe("2");
+    });
+});
+describe("Tab · closable", () => {
+    it("o × é um botão irmão da aba, com o nome 'Fechar <aba>'", () => {
+        render(_jsx(Tabs, { value: "0", children: _jsx(Tab, { label: "Documento 1", index: "0", closable: true }) }));
+        const fechar = screen.getByRole("button", { name: "Fechar Documento 1" });
+        const aba = screen.getByRole("tab");
+        expect(aba.contains(fechar)).toBe(false);
+        expect(fechar.parentElement).toBe(aba.parentElement);
+    });
+    it("o rótulo do × vem por prop", () => {
+        render(_jsx(Tabs, { value: "0", children: _jsx(Tab, { label: "Doc 1", index: "0", closable: true, closeLabel: "Close" }) }));
+        expect(screen.getByRole("button", { name: "Close Doc 1" })).toBeInTheDocument();
+    });
+    it("clicar no × chama onClose com o index e não troca de aba", () => {
+        const aoFechar = vi.fn();
+        const aoTrocar = vi.fn();
+        render(_jsxs(Tabs, { value: "0", onChange: aoTrocar, children: [_jsx(Tab, { label: "Um", index: "0" }), _jsx(Tab, { label: "Dois", index: "1", closable: true, onClose: aoFechar })] }));
+        fireEvent.click(screen.getByRole("button", { name: "Fechar Dois" }));
+        expect(aoFechar).toHaveBeenCalledTimes(1);
+        expect(aoFechar.mock.calls[0][0]).toBe("1");
+        expect(aoTrocar).not.toHaveBeenCalled();
+    });
+    it("Delete na aba focada fecha; sem closable, não", () => {
+        const aoFechar = vi.fn();
+        render(_jsxs(Tabs, { value: "0", children: [_jsx(Tab, { label: "Fech\u00E1vel", index: "0", closable: true, onClose: aoFechar }), _jsx(Tab, { label: "Fixa", index: "1", onClose: aoFechar })] }));
+        fireEvent.keyDown(screen.getByRole("tab", { name: "Fechável" }), { key: "Delete" });
+        expect(aoFechar).toHaveBeenCalledTimes(1);
+        fireEvent.keyDown(screen.getByRole("tab", { name: "Fixa" }), { key: "Delete" });
+        expect(aoFechar).toHaveBeenCalledTimes(1);
+    });
+    it("sem closable não há ×", () => {
+        render(_jsx(Tabs, { value: "0", children: _jsx(Tab, { label: "Fixa", index: "0" }) }));
+        expect(screen.queryByRole("button")).toBeNull();
+    });
+    it("o tablist só tem abas como filhas de papel (o × não é tab)", () => {
+        render(_jsxs(Tabs, { value: "0", children: [_jsx(Tab, { label: "A", index: "0", closable: true }), _jsx(Tab, { label: "B", index: "1", closable: true })] }));
+        expect(screen.getAllByRole("tab")).toHaveLength(2);
+    });
+});
+describe("Tabs · onAdd", () => {
+    it("mostra o + fora do tablist e chama onAdd", () => {
+        const aoAdicionar = vi.fn();
+        render(_jsx(Tabs, { value: "0", onAdd: aoAdicionar, children: _jsx(Tab, { label: "A", index: "0" }) }));
+        const mais = screen.getByRole("button", { name: "Adicionar aba" });
+        expect(screen.getByRole("tablist").contains(mais)).toBe(false);
+        fireEvent.click(mais);
+        expect(aoAdicionar).toHaveBeenCalledTimes(1);
+    });
+    it("o rótulo do + vem por prop", () => {
+        render(_jsx(Tabs, { value: "0", onAdd: () => { }, addLabel: "New tab", children: _jsx(Tab, { label: "A", index: "0" }) }));
+        expect(screen.getByRole("button", { name: "New tab" })).toBeInTheDocument();
+    });
+    it("sem onAdd não há botão", () => {
+        render(_jsx(Tabs, { value: "0", children: _jsx(Tab, { label: "A", index: "0" }) }));
+        expect(screen.queryByRole("button")).toBeNull();
+    });
+});

package/dist/teste/Tooltip.test.d.ts

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

package/dist/teste/Tooltip.test.js

@@ -0,0 +1,109 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { describe, expect, it, vi } from "vitest";
+import { fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { renderToString } from "react-dom/server";
+import Tooltip from "../components/Tooltip/Tooltip";
+import Modal from "../components/Modal/Modal";
+import Drawer from "../components/Drawer/Drawer";
+/**
+ * O Tooltip embrulha o gatilho num <span> que não recebe foco. O
+ * `aria-describedby` morava nesse span — e o leitor de tela lê a descrição
+ * de quem tem o FOCO, o botão. O texto nunca era anunciado. Estes testes
+ * guardam que a descrição chega ao elemento focável, que o foco abre a
+ * bolha e que o Esc a fecha.
+ */
+describe("Tooltip · descrição no elemento focável", () => {
+    it("o botão dentro do Tooltip é descrito pelo texto", () => {
+        render(_jsx(Tooltip, { content: "Salva o documento atual", children: _jsx("button", { type: "button", children: "Salvar" }) }));
+        expect(screen.getByRole("button", { name: "Salvar" })).toHaveAccessibleDescription("Salva o documento atual");
+    });
+    it("título e conteúdo entram os dois na descrição", () => {
+        render(_jsx(Tooltip, { title: "Atalho", content: "Ctrl+S", children: _jsx("button", { type: "button", children: "Salvar" }) }));
+        expect(screen.getByRole("button")).toHaveAccessibleDescription("Atalho Ctrl+S");
+    });
+    it("soma ao aria-describedby que o filho já tinha", () => {
+        render(_jsxs(_Fragment, { children: [_jsx("span", { id: "dica-externa", children: "Obrigat\u00F3rio" }), _jsx(Tooltip, { content: "Formato DD/MM/AAAA", children: _jsx("input", { "aria-label": "Data", "aria-describedby": "dica-externa" }) })] }));
+        expect(screen.getByRole("textbox")).toHaveAccessibleDescription("Obrigatório Formato DD/MM/AAAA");
+    });
+    it("disabled não descreve", () => {
+        render(_jsx(Tooltip, { content: "Bloqueado", disabled: true, children: _jsx("button", { type: "button", children: "Publicar" }) }));
+        expect(screen.getByRole("button")).not.toHaveAttribute("aria-describedby");
+    });
+    it("ao ficar disabled, o filho volta ao aria-describedby original", () => {
+        const { rerender } = render(_jsx(Tooltip, { content: "Dica", children: _jsx("input", { "aria-label": "Nome", "aria-describedby": "erro" }) }));
+        const campo = screen.getByRole("textbox");
+        expect(campo.getAttribute("aria-describedby")).toMatch(/^erro umds-tooltip-/);
+        rerender(_jsx(Tooltip, { content: "Dica", disabled: true, children: _jsx("input", { "aria-label": "Nome", "aria-describedby": "erro" }) }));
+        expect(campo).toHaveAttribute("aria-describedby", "erro");
+    });
+});
+describe("Tooltip · foco e Esc", () => {
+    it("abre no foco do filho e fecha no Esc", async () => {
+        render(_jsx(Tooltip, { content: "Salva o documento atual", children: _jsx("button", { type: "button", children: "Salvar" }) }));
+        screen.getByRole("button").focus();
+        await waitFor(() => expect(screen.getByRole("tooltip")).toHaveClass("umds-tooltip__bubble--open"));
+        fireEvent.keyDown(document.activeElement, { key: "Escape" });
+        await waitFor(() => expect(screen.queryByRole("tooltip")).not.toBeInTheDocument());
+    });
+    it("fecha quando o foco sai do gatilho", async () => {
+        render(_jsxs(_Fragment, { children: [_jsx(Tooltip, { content: "Dica", children: _jsx("button", { type: "button", children: "Com dica" }) }), _jsx("button", { type: "button", children: "Outro" })] }));
+        screen.getByRole("button", { name: "Com dica" }).focus();
+        await waitFor(() => expect(screen.getByRole("tooltip")).toBeInTheDocument());
+        screen.getByRole("button", { name: "Outro" }).focus();
+        await waitFor(() => expect(screen.queryByRole("tooltip")).not.toBeInTheDocument());
+    });
+});
+describe("Tooltip · Esc dentro de overlay", () => {
+    /**
+     * Modal, Drawer e BottomSheet fecham no Esc escutando o document. Com um
+     * tooltip aberto dentro deles, o primeiro Esc tem de fechar SÓ o tooltip:
+     * quem aperta Esc para dispensar a dica não espera perder o formulário
+     * inteiro. O segundo Esc, já sem tooltip, volta a ser do overlay.
+     */
+    const abrirDica = async (nome) => {
+        screen.getByRole("button", { name: nome }).focus();
+        await waitFor(() => expect(screen.getByRole("tooltip")).toHaveClass("umds-tooltip__bubble--open"));
+    };
+    it("com o tooltip aberto, o Esc fecha a dica e não fecha o Modal", async () => {
+        const aoFechar = vi.fn();
+        render(_jsx(Modal, { open: true, title: "Editar processo", onClose: aoFechar, children: _jsx(Tooltip, { content: "Salva sem enviar", children: _jsx("button", { type: "button", children: "Salvar rascunho" }) }) }));
+        await abrirDica("Salvar rascunho");
+        fireEvent.keyDown(document.activeElement, { key: "Escape" });
+        await waitFor(() => expect(screen.queryByRole("tooltip")).not.toBeInTheDocument());
+        expect(aoFechar).not.toHaveBeenCalled();
+    });
+    it("com o tooltip fechado, o Esc segue para o Modal", async () => {
+        const aoFechar = vi.fn();
+        render(_jsx(Modal, { open: true, title: "Editar processo", onClose: aoFechar, children: _jsx(Tooltip, { content: "Salva sem enviar", children: _jsx("button", { type: "button", children: "Salvar rascunho" }) }) }));
+        await abrirDica("Salvar rascunho");
+        // Primeiro Esc: só a dica.
+        fireEvent.keyDown(document.activeElement, { key: "Escape" });
+        await waitFor(() => expect(screen.queryByRole("tooltip")).not.toBeInTheDocument());
+        expect(aoFechar).not.toHaveBeenCalled();
+        // Segundo Esc, sem tooltip: agora é do Modal.
+        fireEvent.keyDown(document.activeElement, { key: "Escape" });
+        expect(aoFechar).toHaveBeenCalledTimes(1);
+    });
+    it("com o tooltip aberto, o Esc não fecha o Drawer", async () => {
+        const aoFechar = vi.fn();
+        render(_jsx(Drawer, { open: true, title: "Detalhes", onClose: aoFechar, children: _jsx(Tooltip, { content: "Copia o n\u00FAmero do processo", children: _jsx("button", { type: "button", children: "Copiar" }) }) }));
+        await abrirDica("Copiar");
+        fireEvent.keyDown(document.activeElement, { key: "Escape" });
+        await waitFor(() => expect(screen.queryByRole("tooltip")).not.toBeInTheDocument());
+        expect(aoFechar).not.toHaveBeenCalled();
+        fireEvent.keyDown(document.activeElement, { key: "Escape" });
+        expect(aoFechar).toHaveBeenCalledTimes(1);
+    });
+    it("tooltip que nunca abriu não engole o Esc", () => {
+        const aoFechar = vi.fn();
+        render(_jsx(Modal, { open: true, title: "Editar processo", onClose: aoFechar, children: _jsx(Tooltip, { content: "Salva sem enviar", children: _jsx("button", { type: "button", children: "Salvar rascunho" }) }) }));
+        fireEvent.keyDown(document.body, { key: "Escape" });
+        expect(aoFechar).toHaveBeenCalledTimes(1);
+    });
+});
+describe("Tooltip · servidor", () => {
+    it("o HTML do servidor é determinístico", () => {
+        const html = () => renderToString(_jsx(Tooltip, { content: "Dica", children: _jsx("button", { type: "button", children: "Salvar" }) }));
+        expect(html()).toBe(html());
+    });
+});

package/dist/teste/TooltipDark.test.d.ts

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

package/dist/teste/TooltipDark.test.js

@@ -0,0 +1,31 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { describe, expect, it } from "vitest";
+import { render, screen, waitFor } from "@testing-library/react";
+import Tooltip from "../components/Tooltip/Tooltip";
+async function abrir(ui) {
+    render(ui);
+    screen.getByRole("button").focus();
+    await waitFor(() => expect(screen.getByRole("tooltip")).toHaveClass("umds-tooltip__bubble--open"));
+    return screen.getByRole("tooltip");
+}
+describe("Tooltip · variant dark e maxWidth", () => {
+    it("dark escreve a classe no balão e no wrapper flutuante", async () => {
+        const balao = await abrir(_jsx(Tooltip, { content: "Atualizar", variant: "dark", children: _jsx("button", { type: "button", children: "Atualizar" }) }));
+        expect(balao).toHaveClass("umds-tooltip__bubble--dark");
+        expect(balao.parentElement).toHaveClass("umds-tooltip__floating--dark");
+    });
+    it("sem variant o balão é o padrão", async () => {
+        const balao = await abrir(_jsx(Tooltip, { content: "Atualizar", children: _jsx("button", { type: "button", children: "Atualizar" }) }));
+        expect(balao).not.toHaveClass("umds-tooltip__bubble--dark");
+        expect(balao.parentElement).not.toHaveClass("umds-tooltip__floating--dark");
+        expect(balao.parentElement?.style.maxWidth).toBe("");
+    });
+    it("maxWidth vai ao wrapper flutuante, em qualquer variante", async () => {
+        const balao = await abrir(_jsx(Tooltip, { content: "Texto longo", variant: "dark", maxWidth: "140px", children: _jsx("button", { type: "button", children: "x" }) }));
+        expect(balao.parentElement?.style.maxWidth).toBe("140px");
+    });
+    it("a descrição acessível não muda com a variante", () => {
+        render(_jsx(Tooltip, { content: "Atualizar", variant: "dark", children: _jsx("button", { type: "button", children: "Recarregar" }) }));
+        expect(screen.getByRole("button")).toHaveAccessibleDescription("Atualizar");
+    });
+});

package/dist/utils/calendario.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Datas do `Calendar`, em ISO local (`YYYY-MM-DD`) e sem biblioteca.
+ *
+ * Tudo aqui trabalha com o DIA como texto: `"2026-05-15"`. O `Date` só aparece
+ * por dentro, sempre à meia-noite LOCAL (`new Date(ano, mes, dia)`), nunca
+ * `new Date("2026-05-15")`, que o JavaScript lê como UTC e, no fuso do Brasil,
+ * devolve o dia anterior.
+ */
+/** `Date` local → `YYYY-MM-DD`. */
+export declare const toIso: (data: Date) => string;
+/** `YYYY-MM-DD` → `Date` à meia-noite local. */
+export declare const parseIso: (iso: string) => Date;
+/** Aceita `Date` ou texto (`2026-05-15` e `2026-05-15T10:00`) e devolve `YYYY-MM-DD`; "" se não der. */
+export declare const normalizeIso: (valor: any) => string;
+export declare const addDays: (iso: string, dias: number) => string;
+/** Soma meses mantendo o dia, ou o último dia do mês de chegada (31/01 + 1 mês = 28/02). */
+export declare const addMonths: (iso: string, meses: number) => string;
+/** Dia da semana: 0 = domingo. */
+export declare const weekdayOf: (iso: string) => number;
+/** Primeiro dia da semana que contém `iso`, dado o dia em que a semana começa (0 = domingo, 1 = segunda). */
+export declare const startOfWeek: (iso: string, comecaEm: number) => string;
+export declare const startOfMonth: (iso: string) => string;
+export declare const endOfMonth: (iso: string) => string;
+export declare const isSameMonth: (a: string, b: string) => boolean;
+/** Os sete dias da semana que contém `iso`. */
+export declare const weekDays: (iso: string, comecaEm: number) => string[];
+/** O mês de `iso` em semanas inteiras (de 4 a 6 linhas), com os dias dos meses vizinhos que completam as pontas. */
+export declare const monthMatrix: (iso: string, comecaEm: number) => string[][];

package/dist/utils/calendario.js

@@ -0,0 +1,73 @@
+/**
+ * Datas do `Calendar`, em ISO local (`YYYY-MM-DD`) e sem biblioteca.
+ *
+ * Tudo aqui trabalha com o DIA como texto: `"2026-05-15"`. O `Date` só aparece
+ * por dentro, sempre à meia-noite LOCAL (`new Date(ano, mes, dia)`), nunca
+ * `new Date("2026-05-15")`, que o JavaScript lê como UTC e, no fuso do Brasil,
+ * devolve o dia anterior.
+ */
+const doisDigitos = (n) => n < 10 ? "0" + n : String(n);
+/** `Date` local → `YYYY-MM-DD`. */
+export const toIso = (data) => data.getFullYear() + "-" + doisDigitos(data.getMonth() + 1) + "-" + doisDigitos(data.getDate());
+/** `YYYY-MM-DD` → `Date` à meia-noite local. */
+export const parseIso = (iso) => {
+    const partes = iso.slice(0, 10).split("-");
+    return new Date(Number(partes[0]), Number(partes[1]) - 1, Number(partes[2]));
+};
+/** Aceita `Date` ou texto (`2026-05-15` e `2026-05-15T10:00`) e devolve `YYYY-MM-DD`; "" se não der. */
+export const normalizeIso = (valor) => {
+    if (!valor)
+        return "";
+    if (typeof valor === "string")
+        return /^\d{4}-\d{2}-\d{2}/.test(valor) ? valor.slice(0, 10) : "";
+    if (valor instanceof Date && !isNaN(valor.getTime()))
+        return toIso(valor);
+    return "";
+};
+export const addDays = (iso, dias) => {
+    const data = parseIso(iso);
+    data.setDate(data.getDate() + dias);
+    return toIso(data);
+};
+/** Soma meses mantendo o dia, ou o último dia do mês de chegada (31/01 + 1 mês = 28/02). */
+export const addMonths = (iso, meses) => {
+    const data = parseIso(iso);
+    const dia = data.getDate();
+    data.setDate(1);
+    data.setMonth(data.getMonth() + meses);
+    const ultimo = new Date(data.getFullYear(), data.getMonth() + 1, 0).getDate();
+    data.setDate(Math.min(dia, ultimo));
+    return toIso(data);
+};
+/** Dia da semana: 0 = domingo. */
+export const weekdayOf = (iso) => parseIso(iso).getDay();
+/** Primeiro dia da semana que contém `iso`, dado o dia em que a semana começa (0 = domingo, 1 = segunda). */
+export const startOfWeek = (iso, comecaEm) => {
+    const recuo = (weekdayOf(iso) - comecaEm + 7) % 7;
+    return addDays(iso, -recuo);
+};
+export const startOfMonth = (iso) => iso.slice(0, 8) + "01";
+export const endOfMonth = (iso) => {
+    const data = parseIso(iso);
+    return toIso(new Date(data.getFullYear(), data.getMonth() + 1, 0));
+};
+export const isSameMonth = (a, b) => a.slice(0, 7) === b.slice(0, 7);
+/** Os sete dias da semana que contém `iso`. */
+export const weekDays = (iso, comecaEm) => {
+    const inicio = startOfWeek(iso, comecaEm);
+    const dias = [];
+    for (let i = 0; i < 7; i++)
+        dias.push(addDays(inicio, i));
+    return dias;
+};
+/** O mês de `iso` em semanas inteiras (de 4 a 6 linhas), com os dias dos meses vizinhos que completam as pontas. */
+export const monthMatrix = (iso, comecaEm) => {
+    const ultimo = endOfMonth(iso);
+    let cursor = startOfWeek(startOfMonth(iso), comecaEm);
+    const semanas = [];
+    while (cursor <= ultimo) {
+        semanas.push(weekDays(cursor, comecaEm));
+        cursor = addDays(cursor, 7);
+    }
+    return semanas;
+};

package/dist/utils/chart.d.ts

@@ -180,6 +180,10 @@ export interface ChartEntradaCartesiana extends ChartFormato {
     ariaLabel?: string;
     showLegend?: any;
     showGrid?: any;
+    /** Nome do tipo de gráfico (legenda da tabela sem título e começo do resumo automático). */
+    typeLabel?: string;
+    /** Nome da lista de alvos focáveis; o título, se houver, vem depois de " — ". */
+    valuesListLabel?: string;
 }
 export interface ChartGradeLinha {
     chave: string;

package/dist/utils/chart.js

@@ -392,7 +392,8 @@ export function modeloCartesiano(tipo, entrada, largura, altura) {
         serie: j + 1,
         nome: s.name
     }));
-    const nomeDoTipo = tipo === "barras" ? "Gráfico de barras" : "Gráfico de linhas";
+    const nomeDoTipo = entrada.typeLabel || (tipo === "barras" ? "Gráfico de barras" : "Gráfico de linhas");
+    const nomeDaLista = entrada.valuesListLabel || "Valores por categoria";
     const base = {
         vazio: true,
         viewBox: `0 0 ${largo} ${alto}`,
@@ -413,7 +414,7 @@ export function modeloCartesiano(tipo, entrada, largura, altura) {
         pontos: [],
         legenda,
         resumo: entrada.ariaLabel || `${nomeDoTipo} sem dados.`,
-        rotuloDaLista: entrada.title ? `Valores por categoria — ${entrada.title}` : "Valores por categoria",
+        rotuloDaLista: entrada.title ? `${nomeDaLista} — ${entrada.title}` : nomeDaLista,
         legendaDaTabela: entrada.title || nomeDoTipo,
         cabecalhos: legenda,
         tabela: []

package/dist/utils/html-seguro.d.ts

@@ -0,0 +1,27 @@
+/**
+ * HTML seguro para o `RichTextEditor`.
+ *
+ * O editor devolve HTML (`onChange`) e recebe HTML (`value`). HTML que vem de
+ * fora (um valor guardado, um texto colado) pode trazer `<img onerror>`,
+ * `<a href="javascript:...">`, `<script>`, `style` e classes de outro site. Este
+ * módulo reduz o HTML ao que o editor sabe escrever: negrito, itálico,
+ * sublinhado, tachado, listas, parágrafos, quebras, títulos, citação e link.
+ *
+ * Roda no navegador (precisa de DOM). Dentro de um `<template>` o HTML é inerte:
+ * nada executa e nenhuma imagem carrega enquanto se higieniza. Sem DOM
+ * (servidor), devolve o texto escapado.
+ */
+/**
+ * Endereço de link que o editor aceita: `http:`, `https:`, `mailto:`, `tel:`,
+ * caminho (`/x`, `./x`, `../x`) ou âncora (`#x`). Devolve o endereço limpo, ou ""
+ * se for perigoso (`javascript:`, `data:`, `vbscript:`...).
+ */
+export declare const enderecoSeguro: (bruto: string) => string;
+/** Devolve o endereço pronto para `href`: o seguro como veio, ou `https://` + o texto quando não tem esquema. "" se perigoso ou vazio. */
+export declare const normalizarEndereco: (bruto: string) => string;
+/** Reduz `html` ao que o editor escreve. Sem DOM, devolve o texto escapado. */
+export declare const sanitizarHtml: (html: string) => string;
+/** O editor está "vazio": sem texto, sem lista e sem quebra solta (o `<br>` que o navegador deixa). */
+export declare const htmlVazio: (html: string) => boolean;
+/** O `<a>` que o editor escreve quando o link não tem texto escolhido: o endereço (já seguro) é o href e o texto. */
+export declare const htmlDoLink: (endereco: string) => string;

package/dist/utils/html-seguro.js

@@ -0,0 +1,97 @@
+/**
+ * HTML seguro para o `RichTextEditor`.
+ *
+ * O editor devolve HTML (`onChange`) e recebe HTML (`value`). HTML que vem de
+ * fora (um valor guardado, um texto colado) pode trazer `<img onerror>`,
+ * `<a href="javascript:...">`, `<script>`, `style` e classes de outro site. Este
+ * módulo reduz o HTML ao que o editor sabe escrever: negrito, itálico,
+ * sublinhado, tachado, listas, parágrafos, quebras, títulos, citação e link.
+ *
+ * Roda no navegador (precisa de DOM). Dentro de um `<template>` o HTML é inerte:
+ * nada executa e nenhuma imagem carrega enquanto se higieniza. Sem DOM
+ * (servidor), devolve o texto escapado.
+ */
+const PERMITIDAS = ["A", "B", "STRONG", "I", "EM", "U", "S", "STRIKE", "DEL", "UL", "OL", "LI", "P", "BR", "DIV", "SPAN", "H1", "H2", "H3", "H4", "BLOCKQUOTE"];
+const DESCARTADAS = ["SCRIPT", "STYLE", "IFRAME", "OBJECT", "EMBED", "LINK", "META", "TEMPLATE", "NOSCRIPT", "SVG", "MATH", "FORM", "INPUT", "BUTTON", "TEXTAREA", "SELECT"];
+const escapar = (texto) => texto.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+/**
+ * Endereço de link que o editor aceita: `http:`, `https:`, `mailto:`, `tel:`,
+ * caminho (`/x`, `./x`, `../x`) ou âncora (`#x`). Devolve o endereço limpo, ou ""
+ * se for perigoso (`javascript:`, `data:`, `vbscript:`...).
+ */
+export const enderecoSeguro = (bruto) => {
+    const texto = (bruto || "").trim();
+    if (!texto)
+        return "";
+    // Caracteres de controle e espaços no meio do esquema são o truque clássico (`java\nscript:`).
+    const semControle = texto.replace(/[\u0000-\u001f\u007f\s]+/g, "");
+    if (/^(https?:\/\/|mailto:|tel:|\/|\.\.?\/|#)/i.test(semControle))
+        return texto;
+    if (/^[a-z][a-z0-9+.-]*:/i.test(semControle))
+        return "";
+    return "";
+};
+/** Devolve o endereço pronto para `href`: o seguro como veio, ou `https://` + o texto quando não tem esquema. "" se perigoso ou vazio. */
+export const normalizarEndereco = (bruto) => {
+    const texto = (bruto || "").trim();
+    if (!texto)
+        return "";
+    const seguro = enderecoSeguro(texto);
+    if (seguro)
+        return seguro;
+    const semControle = texto.replace(/[\u0000-\u001f\u007f\s]+/g, "");
+    if (/^[a-z][a-z0-9+.-]*:/i.test(semControle))
+        return "";
+    return "https://" + texto;
+};
+const limparNo = (no, saida, documento) => {
+    const filhos = Array.prototype.slice.call(no.childNodes);
+    for (let i = 0; i < filhos.length; i++) {
+        const filho = filhos[i];
+        if (filho.nodeType === 3) {
+            saida.appendChild(documento.createTextNode(filho.nodeValue));
+            continue;
+        }
+        if (filho.nodeType !== 1)
+            continue;
+        const tag = String(filho.tagName).toUpperCase();
+        if (DESCARTADAS.indexOf(tag) !== -1)
+            continue;
+        if (PERMITIDAS.indexOf(tag) === -1) {
+            // Tag desconhecida: some a tag, fica o conteúdo.
+            limparNo(filho, saida, documento);
+            continue;
+        }
+        const novo = documento.createElement(tag.toLowerCase());
+        if (tag === "A") {
+            const href = enderecoSeguro(filho.getAttribute("href") || "");
+            if (href) {
+                novo.setAttribute("href", href);
+                novo.setAttribute("rel", "noopener noreferrer");
+            }
+        }
+        limparNo(filho, novo, documento);
+        saida.appendChild(novo);
+    }
+};
+/** Reduz `html` ao que o editor escreve. Sem DOM, devolve o texto escapado. */
+export const sanitizarHtml = (html) => {
+    const bruto = html || "";
+    if (typeof document === "undefined")
+        return escapar(bruto);
+    const molde = document.createElement("template");
+    molde.innerHTML = bruto;
+    const saida = document.createElement("div");
+    limparNo(molde.content, saida, document);
+    return saida.innerHTML;
+};
+/** O editor está "vazio": sem texto, sem lista e sem quebra solta (o `<br>` que o navegador deixa). */
+export const htmlVazio = (html) => {
+    const texto = (html || "").replace(/<br\s*\/?>/gi, "").replace(/<\/?(div|p|span)[^>]*>/gi, "").trim();
+    return texto === "";
+};
+/** O `<a>` que o editor escreve quando o link não tem texto escolhido: o endereço (já seguro) é o href e o texto. */
+export const htmlDoLink = (endereco) => {
+    const seguro = escapar(endereco);
+    return '<a href="' + seguro + '">' + seguro + "</a>";
+};

package/dist/utils/id.d.ts

@@ -0,0 +1,2 @@
+/** Próximo id da página para o prefixo dado, ex.: `umds-select-3`. */
+export declare const gerarId: (prefixo: string) => string;

package/dist/utils/id.js

@@ -0,0 +1,23 @@
+/**
+ * Ids automáticos que não quebram a hidratação SSR.
+ *
+ * O padrão antigo da biblioteca sorteava o id na inicialização do store
+ * (`"umds-x-" + Math.random()`). No servidor sai um número, no cliente sai
+ * outro, e o React/Vue reclamam de hidratação divergente — e, pior, o
+ * `aria-describedby` que o servidor mandou aponta para um id que o cliente
+ * trocou.
+ *
+ * A regra agora: o componente começa SEM id automático (servidor e primeira
+ * renderização do cliente saem idênticos) e chama `gerarId` no `onMount`,
+ * que só roda no navegador. O contador é de módulo, mas como só avança no
+ * cliente não acumula entre requisições do servidor. Quem precisa do id já
+ * no HTML do servidor passa a prop `id`.
+ *
+ * Singleton por bundle, compartilhado entre os componentes gerados.
+ */
+let contador = 0;
+/** Próximo id da página para o prefixo dado, ex.: `umds-select-3`. */
+export const gerarId = (prefixo) => {
+    contador += 1;
+    return prefixo + "-" + contador;
+};