acai-ui 1.65.5

package/dist/hooks/use-contador-sessao.d.ts

@@ -0,0 +1,22 @@
+import { MaybeRefOrGetter } from 'vue';
+export interface OpcoesContadorSessao {
+    /** Minutos restantes a partir dos quais `emAlerta` fica true. Default 5. */
+    minutosAlerta?: number;
+    /** Chamado UMA vez quando o tempo zera. */
+    aoExpirar?: () => void;
+}
+/**
+ * Contagem regressiva de sessão a partir de um instante de expiração.
+ * Aceita epoch em MILISSEGUNDOS ou `Date` (de um JWT: `exp * 1000`).
+ * Reativo — reinicia sozinho quando `expiraEm` muda; limpa o intervalo no unmount.
+ *
+ * @example
+ * const { horasMinutos, emAlerta } = useContadorSessao(() => usuario.value?.exp ? usuario.value.exp * 1000 : null)
+ */
+export declare function useContadorSessao(expiraEm: MaybeRefOrGetter<number | Date | null | undefined>, opcoes?: OpcoesContadorSessao): {
+    restanteMs: import('vue').Ref<number | null, number | null>;
+    horasMinutos: import('vue').ComputedRef<string>;
+    horasMinutosSegundos: import('vue').ComputedRef<string>;
+    emAlerta: import('vue').ComputedRef<boolean>;
+};
+//# sourceMappingURL=use-contador-sessao.d.ts.map

package/dist/hooks/use-contador-sessao.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-contador-sessao.d.ts","sourceRoot":"","sources":["../../src/hooks/use-contador-sessao.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkD,KAAK,gBAAgB,EAAE,MAAM,KAAK,CAAA;AAE3F,MAAM,WAAW,oBAAoB;IACnC,4EAA4E;IAC5E,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,2CAA2C;IAC3C,SAAS,CAAC,EAAE,MAAM,IAAI,CAAA;CACvB;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,gBAAgB,CAAC,MAAM,GAAG,IAAI,GAAG,IAAI,GAAG,SAAS,CAAC,EAC5D,MAAM,GAAE,oBAAyB;;;;;EA2ElC"}

package/dist/hooks/use-filtros-na-url.d.ts

@@ -0,0 +1,110 @@
+import { Ref } from 'vue';
+import { TipoFiltroUrl } from './filtros-url-internos';
+export type { TipoFiltroUrl };
+export interface OpcoesFiltrosNaUrl {
+    /**
+     * Chaves que NUNCA aparecem na URL. É onde mora dado pessoal (CPF, RG, nome).
+     *
+     * Simétrico de propósito: a chave excluída também não é LIDA da URL. Se
+     * alguém colar `?cpf=...` à mão, o valor é ignorado — senão "não publicamos
+     * isso" viraria "não publicamos, mas aceitamos".
+     *
+     * Aceita a chave inteira (`'periodo'`) ou uma folha (`'periodo.from'`).
+     */
+    excluir?: readonly string[];
+    /**
+     * Tipo declarado por campo, quando o valor inicial não consegue dizer.
+     *
+     * 🔴 É o que faz o hook servir a formulário de verdade. O padrão dos apps
+     * DETRAN é derivar o modelo do request do swagger trocando `undefined` por
+     * `null` (os componentes exigem `string | number | null` e `v-model` não
+     * compila com `readonly`) — e aí `cargoId: null` não diz que é número, então
+     * a URL devolveria `'12'` em vez de `12`, calado, direto pro payload.
+     *
+     * ```ts
+     * useFiltrosNaUrl(formulario, {
+     *   tipos: { cargoId: 'number', regimeJuridicoId: 'number', progressoMinimo: 'number' },
+     * })
+     * ```
+     *
+     * Campo declarado aqui é governado mesmo que não exista no valor inicial —
+     * declarar é decisão explícita de quem escreveu a tela, diferente de aceitar
+     * chave desconhecida vinda da URL.
+     */
+    tipos?: Readonly<Record<string, TipoFiltroUrl>>;
+    /**
+     * Prefixo das chaves. Só é necessário quando DUAS listagens convivem na mesma
+     * rota e as duas têm um filtro de mesmo nome, que sem prefixo se sobrescrevem.
+     */
+    prefixo?: string;
+    /** Ler a URL na entrada. Default `true`. */
+    hidratar?: boolean;
+}
+export interface FiltrosNaUrl {
+    /**
+     * Grava o estado atual dos filtros na URL. Chame no `buscar()`, não a cada
+     * tecla — senão a URL fica pulando enquanto a pessoa digita.
+     *
+     * Em tela onde o submit só reposiciona a página e deixa um `watch` buscar,
+     * chame na função que de fato dispara a requisição, não no `@submit`.
+     */
+    sincronizar: () => void;
+    /** Remove os filtros da URL. Chame no `resetar()`. */
+    limpar: () => void;
+    /**
+     * `true` quando a URL trouxe algum filtro na entrada.
+     *
+     * Em tela que NÃO busca no mount, é o gatilho de restaurar o resultado —
+     * senão o formulário volta preenchido com a tabela vazia:
+     * `if (hidratou) void pesquisar()`.
+     */
+    hidratou: boolean;
+}
+/**
+ * Mantém os filtros de pesquisa na query string.
+ *
+ * Chame no `setup`, ANTES do primeiro `buscar()`: a hidratação é síncrona, então
+ * o `onMounted(buscar)` que a tela já tem sai com os filtros da URL e não há
+ * segunda requisição.
+ *
+ * ```ts
+ * const filtros = ref(filtrosVistoriaVazios())
+ * // `excluir`: CPF na URL vai pro log de acesso do servidor.
+ * // `tipos`: campo que nasce `null` não diz que é número.
+ * const { sincronizar, limpar } = useFiltrosNaUrl(filtros, {
+ *   excluir: ['cpf'],
+ *   tipos: { cargoId: 'number' },
+ * })
+ *
+ * async function buscar(): Promise<void> {
+ *   sincronizar()
+ *   await executar(limparCamposVazios(filtros.value))
+ * }
+ *
+ * function resetar(): void {
+ *   filtros.value = limparModelo(filtros.value)
+ *   limpar()
+ * }
+ *
+ * onMounted(buscar)
+ * ```
+ *
+ * **Tipos suportados:** string, number, boolean, Date, array de primitivo (chave
+ * repetida: `?sort=nome,asc&sort=idade,desc`) e **objeto de um nível** de
+ * primitivos, que vira caminho com ponto — `{ periodo: { from, to } }` sai como
+ * `?periodo.from=…&periodo.to=…`. É o formato do `<acai-ui-date-range>`, então
+ * filtro de período funciona sem o consumidor achatar nada. Dois níveis não.
+ *
+ * **O tipo sai do valor inicial** do objeto (o "molde"), e `tipos` tem
+ * precedência sobre ele.
+ *
+ * **Chave que não está no molde nem em `tipos` é ignorada** — sem isso a URL
+ * viraria vetor de injeção (`?size=99999` descendo direto pro `executar()`).
+ *
+ * ⚠️ A hidratação acontece UMA vez, no `setup`. Voltar/avançar no navegador não
+ * repõe o formulário, e a gravação usa `replace` (pesquisa não vira histórico).
+ * Quem quer a URL como fonte da verdade — com voltar funcionando e cache — usa
+ * `useListagemNaUrl`.
+ */
+export declare function useFiltrosNaUrl<T extends object>(filtros: Ref<T>, opcoes?: OpcoesFiltrosNaUrl): FiltrosNaUrl;
+//# sourceMappingURL=use-filtros-na-url.d.ts.map

package/dist/hooks/use-filtros-na-url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-filtros-na-url.d.ts","sourceRoot":"","sources":["../../src/hooks/use-filtros-na-url.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,KAAK,GAAG,EAAE,MAAM,KAAK,CAAA;AAC9B,OAAO,EAML,KAAK,aAAa,EACnB,MAAM,wBAAwB,CAAA;AAE/B,YAAY,EAAE,aAAa,EAAE,CAAA;AAE7B,MAAM,WAAW,kBAAkB;IACjC;;;;;;;;OAQG;IACH,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IAC3B;;;;;;;;;;;;;;;;;;OAkBG;IACH,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,CAAA;IAC/C;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,4CAA4C;IAC5C,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB;AAED,MAAM,WAAW,YAAY;IAC3B;;;;;;OAMG;IACH,WAAW,EAAE,MAAM,IAAI,CAAA;IACvB,sDAAsD;IACtD,MAAM,EAAE,MAAM,IAAI,CAAA;IAClB;;;;;;OAMG;IACH,QAAQ,EAAE,OAAO,CAAA;CAClB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,MAAM,EAC9C,OAAO,EAAE,GAAG,CAAC,CAAC,CAAC,EACf,MAAM,GAAE,kBAAuB,GAC9B,YAAY,CAkCd"}

package/dist/hooks/use-leitura-voz.d.ts

@@ -0,0 +1,60 @@
+import { Ref } from 'vue';
+/**
+ * Leitura em voz alta pela Web Speech API do próprio navegador.
+ *
+ * Sem dependência nova e sem rede: a síntese é do sistema operacional, o que
+ * importa numa máquina de balcão do DETRAN que pode não ter saída pra internet.
+ *
+ * NUNCA fala sozinho — quem dispara é sempre um clique do usuário (WCAG 1.4.2:
+ * áudio automático precisa de controle; não ter autoplay resolve na raiz).
+ */
+/** Identidade do trecho lido — é o que faz cada botão saber se é ELE que fala. */
+export type IdLeitura = string;
+export interface OpcoesFala {
+    /** Identidade do trecho. Sem id, o botão não consegue mostrar "estou lendo". */
+    id?: IdLeitura | undefined;
+    /** Idioma BCP-47 da fala (ex.: `pt-BR`). @default 'pt-BR' */
+    lang?: string | undefined;
+    /** Velocidade da fala, 0.1 a 10. @default 1 */
+    rate?: number | undefined;
+    /**
+     * Nome da voz (`SpeechSynthesisVoice.name`), como veio de `vozes`.
+     *
+     * É por NOME e não pelo objeto porque é isso que dá pra persistir. Voz que não
+     * existe mais na máquina (perfil novo, Windows sem o pacote) cai na escolha
+     * automática em vez de emudecer.
+     */
+    voz?: string | undefined;
+}
+/**
+ * Quebra o texto em pedaços que cabem numa fala curta.
+ *
+ * O Chrome interrompe uma fala longa por volta de 15 segundos. A saída é
+ * enfileirar vários pedaços curtos de uma vez (o motor toca em sequência) em vez
+ * de uma fala só. Corta em fim de frase; se não houver, no último espaço; só
+ * parte palavra quando a "palavra" sozinha já estoura o limite (URL, token).
+ */
+export declare function fatiarTexto(texto: string, max?: number): string[];
+export declare function useLeituraVoz(): {
+    suportado: Readonly<Ref<boolean>>;
+    lendo: Readonly<Ref<boolean>>;
+    idLendo: Readonly<Ref<IdLeitura | null>>;
+    /** Vozes instaladas na máquina. Popula sozinha no `voiceschanged`. */
+    vozes: Readonly<Ref<SpeechSynthesisVoice[]>>;
+    /** Vozes que servem para um idioma (prefixo BCP-47: `pt` casa `pt-BR` e `pt-PT`). */
+    vozesPara: (lang: string) => SpeechSynthesisVoice[];
+    /**
+     * Se dá pra ler NESTE idioma nesta máquina.
+     *
+     * Otimista de propósito: com a lista ainda vazia (o `voiceschanged` costuma
+     * chegar depois) devolve `true`. Esconder o botão por uma lista que ainda não
+     * carregou seria pior que tentar e falhar — e a falha real desliga o suporte.
+     */
+    temVozPara: (lang: string) => boolean;
+    falar: (texto: string, opcoes?: OpcoesFala) => void;
+    alternar: (texto: string, opcoes?: OpcoesFala) => void;
+    parar: () => void;
+};
+/** Só para testes — descarta o singleton (espelha `resetarTourVistoParaTeste`). */
+export declare function resetarLeituraVozParaTeste(): void;
+//# sourceMappingURL=use-leitura-voz.d.ts.map

package/dist/hooks/use-leitura-voz.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-leitura-voz.d.ts","sourceRoot":"","sources":["../../src/hooks/use-leitura-voz.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,GAAG,EAAE,MAAM,KAAK,CAAA;AAE7C;;;;;;;;GAQG;AAEH,kFAAkF;AAClF,MAAM,MAAM,SAAS,GAAG,MAAM,CAAA;AAE9B,MAAM,WAAW,UAAU;IACzB,gFAAgF;IAChF,EAAE,CAAC,EAAE,SAAS,GAAG,SAAS,CAAA;IAC1B,6DAA6D;IAC7D,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACzB,+CAA+C;IAC/C,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACzB;;;;;;OAMG;IACH,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CACzB;AAgED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,SAAiB,GAAG,MAAM,EAAE,CA2BzE;AAgGD,wBAAgB,aAAa,IAAI;IAC/B,SAAS,EAAE,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAA;IACjC,KAAK,EAAE,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAA;IAC7B,OAAO,EAAE,QAAQ,CAAC,GAAG,CAAC,SAAS,GAAG,IAAI,CAAC,CAAC,CAAA;IACxC,sEAAsE;IACtE,KAAK,EAAE,QAAQ,CAAC,GAAG,CAAC,oBAAoB,EAAE,CAAC,CAAC,CAAA;IAC5C,qFAAqF;IACrF,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,oBAAoB,EAAE,CAAA;IACnD;;;;;;OAMG;IACH,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAA;IACrC,KAAK,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,UAAU,KAAK,IAAI,CAAA;IACnD,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,UAAU,KAAK,IAAI,CAAA;IACtD,KAAK,EAAE,MAAM,IAAI,CAAA;CAClB,CA+FA;AAED,mFAAmF;AACnF,wBAAgB,0BAA0B,IAAI,IAAI,CAGjD"}

package/dist/hooks/use-listagem-na-url.d.ts

@@ -0,0 +1,185 @@
+import { ComputedRef, Ref } from 'vue';
+import { TipoFiltroUrl } from './filtros-url-internos';
+/** O que a tela precisa devolver para a tabela se pintar. */
+export interface ResultadoListagem<Linha> {
+    linhas: Linha[];
+    /** Total de registros no servidor. Sem ele, cai na contagem das linhas da página. */
+    totalItens?: number;
+    /** Total de páginas. Sem ele, assume 1. */
+    totalPaginas?: number;
+}
+/** O que o hook entrega para a função de busca. Vem da URL, não do formulário. */
+export interface ParametrosListagem<Filtros> {
+    /** Filtros já convertidos pelos `tipos` — o que a URL de fato carrega. */
+    filtros: Filtros;
+    /**
+     * Página **1-based**, igual ao `v-model` do `<acai-ui-table>`.
+     *
+     * 🔴 **Com `paginacao: 'cliente'`, IGNORE.** Lá quem fatia é o hook, e a chave
+     * do cache não inclui a página de propósito — é isso que faz folhear não
+     * chamar `buscar`. Se a busca usar esta página nesse modo, a primeira fatia
+     * pedida fica em cache e passa a ser devolvida para TODAS as páginas: dado
+     * errado, sem erro nenhum. Nesse modo escreva `({ filtros }) => …`.
+     */
+    pagina: number;
+}
+export interface OpcoesListagemNaUrl<Filtros extends object, Linha> {
+    /**
+     * Fábrica do estado inicial dos filtros. **Função, não objeto**: ela é chamada
+     * de novo no `limpar()`, e um objeto compartilhado voltaria já sujo da última
+     * pesquisa.
+     */
+    molde: () => Filtros;
+    /**
+     * A requisição. Recebe o que está na URL e devolve o que a tabela mostra.
+     *
+     * Erro aqui NÃO é engolido nem quebra a tela: as linhas atuais ficam onde
+     * estão, `erro` recebe o que foi lançado e o resultado não vai pro cache.
+     * Quem trata (notificação, retry) é a tela — o hook não sabe o que é um erro
+     * aceitável no domínio dela.
+     */
+    buscar: (parametros: ParametrosListagem<Filtros>) => Promise<ResultadoListagem<Linha>>;
+    /** Tipo declarado por campo. Ver `useFiltrosNaUrl` — mesma regra e mesmo motivo. */
+    tipos?: Readonly<Record<string, TipoFiltroUrl>>;
+    /** Chaves que NUNCA entram na URL (dado pessoal). Simétrico: também não são lidas. */
+    excluir?: readonly string[];
+    /** Prefixo das chaves. Só necessário com DUAS listagens na mesma rota. */
+    prefixo?: string;
+    /** Nome da chave de página na URL. Default `'pagina'`. */
+    chavePagina?: string;
+    /**
+     * Quem fatia as páginas. Default `'servidor'`.
+     *
+     * - **`'servidor'`** — `buscar` recebe a página e devolve só ela. É o desenho
+     *   de API paginada (Spring e afins), e cada troca de página é uma requisição.
+     * - **`'cliente'`** — `buscar` devolve o conjunto INTEIRO e o hook fatia. Uma
+     *   requisição por conjunto de filtros; folhear não chama `buscar` nenhuma vez.
+     *
+     * 🔴 `'cliente'` existe para fonte que **não pagina** — SOAP, arquivo, endpoint
+     * legado que só sabe devolver tudo. Nesses casos paginar no servidor não é uma
+     * escolha de desenho: refazer a chamada a cada clique de página é o custo
+     * inteiro da consulta de novo (medido de 9 a 15s no SOAP do DETRAN).
+     *
+     * Não é atalho para fonte que pagina de verdade: com resultado grande, trazer
+     * tudo para fatiar no navegador troca uma requisição pequena por uma enorme.
+     */
+    paginacao?: 'servidor' | 'cliente';
+    /**
+     * Quantas linhas por página. Default `10`.
+     *
+     * ⚠️ **Só vale com `paginacao: 'cliente'`** — quem fatia no modo servidor é o
+     * servidor, e o hook não tem como impor tamanho de página a ele. Declarar aqui
+     * junto de `'servidor'` avisa em DEV e não faz nada.
+     */
+    itensPorPagina?: number;
+    /**
+     * Buscar ao montar quando a URL está vazia? Default `true` — é o que toda
+     * listagem dos apps faz hoje (`onMounted(buscar)`). Passe `false` na tela que
+     * só deve buscar depois que a pessoa pesquisar.
+     *
+     * Com filtro na URL o hook busca de qualquer jeito: foi pedido explicitamente.
+     */
+    buscarAoMontar?: boolean;
+}
+export interface ListagemNaUrl<Filtros extends object, Linha> {
+    /**
+     * Rascunho do formulário — é aqui que os campos dão `v-model`.
+     *
+     * É rascunho de propósito: digitar não pesquisa e não mexe na URL. O que está
+     * na URL é a pesquisa APLICADA, e as duas só se encontram no `pesquisar()`.
+     */
+    filtros: Ref<Filtros>;
+    /**
+     * Os filtros que produziram as LINHAS que estão na tela — não o rascunho.
+     *
+     * Serve pra tudo que precisa acompanhar o resultado exibido em vez do que a
+     * pessoa está digitando. O caso real: listagem cujas COLUNAS dependem do
+     * filtro (situação `Ativo`/`Desligado` mostra ou não "Motivo de saída"). Com
+     * `filtros` o cabeçalho mudaria no meio da digitação, antes das linhas
+     * correspondentes chegarem.
+     *
+     * Só avança quando o resultado é aplicado — inclusive vindo do cache. Se a
+     * busca falha, continua descrevendo as linhas que ficaram na tela.
+     */
+    aplicados: Ref<Filtros>;
+    /** `v-model` do `<acai-ui-table>`. Mudar aqui já pagina (e escreve na URL). */
+    pagina: Ref<number>;
+    linhas: Ref<Linha[]>;
+    totalItens: Ref<number>;
+    totalPaginas: Ref<number>;
+    carregando: Ref<boolean>;
+    /** O que a última busca lançou, ou `null`. */
+    erro: Ref<unknown>;
+    /** Props prontas do `<acai-ui-table>`: `v-bind="listagem.tabela"`. */
+    tabela: ComputedRef<{
+        rows: Linha[];
+        totalItems: number;
+        totalPages: number;
+        skeleton: boolean;
+    }>;
+    /** `@submit` do `<acai-ui-form>`. Aplica o rascunho, volta pra página 1. */
+    pesquisar: () => void;
+    /** `@reset` do `<acai-ui-form>`. Devolve o molde e limpa a URL. */
+    limpar: () => void;
+    /**
+     * Refaz a requisição da pesquisa atual, ignorando o cache.
+     *
+     * É o que chamar depois de excluir uma linha na própria tela.
+     */
+    recarregar: () => Promise<void>;
+    /** Descarta o cache desta listagem sem refazer a busca agora. */
+    invalidar: () => void;
+    /** `true` quando a tela abriu já com filtro na URL. */
+    hidratou: boolean;
+}
+/**
+ * Descarta o cache de listagem.
+ *
+ * 🔴 **Chame depois de gravar.** O cache não tem como saber que outra tela
+ * cadastrou, editou ou excluiu um registro que a listagem mostra — e sem isso a
+ * pessoa salva, volta pra lista e vê o dado velho.
+ *
+ * ```ts
+ * // na tela de cadastro, depois de salvar
+ * await salvar()
+ * invalidarListagens('/servidores')   // ou sem argumento, pra derrubar todas
+ * void router.push({ name: 'servidores' })
+ * ```
+ *
+ * Sem argumento derruba tudo. É grosso, mas é o padrão seguro: o custo de
+ * invalidar demais é uma requisição, e o de invalidar de menos é dado errado
+ * na tela.
+ */
+export declare function invalidarListagens(rota?: string): void;
+/**
+ * Listagem com a URL como fonte da verdade.
+ *
+ * ```ts
+ * const listagem = useListagemNaUrl({
+ *   molde: filtrosServidoresIniciais,
+ *   excluir: ['pessoalCpf'],
+ *   tipos: { cargoId: 'number', progressoMinimo: 'number' },
+ *   buscar: async ({ filtros, pagina }) => {
+ *     const dados = await listarServidores(montarParametros(filtros, pagina))
+ *     return {
+ *       linhas: dados.content ?? [],
+ *       totalItens: dados.page?.totalElements,
+ *       totalPaginas: dados.page?.totalPages,
+ *     }
+ *   },
+ * })
+ * ```
+ *
+ * ```html
+ * <acai-ui-form @submit="listagem.pesquisar()" @reset="listagem.limpar()">
+ *   <acai-ui-input v-model="listagem.filtros.value.pessoalNome" label="Nome" />
+ * </acai-ui-form>
+ *
+ * <acai-ui-table v-model="listagem.pagina.value" :columns="colunas" v-bind="listagem.tabela.value" />
+ * ```
+ *
+ * Com `<script setup>`, desestruture — todos os campos são ref/computed e
+ * continuam reativos: `const { filtros, pagina, tabela, pesquisar } = listagem`.
+ */
+export declare function useListagemNaUrl<Filtros extends object, Linha>(opcoes: OpcoesListagemNaUrl<Filtros, Linha>): ListagemNaUrl<Filtros, Linha>;
+//# sourceMappingURL=use-listagem-na-url.d.ts.map

package/dist/hooks/use-listagem-na-url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-listagem-na-url.d.ts","sourceRoot":"","sources":["../../src/hooks/use-listagem-na-url.ts"],"names":[],"mappings":"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"}

package/dist/hooks/use-preferencias.d.ts

@@ -0,0 +1,60 @@
+export type TemaAcaiUi = 'claro' | 'escuro';
+export type DaltonismoAcaiUi = 'padrao' | 'protanopia' | 'deuteranopia' | 'tritanopia' | 'acromatopsia';
+export interface PreferenciasAcaiUi {
+    /** Tema de cores. Aplicado de fato via Quasar `Dark` + a camada `_themes.scss`. */
+    tema: TemaAcaiUi;
+    /** Tamanho da fonte em % da raiz (87.5 / 100 / 112.5 / 125). Aplicado de fato. */
+    tamanhoFonte: number;
+    /** Tipo de daltonismo: ajusta as cores de status pra paleta distinguível na condição. */
+    daltonismo: DaltonismoAcaiUi;
+    /** Reforço de bordas/contraste. (Persistido + marca o `<html>`.) */
+    altoContraste: boolean;
+    /** Desliga transições/animações. Aplicado de fato (injeta regra global). */
+    reduzirAnimacoes: boolean;
+    /**
+     * Mostra os botões de ouvir os textos da ajuda (leitura em voz alta).
+     *
+     * Não é "ler automaticamente": nada fala sem clique. Por isso não há efeito
+     * colateral no `aplicar()` — a preferência só é LIDA por quem desenha o botão.
+     */
+    leituraVoz: boolean;
+    /**
+     * Voz escolhida, pelo `name` do `SpeechSynthesisVoice`. Vazio = automática
+     * (voz local do idioma). Guardar o NOME e não o objeto é o que permite
+     * persistir; voz que sumiu da máquina cai na automática.
+     */
+    vozNome: string;
+    /**
+     * Velocidade da fala (`rate` da Web Speech API): 0.6 / 1 / 1.6.
+     *
+     * Valores medidos, não escolhidos por simetria: o motor do Windows arredonda o
+     * `rate` para degraus internos, e 0.85 / 1.15 soavam idênticos a 1.
+     */
+    vozVelocidade: number;
+}
+/**
+ * Preferências de acessibilidade/aparência do app, persistidas neste dispositivo.
+ * Estado é singleton (compartilhado por todos os `usePreferencias()`).
+ *
+ * Aplica de fato: **tema escuro** (Quasar `Dark` + `_themes.scss`), **tamanho da
+ * fonte** (root font-size) e **reduzir animações** (regra global). Daltonismo e alto
+ * contraste ainda só marcam `<html data-acai-*>` — a camada de tema (`_themes.scss`)
+ * já está preparada pra ligá-los reusando os mesmos `--acai-*`.
+ */
+export declare function usePreferencias(): {
+    /** Estado reativo (mutável via bind direto nos controles). */
+    preferencias: PreferenciasAcaiUi;
+    /** Cópia somente-leitura, útil pra ler sem risco de escrita acidental. */
+    somenteLeitura: {
+        readonly tema: TemaAcaiUi;
+        readonly tamanhoFonte: number;
+        readonly daltonismo: DaltonismoAcaiUi;
+        readonly altoContraste: boolean;
+        readonly reduzirAnimacoes: boolean;
+        readonly leituraVoz: boolean;
+        readonly vozNome: string;
+        readonly vozVelocidade: number;
+    };
+    redefinir: () => void;
+};
+//# sourceMappingURL=use-preferencias.d.ts.map

package/dist/hooks/use-preferencias.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-preferencias.d.ts","sourceRoot":"","sources":["../../src/hooks/use-preferencias.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,UAAU,GAAG,OAAO,GAAG,QAAQ,CAAA;AAC3C,MAAM,MAAM,gBAAgB,GACxB,QAAQ,GACR,YAAY,GACZ,cAAc,GACd,YAAY,GACZ,cAAc,CAAA;AAElB,MAAM,WAAW,kBAAkB;IACjC,mFAAmF;IACnF,IAAI,EAAE,UAAU,CAAA;IAChB,kFAAkF;IAClF,YAAY,EAAE,MAAM,CAAA;IACpB,yFAAyF;IACzF,UAAU,EAAE,gBAAgB,CAAA;IAC5B,oEAAoE;IACpE,aAAa,EAAE,OAAO,CAAA;IACtB,4EAA4E;IAC5E,gBAAgB,EAAE,OAAO,CAAA;IACzB;;;;;OAKG;IACH,UAAU,EAAE,OAAO,CAAA;IACnB;;;;OAIG;IACH,OAAO,EAAE,MAAM,CAAA;IACf;;;;;OAKG;IACH,aAAa,EAAE,MAAM,CAAA;CACtB;AAkFD;;;;;;;;GAQG;AACH,wBAAgB,eAAe;IAY3B,8DAA8D;;IAE9D,0EAA0E;;uBAtItE,UAAU;+BAEF,MAAM;6BAER,gBAAgB;gCAEb,OAAO;mCAEJ,OAAO;6BAOb,OAAO;0BAMV,MAAM;gCAOA,MAAM;;qBAmGC,IAAI;EAW3B"}

package/dist/hooks/use-repasse-quasar.d.ts

@@ -0,0 +1,42 @@
+import { ComputedRef } from 'vue';
+/**
+ * Repassa ao `q-*` tudo o que o wrapper recebeu, menos o que a lib consome ou
+ * compõe por conta própria.
+ *
+ * **Por que existe:** os wrappers tipam props como `extends Omit<QXProps, ...>`,
+ * então TODA prop do Quasar — inclusive os eventos, que ele declara como
+ * `onFocus`, `onFilter`, ... — vira prop DECLARADA do wrapper. Prop declarada
+ * sai do `$attrs` e **não faz fallthrough**: só chega no `q-*` o que o wrapper
+ * repassar à mão. Enquanto esse repasse foi uma lista escrita à mão, o que
+ * ficava de fora nascia morto — aceito pelo TypeScript, montado sem erro e sem
+ * efeito nenhum. Já custou `@focus`/`@blur`, `@filter` (a busca server-side do
+ * `q-select`) e, do lado das props, `debounce`, `counter`, `autogrow` e
+ * `autofocus`.
+ *
+ * **Por que não tirar as props do Quasar do tipo:** `Omit<QXProps, \`on${string}\`>`
+ * seria a solução de raiz — virariam attrs e o fallthrough resolveria sozinho.
+ * Mas o `@vue/compiler-sfc` não resolve template literal em `Omit` e o build
+ * quebra com "Failed to resolve extends base type" (o `vue-tsc` aceita — o
+ * resolver do compiler é mais limitado que o do TS). E remover as props do tipo
+ * sem mais nada tiraria do consumidor o autocomplete e a checagem que ele tem
+ * hoje.
+ *
+ * **A inversão que isso traz:** a lista mantida à mão passa a ser a das props da
+ * PRÓPRIA lib (`naoRepassar`) — pequena, estável e sob nosso controle. A lista
+ * do Quasar, que muda fora do nosso controle, flui sozinha: prop nova dele já
+ * nasce ligada.
+ *
+ * 🔴 **Prop de três estados exige `default: undefined` no `withDefaults`.** O Vue
+ * casta prop booleana AUSENTE para `false`, e algumas props do Quasar são
+ * `Boolean | null` onde `null` significa "herda" e `false` significa "força
+ * desligado" — `dark` é a mais grave (`null` = segue o tema, `false` = força
+ * claro). Sem o `undefined` explícito, repassar tudo desligaria o tema escuro em
+ * todo campo de todo app. Com ele, a prop ausente fica `undefined` e é filtrada
+ * aqui, deixando o Quasar aplicar o default dele.
+ *
+ * @param props as props do wrapper (`defineProps`).
+ * @param naoRepassar props que a lib CONSOME (não existem no `q-*`, e vazariam
+ *   como atributo no DOM) ou COMPÕE (o wrapper repassa com valor próprio).
+ */
+export declare function useRepasseQuasar(props: object, naoRepassar?: readonly string[]): ComputedRef<Record<string, unknown>>;
+//# sourceMappingURL=use-repasse-quasar.d.ts.map

package/dist/hooks/use-repasse-quasar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-repasse-quasar.d.ts","sourceRoot":"","sources":["../../src/hooks/use-repasse-quasar.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,WAAW,EAAE,MAAM,KAAK,CAAA;AAKhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,MAAM,EACb,WAAW,GAAE,SAAS,MAAM,EAAO,GAClC,WAAW,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAetC"}

package/dist/hooks/use-tamanho-elemento.d.ts

@@ -0,0 +1,26 @@
+import { Ref } from 'vue';
+/**
+ * Mede a caixa de um elemento e mantém a medida atualizada.
+ *
+ * Existe pro gráfico renderizar 1:1 em vez de esticar o `viewBox`. Esticar
+ * escalaria o TEXTO junto: a mesma folha em 380px e em 1400px teria rótulo de
+ * 8px e de 20px — abaixo do legível num caso, e ignorando a preferência de
+ * tamanho de fonte do usuário (`html { font-size: X% }`) no outro.
+ *
+ * SSR-safe: nada toca o DOM fora do `onMounted`, e cada observador é criado só
+ * se existir no ambiente.
+ */
+export interface TamanhoElemento {
+    largura: Ref<number>;
+    altura: Ref<number>;
+    /** `false` até a primeira medição real. Quem desenha usa o padrão nesse meio-tempo. */
+    medido: Ref<boolean>;
+    /** Força uma releitura (troca de aba, fim de animação, mudança de fonte). */
+    remedir: () => void;
+}
+export interface PadraoTamanho {
+    largura?: number;
+    altura?: number;
+}
+export declare function useTamanhoElemento(alvo: Ref<HTMLElement | null | undefined>, padrao?: PadraoTamanho): TamanhoElemento;
+//# sourceMappingURL=use-tamanho-elemento.d.ts.map

package/dist/hooks/use-tamanho-elemento.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-tamanho-elemento.d.ts","sourceRoot":"","sources":["../../src/hooks/use-tamanho-elemento.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmC,KAAK,GAAG,EAAE,MAAM,KAAK,CAAA;AAE/D;;;;;;;;;;GAUG;AACH,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IACpB,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IACnB,uFAAuF;IACvF,MAAM,EAAE,GAAG,CAAC,OAAO,CAAC,CAAA;IACpB,6EAA6E;IAC7E,OAAO,EAAE,MAAM,IAAI,CAAA;CACpB;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,GAAG,CAAC,WAAW,GAAG,IAAI,GAAG,SAAS,CAAC,EACzC,MAAM,GAAE,aAAkB,GACzB,eAAe,CA4EjB"}

package/dist/hooks/use-tela.d.ts

@@ -0,0 +1,84 @@
+import { ComputedRef, MaybeRefOrGetter } from 'vue';
+/**
+ * Breakpoints em número, espelhando `scss/_breakpoints.scss`.
+ *
+ * Existem em duplicata (SCSS + TS) porque não há como um `@media` ler uma
+ * constante de runtime nem o contrário. A regra é: quem muda só de ESTILO usa
+ * o mixin SCSS; quem muda de COMPORTAMENTO usa isto aqui. Mexeu num, mexe no
+ * outro.
+ */
+export declare const BREAKPOINTS: {
+    /** < 600px — celular */
+    readonly sm: 600;
+    /** < 1024px — tablet paisagem / laptop */
+    readonly md: 1024;
+    /** < 1440px — desktop */
+    readonly lg: 1440;
+    /** < 1920px — desktop grande */
+    readonly xl: 1920;
+};
+export interface TelaAcaiUi {
+    /** Largura da viewport em px. **0 enquanto não houve medição** — ver `medido`. */
+    largura: ComputedRef<number>;
+    /**
+     * `false` no servidor (SSR) e durante o render de hidratação; `true` a partir
+     * do momento em que o Quasar mediu a viewport de verdade.
+     *
+     * Em SPA nasce `true`: o `Screen` do Quasar mede no `install`, antes do mount.
+     */
+    medido: ComputedRef<boolean>;
+    /** Viewport ≤ 599.98px (o `xs` do Quasar, o `ate-mobile` do SCSS). */
+    ehMobile: ComputedRef<boolean>;
+    /** Viewport ≤ 1023.98px — celular ou tablet retrato (`ate-tablet` do SCSS). */
+    ateTablet: ComputedRef<boolean>;
+    /** Ponteiro grosso (dedo/caneta). É sobre COMO se aponta, não sobre largura. */
+    ehToque: ComputedRef<boolean>;
+    /** Viewport ≤ `limite`. Aceita número, ref ou getter (ex.: `() => props.breakpoint`). */
+    abaixoDe: (limite: MaybeRefOrGetter<number>) => ComputedRef<boolean>;
+}
+/**
+ * Leitura de viewport que funciona igual em SPA e em SSR.
+ *
+ * ## Por que não usar `$q.screen` direto
+ *
+ * `$q.screen.width` **é 0 em SSR**, e não por acidente. No fonte do Quasar
+ * (`plugins/screen/Screen.js`):
+ *
+ * - no servidor o `install()` retorna em `if (__QUASAR_SSR_SERVER__) return`
+ *   logo depois de `$q.screen = this` — os defaults nunca são atualizados;
+ * - no cliente, quando a página veio do servidor, a medição (`start`) é
+ *   empurrada pra `onSSRHydrated`, ou seja roda **depois** da hidratação.
+ *
+ * Isso é deliberado: servidor e render de hidratação enxergam o MESMO 0, então
+ * a marcação bate e não há erro de hidratação. O preço é que, entre o primeiro
+ * byte e o fim da hidratação, ninguém sabe a largura.
+ *
+ * Ler `$q.screen.width` cru nesse intervalo dá "0", e `0 <= breakpoint` é
+ * verdadeiro — um componente ingênuo renderiza **mobile no desktop** e pisca.
+ * Guardar com `width > 0` conserta o pisca mas inverte o erro: o celular recebe
+ * o layout de desktop na primeira pintura e só corrige depois de hidratar —
+ * salto de layout em toda navegação.
+ *
+ * ## O que este hook faz
+ *
+ * Enquanto não há medição, o palpite vem do **User-Agent**, que o Quasar
+ * resolve no servidor a partir do header da requisição (`Platform.parseSSR`) e
+ * mantém idêntico no cliente até a hidratação terminar (`preHydrationBrowser`,
+ * guardado justamente "in order to prevent hydration errors"). Servidor e
+ * cliente chegam à mesma resposta — sem mismatch — e um celular já recebe o
+ * layout de celular na primeira pintura. Assim que a medição chega, ela manda,
+ * e a UA vira irrelevante.
+ *
+ * Em SPA nada disso acontece: `medido` já é `true` no primeiro render e o
+ * caminho da UA nunca é exercido.
+ *
+ * ## Quando NÃO usar
+ *
+ * Se a mudança é só de estilo, use `@include ate-mobile` do
+ * `scss/_breakpoints.scss`. Media query é resolvida pelo navegador na primeira
+ * pintura, sem JS e sem hidratação — é sempre a opção mais correta e mais
+ * barata. Este hook é pro caso em que o COMPORTAMENTO muda: outra prop, outro
+ * componente, outra árvore.
+ */
+export declare function useTela(): TelaAcaiUi;
+//# sourceMappingURL=use-tela.d.ts.map

package/dist/hooks/use-tela.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-tela.d.ts","sourceRoot":"","sources":["../../src/hooks/use-tela.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,KAAK,WAAW,EAAE,KAAK,gBAAgB,EAAE,MAAM,KAAK,CAAA;AAGhF;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW;IACtB,wBAAwB;;IAExB,0CAA0C;;IAE1C,yBAAyB;;IAEzB,gCAAgC;;CAExB,CAAA;AAEV,MAAM,WAAW,UAAU;IACzB,kFAAkF;IAClF,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;IAC5B;;;;;OAKG;IACH,MAAM,EAAE,WAAW,CAAC,OAAO,CAAC,CAAA;IAC5B,sEAAsE;IACtE,QAAQ,EAAE,WAAW,CAAC,OAAO,CAAC,CAAA;IAC9B,+EAA+E;IAC/E,SAAS,EAAE,WAAW,CAAC,OAAO,CAAC,CAAA;IAC/B,gFAAgF;IAChF,OAAO,EAAE,WAAW,CAAC,OAAO,CAAC,CAAA;IAC7B,yFAAyF;IACzF,QAAQ,EAAE,CAAC,MAAM,EAAE,gBAAgB,CAAC,MAAM,CAAC,KAAK,WAAW,CAAC,OAAO,CAAC,CAAA;CACrE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAgB,OAAO,IAAI,UAAU,CA2BpC"}