Table Builder para Quasar

🇺🇸 English | 🇪🇸 Versión en español

Extensão Quasar para tabelas declarativas em apps Vue 3 + Quasar: listagens com filtros (via Form Builder), paginação servidor/cliente, ordenação no backend, seleção de linhas, slots de coluna e consultas canceláveis.

Índice

• Em 30 segundos
• O que é e o que inclui
• Requisitos e compatibilidade
• Instalação em app Quasar
• O que a extensão adiciona ao host
• Defaults globais (boot)
• Comandos scaffold no host
• Uso rápido
• Idioma (i18n)
• TypeScript no seu IDE
• Configuração de defineTable
• Filtros e busca
• Paginação
• Ordenação
• Seleção de linhas
• fetch, cancelamento e hooks
• Slots
• Ref de TableBuilder
• Tipos TypeScript exportados
• Extensões relacionadas
• Sessão e store Pinia
• Entrypoints públicos
• Troubleshooting

Em 30 segundos

Fluxo base recomendado:

1. Definir tipos de filtros F e linha R.
2. Configurar campos de filtro com Form Builder (defineForm ou filters.form inline).
3. Criar a tabela com defineTable<F, R>({ ... }) a partir de useTableBuilder().
4. Renderizar <TableBuilder ref="tableRef" :config="config" /> com slots #column-* e #toolbar.

A extensão registra boot e CSS no projeto host automaticamente após quasar ext add.

O que é e o que inclui

Table Builder orquestra listagens: toolbar, filtros Form Builder, tabela, paginação e fetch. Não substitui Form Builder — os filtros são sempre um formulário FB.

• defineTable<F, R> + <TableBuilder />; filtros drawer | inline ou filters: false.
• Paginação server | client; ordenação; seleção de linhas; slots #column-* / #toolbar.
• Ref imperativa (reload, resetFilters, cancelFetch, …) e selectTableStore (Pinia por tabela).
• persistData opcional; cancelamento via signalAbort ou abort global no boot.
• Defaults no boot (configureTableBuilder); filterUi tematiza botões, cabeçalho do drawer, chips e painel por light / dark.
• Grade e paginação via DataTable (@benjaminor-dev/datatable) — cards no mobile < sm.
• Defaults no boot (configureTableBuilder); scaffold bor:make-table.
• i18n integrado en, es, pt — segue Quasar $q.lang; overrides no boot (locale, messages).

Requisitos e compatibilidade

O boot de Pinia do host deve rodar antes de Form Builder e Table Builder.

Instalação em app Quasar

Instale DataTable e Form Builder antes de Table Builder (peers obrigatórios):

quasar ext add @benjaminor-dev/datatable
quasar ext add @benjaminor-dev/form-builder
quasar ext add @benjaminor-dev/table-builder

Remover:

quasar ext remove @benjaminor-dev/table-builder

O que a extensão adiciona ao host

Install (quasar ext add / invoke): cria src/boot/bor/bor-table-builder-defaults.ts (ou .js) e registra em quasar.config → boot: [] automaticamente. Não é preciso editar manualmente numa instalação normal. O boot do pacote (boot/store) e CSS são injetados pela extensão em cada dev/build.

Remove (quasar ext remove): remove o script scaffold, o defaults boot, sua entrada em quasar.config e bor:make-table em package.json (se ainda apontar para o arquivo do install).

Se você apagar o arquivo de defaults, a app continua com os built-ins da biblioteca (fetchOnMount: false, pageSize: 10, etc.).

Ordem de boots (esta extensão): Pinia → DataTable (CSS) → Form Builder → boot store TB → bor/bor-table-builder-defaults → resto.

Defaults globais (boot)

Evite repetir filters, pagination, fetchOnMount, persistData e abort em cada defineTable. Prioridade: defineTable → boot (configureTableBuilder) → built-in da biblioteca.

Após quasar ext add, revise src/boot/bor/bor-table-builder-defaults.ts — template com fetchAbort e opções comentadas (pagination, persistData). Defaults built-in: JSDoc @default nos tipos.

// src/boot/bor/bor-table-builder-defaults.ts (trecho)
import { configureTableBuilder } from "@benjaminor-dev/quasar-app-extension-table-builder";

configureTableBuilder({
  filters: { layout: "drawer", openFiltersOnMount: false, showFilterChips: true },
  fetchOnMount: false,
  // persistData: true, // descomente para cache SPA global
  filterUi: {
    buttonStyle: {
      light: {
        filtersColor: "teal",
        filtersVariant: "outline",
        searchColor: "primary",
        searchVariant: "outline",
        clearVariant: "flat",
        submitColor: "primary",
        submitVariant: "unelevated",
        stopColor: "negative",
        stopVariant: "unelevated",
      },
      dark: {
        filtersColor: "teal",
        filtersVariant: "unelevated",
        searchColor: "primary",
        searchVariant: "unelevated",
        clearColor: "white",
        clearVariant: "flat",
        submitColor: "primary",
        submitVariant: "unelevated",
        stopColor: "negative",
        stopVariant: "unelevated",
      },
    },
    panelHeader: {
      light: { color: "primary", textColor: "white" },
      dark: { color: "primary", textColor: "white" },
    },
    chips: {
      light: { color: "primary", textColor: "white" },
      dark: { color: "primary", textColor: "white" },
    },
    chipsPanel: {
      light: {
        borderColor: "rgba(25, 118, 210, 0.16)",
        backgroundColor: "rgba(25, 118, 210, 0.04)",
      },
      dark: {
        borderColor: "rgba(255, 255, 255, 0.12)",
        backgroundColor: "rgba(255, 255, 255, 0.04)",
      },
    },
  },
  // fetchAbort opcional — veja arquivo gerado no install
});

Use configureTableBuilderDefaults se você só precisa de defaults sem registrar fetchAbort.

Prioridade de filterUi: defineTable({ filterUi }) → boot → built-in. O tema ativo segue $q.dark do host.

Cancelamento detalhado: § Cancelamento.

Comandos scaffold no host

A extensão registra bor:make-table no host (scripts/bor/bor-make-table.mjs → runBorMakeTable em /scaffold). Execute npm run bor:help (Form Builder) para ver todos os geradores instalados.

Tabelas (bor:make-table)

npm run bor:make-table -- <nombre-o-ruta>

Exemplo — criar UsuariosTable.vue:

npm run bor:make-table -- usuarios

Resultado:

• src/components/TableBuilder/UsuariosTable.vue
• tableName: "UsuariosTable" (PascalCase, alinhado ao arquivo)
• Tipos UsuariosFilters / UsuarioRow y variable usuariosTableStore = selectTableStore<UsuarioRow>("UsuariosTable")

Regras de naming:

• O nome do arquivo é normalizado para PascalCase e termina em Table.vue.
• Se você enviar UsuariosTable, não duplica o sufixo.
• usuarios → UsuariosTable.vue; personas/equipo → personas/EquipoTable.vue.
• Você pode forçar overwrite com --force (ou -f).
• O rascunho inclui filtros drawer, colunas com slots (icon, actions), selectTableStore e deleteRow via patchItems.
• Template override no host: scripts/bor/stubs/bor-make-table.stub.

Uso rápido

<script setup lang="ts">
import { TableBuilder, useTableBuilder } from "@benjaminor-dev/quasar-app-extension-table-builder";

type Filters = { search: string | null; role: string | null };
type Row = { id: number; name: string; role: string };

const { defineTable, useTableRef } = useTableBuilder();
const tableRef = useTableRef();

const config = defineTable<Filters, Row>({
  tableName: "usuarios",
  title: "Usuários",
  columns: [
    { name: "name", label: "Nome", field: "name", align: "left", sortable: true },
    { name: "role", label: "Papel", field: "role", sortable: true },
  ],
  pagination: { mode: "server", pageSize: 10, placement: "auto", defaultSort: { sortBy: "name" } },
  fetchOnMount: false,
  filters: {
    layout: "drawer",
    minActiveFilters: 1,
    form: {
      fields: [
        { type: "InputSearch", model: "search", label: "Buscar" },
        {
          type: "InputSelect",
          model: "role",
          label: "Papel",
          props: { options: [{ label: "Admin", value: "admin" }], clearable: true },
        },
      ],
    },
  },
  fetch: async ({ filters, page, pageSize, sortBy, descending, signalAbort }) => {
    const params = new URLSearchParams({
      page: String(page),
      pageSize: String(pageSize),
    });
    if (sortBy) {
      params.set("sortBy", sortBy);
      params.set("descending", String(descending));
    }
    if (filters.search) params.set("search", filters.search);
    if (filters.role) params.set("role", filters.role);

    const res = await fetch(`/api/users?${params}`, { signal: signalAbort });
    const data = await res.json();
    return {
      rows: data.items,
      pagination: { total: data.total, page, pageSize },
    };
  },
});
</script>

<template>
  <TableBuilder ref="tableRef" :config="config">
    <template #column-name="{ row, text }">
      <strong>{{ text || row.name }}</strong>
    </template>
  </TableBuilder>
</template>

Idioma (i18n)

Integrado en, es e pt. Por padrão os textos de toolbar, drawer, estados vazios e skeleton seguem o idioma do Quasar ($q.lang.isoName); se o Quasar não tiver idioma, o fallback é en.

Resolução de locale: boot locale → prefixo de $q.lang.isoName (es* → es, pt* → pt) → en.

Exemplo em quasar.config.ts (português para toda a app):

// quasar.config.ts
framework: {
  lang: "pt-BR",
},

Template boot (após install):

configureTableBuilder({
  // locale: "pt", // fixa só o idioma do Table Builder
  // messages: { search: "Consultar" },
});

Chaves i18n: botões (filters, search, refresh, stopQuery, clear), drawer (filtersPanelTitle), estados vazios (emptyNotQueried*, noResults*, fetchCancelled*), tooltip de busca (searchGateDefault), skeleton (loading*Title, loading*Hint) e aria (filtersAppliedAria, removeFilterAria com {label}).

Prioridade de mensagens: boot messages funde sobre o catálogo built-in do locale ativo.

TypeScript no seu IDE

A config da tabela é tipada de ponta a ponta: deixe o IDE guiar você.

• Importe de @benjaminor-dev/quasar-app-extension-table-builder/types (TableBuilderConfig, TableColumnDef, TableFetchContext, …).
• defineTable<MeusFiltros, MinhaLinha>({ ... }) — os genéricos tipam filters, o contexto de fetch e as linhas nos slots.
• Ctrl+Space (Windows/Linux) ou Cmd+Space (macOS) dentro de defineTable mostra colunas, pagination, filters, hooks, etc.
• No callback fetch, o parâmetro inclui filters, page, pageSize, sortBy, descending e, se precisar, signalAbort — tudo autocompletado conforme seus genéricos.
• Filtros: os fields do formulário são os mesmos tipos do Form Builder; combine com @benjaminor-dev/quasar-app-extension-form-builder/types se compartilhar modelos.
• Em configureTableBuilder({ filterUi: { ... } }), Ctrl+Space / Cmd+Space lista buttonStyle, panelHeader, chips, chipsPanel e campos por tema (light / dark).
• No boot, locale aceita "en" \| "es" \| "pt"; messages aceita Partial<TableBuilderMessages> (toolbar, drawer, estados vazios, skeleton).
• Override pontual em defineTable({ filterUi }) para uma única tabela.

Se uma opção não aparecer no autocompletar, revise o import de /types antes de buscar no README.

Configuração de defineTable

Campos principais de defineTable<F, R>():

Colunas (columns)

defineTable não exige ordem fixa: o runtime normaliza a lista ao resolver a config.

Para personalizar a coluna índice (largura, alinhamento, ocultá-la), declare explicitamente com name: "index".

Filtros e busca

Layout

Regras para habilitar busca (AND)

filters: {
  minActiveFilters: 1,
  canSearch: (filters) => Boolean(filters.search?.trim()) || filters.role != null,
  searchDisabledMessage: "Indique busca ou papel para consultar.",
  showFilterChips: true,
  form: { fields: [...] },
}

Os chips refletem o snapshot da última busca bem-sucedida, não o formulário ao vivo.

Formulário de filtros (filters.form)

Mesma forma que defineForm do Form Builder:

• fields — obrigatório.
• defaultValues — opcional: só overrides ou pré-carga; não é preciso listar todo o modelo.
• formName — opcional; por padrão table:{tableName}:filters.

filters: {
  form: {
    fields: [{ type: "InputSearch", model: "search", label: "Buscar" }],
    defaultValues: { role: "admin" },
  },
}

Você também pode passar o resultado de defineForm(...) se preferir definir o formulário fora de defineTable.

Toolbar com drawer (grupo fundido)

Um QBtnGroup outline agrupa os botões da toolbar somente quando Filtros e Buscar/Stop compartilham variante outline. Se misturar variantes (ex.: outline + flat), renderiza como botões separados.

• Filtros: abre o drawer.
• Lupa / refresh (mesmo botão): primeira busca se ainda não houver linhas; refresh se já houver resultados (recarrega sem resetar página).
• Stop: durante a carga, cancela a consulta — só se allowUserCancel estiver ativo (boot ou tabela).

UI de filtros por tema (filterUi)

filterUi: {
  buttonStyle: {
    light: { filtersColor: "teal", filtersVariant: "outline", searchVariant: "outline" },
    dark: { filtersColor: "teal", filtersVariant: "unelevated", searchVariant: "unelevated" },
  },
  panelHeader: { light: { color: "primary", textColor: "white" }, dark: { color: "primary", textColor: "white" } },
  chips: { light: { color: "primary", textColor: "white" }, dark: { color: "primary", textColor: "white" } },
},

Paginação

pagination: {
  mode: "server",
  pageSize: 25,
  placement: "auto",
  scrollOnPageChange: "auto",
  defaultSort: { sortBy: "name" },
}

| defaultSort | Ordem inicial no modo server (sortBy, descending?). Ignorado em client salvo se QTable receber o estado inicial via paginação interna. |

Modo server: fetch deve retornar { rows, pagination } com pelo menos total, page e pageSize. Os campos from, to e lastPage são opcionais (o runtime calcula se faltarem). Ao clicar um cabeçalho sortable, reconsulta com sortBy e descending (página 1).

Modo client: fetch pode retornar R[] ou { rows }; pagina e ordena QTable em memória.

Ordenação

Ordem inicial no servidor:

pagination: {
  mode: "server",
  defaultSort: { sortBy: "name", descending: false },
}

sortBy e descending também chegam a onBeforeFetch com a mesma forma que em fetch.

Seleção de linhas

const config = defineTable<Filters, Row>({
  // ...
  selection: "multiple", // ou "single"
});

A seleção é limpa após cada fetch bem-sucedido (busca, paginação, ordenação ou reload).

No script, leia as linhas pela ref:

const tableRef = useTableRef();
const selectedCount = computed(() => tableRef.value?.selectedRows?.length ?? 0);

No template, use um computed (não acesse tableRef.selectedRows diretamente: vue-tsc não desembrulha o ShallowRef no template).

fetch, cancelamento e hooks

Contexto de fetch

type TableFetchContext<F> = {
  filters: F;
  page: number;
  pageSize: number;
  sortBy: string | null;
  descending: boolean;
  signalAbort?: AbortSignal;
};

Retorna linhas (e metadados no modo server):

// client
fetch: async ({ filters }) => ({ rows: await api.list(filters) }),

// server
fetch: async ({ filters, page, pageSize, sortBy, descending }) => ({
  rows: items,
  pagination: { total, page, pageSize },
}),

Cancelamento — escolha um caminho

O cancelamento não passa por onFetchError.

Quem pode parar a consulta?

Por padrão ninguém (sem botão Stop). Ative no boot (fetchAbort.allowUserCancel) ou por tabela (defineTable.allowUserCancel + signalAbort no fetch).

Prioridade: defineTable.allowUserCancel → fetchAbort.allowUserCancel (boot) → false.

// Boot — todas as tabelas com Stop (abort global do host)
configureTableBuilder({
  fetchAbort: {
    allowUserCancel: true,
    getSignal: () => useAbortStore().getSignal(),
    abort: () => useAbortStore().abort(),
  },
});

// Uma tabela sem Stop mesmo com boot ativo
defineTable({ tableName: "Logs", allowUserCancel: false, ... });

// Só esta tabela com Stop (Caminho A portátil)
defineTable({
  tableName: "Usuarios",
  allowUserCancel: true,
  fetch: ({ signalAbort, ...ctx }) => UsersService.list(ctx.filters, signalAbort),
});

Uma nova busca ou mudança de página continua abortando a requisição anterior mesmo com Stop desativado (evita sobreposições).

Caminho A — portátil (default)

Table Builder cria um AbortController por consulta. Reencaminhe signalAbort ao cliente HTTP no fetch:

fetch: async ({ filters, page, pageSize, signalAbort }) => {
  const res = await api.get("/users", { params: { filters, page, pageSize }, signal: signalAbort });
  return { rows: res.data.items, pagination: res.data.meta };
},

Se o service vive fora do componente, passe como argumento:

fetch: ({ filters, signalAbort }) => UsersService.list(filters, signalAbort),

Recomendado com várias tabelas em paralelo (cada consulta tem seu próprio sinal).

Caminho B — abort global do host (sem signalAbort em cada tabela)

Se sua app já centraliza o cancelamento (Pinia + axios que auto-injeta signal em cada requisição), registre o adaptador uma vez no boot do host.

Opção incluída — store Pinia da extensão (useTableFetchAbortStore):

configureTableBuilder({
  fetchAbort: {
    useStore: true,
    allowUserCancel: false, // recomendado: false
  },
});

Injete useTableFetchAbortStore().getSignal() na sua camada HTTP (axios, etc.).

Opção custom — store próprio do host:

// src/boot/table-builder.ts
import { boot } from "quasar/wrappers";
import {
  configureTableBuilder,
  defaultIsTableFetchAbortError,
} from "@benjaminor-dev/quasar-app-extension-table-builder";
import useAbortStore from "@/stores/config/useAbortStore";

export default boot(() => {
  configureTableBuilder({
    fetchAbort: {
      allowUserCancel: false,
      getSignal: () => useAbortStore().getSignal(),
      abort: () => useAbortStore().abort(),
      isAbortError: (error) =>
        defaultIsTableFetchAbortError(error) ||
        (error instanceof Error && error.message === "canceled"),
    },
  });
});

Sua camada HTTP deve continuar injetando o mesmo signal do store quando a requisição não traz um explícito (como em ApiUtils.makeNewConfig).

Então o fetch da tabela não precisa usar signalAbort:

fetch: ({ filters, page, pageSize }) =>
  UsersService.index(filters, { page, pageSize }),

Table Builder chamará abort() do store ao cancelar ou iniciar outra consulta; axios captará como antes.

Nota: um abort store global implica uma consulta abortável ativa na app. Com várias tabelas carregando ao mesmo tempo, use o caminho A.

Hooks (controle opcional)

Cancelamento (AbortError, axios canceled, …) não dispara onFetchError.

Exemplo — erros de validação nos filtros (adapte ao contrato da sua API):

import { selectFormStore } from "@benjaminor-dev/quasar-app-extension-form-builder";

onFetchError: (error, ctx) => {
  const raw = (error as { response?: { data?: { errors?: Record<string, string | string[]> } } })
    .response?.data?.errors;
  if (!raw) {
    $q.notify({ type: "negative", message: "Erro ao consultar." });
    return;
  }

  selectFormStore(`table:${tableName}:filters`).setErrors(
    Object.fromEntries(
      Object.entries(raw).map(([key, value]) => [
        key,
        Array.isArray(value) ? value[0] : String(value),
      ]),
    ),
  );
},

Estados de UI após a consulta

• Sem linhas após busca → mensagem contextual (com/sem filtros aplicados).
• Busca cancelada manualmente → «Consulta cancelada» (conforme origem da carga).
• Carga → skeleton com mensagem conforme motivo (search, pagination, sort, refresh, …).

Slots

<TableBuilder :config="config">
  <template #toolbar>
    <q-chip v-if="selectedCount > 0" dense color="primary">
      {{ selectedCount }} selecionados
    </q-chip>
    <q-btn outline label="Exportar" />
  </template>

  <template #column-actions="{ row, text, column, value }">
    <q-btn flat icon="edit" @click="edit(row)" />
  </template>
</TableBuilder>

Helper tipado: tableColumnSlotName("actions") → "column-actions".

Ref de TableBuilder

const tableRef = useTableRef();

await tableRef.value?.reload();
await tableRef.value?.reload({ resetPage: true });
await tableRef.value?.reload({ resetFilters: true });

tableRef.value?.openFilters();
tableRef.value?.resetFilters();
tableRef.value?.cancelFetch();
tableRef.value?.clearSelection();
await tableRef.value?.invalidate();

if (tableRef.value?.loading) { /* ... */ }
const selected = tableRef.value?.selectedRows ?? [];

Tipos TypeScript exportados

Do entrypoint principal e /types:

import type {
  ConfigureTableBuilderOptions,
  TableFilterUiDefaults,
  TableFilterChipStyleConfig,
  TableFilterChipsPanelStyleConfig,
  TableFilterPanelHeaderStyleConfig,
  TableBuilderConfig,
  TableBuilderResolvedConfig,
  TableFiltersConfigInput,
  TableSearchGateFn,
  TableColumnDef,
  TableColumnSlotProps,
  TablePaginationConfig,
  TablePaginationPlacement,
  TableDefaultSort,
  TableBuilderSlots,
} from "@benjaminor-dev/quasar-app-extension-table-builder/types";

import type {
  TableRow,
  TableFilters,
  TableFetchContext,
  TableFetchResult,
  TablePaginationMeta,
  TablePaginationMetaInput,
  TablePaginationMode,
  TableRowSelectionMode,
} from "@benjaminor-dev/quasar-app-extension-table-builder/types";

import type {
  PersistDataConfig,
  PersistDataConfigOption,
} from "@benjaminor-dev/quasar-app-extension-table-builder/types";

import type {
  TableBuilderExpose,
  TableBuilderReloadOptions,
  RefTableBuilder,
} from "@benjaminor-dev/quasar-app-extension-table-builder";

import { tableColumnSlotName } from "@benjaminor-dev/quasar-app-extension-table-builder";

Extensões relacionadas

Table Builder não inclui gerador de formulários próprio: reutiliza Form Builder para não duplicar inputs nem regras.

Ordem de boots (stack completo):

1. Pinia (host)
2. DataTable — CSS
3. Form Builder — boot/store
4. bor/bor-form-builder-defaults (host)
5. Table Builder — boot/store
6. bor/bor-table-builder-defaults (host)
7. Dialog File Preview — boot/dialog
8. bor/bor-dialog-file-preview-defaults (host)
9. Dialog Loader — boot/dialog
10. bor/bor-dialog-loader-defaults (host)
11. Dialog Message — boot/dialog
12. bor/bor-dialog-message-defaults (host)

Em quasar.config você verá o defaults boot de cada extensão (ex.: bor/bor-table-builder-defaults); os boots do pacote são injetados pela extensão ao compilar — não aparecem como entradas curtas na sua config.

Sessão e store Pinia

Uma sessão por tableName no Pinia (mesmo padrão do store do Form Builder para filtros).

Acesso: useTableBuilder().selectTableStore(tableName) ou selectTableStore(tableName) importado do pacote.

selectTableStore<R>(tableName)

Visão tipada da sessão. O mesmo tableName em outro .vue ou composable compartilha linhas e metadados.

const { defineTable, selectTableStore } = useTableBuilder();

const usuariosTableStore = selectTableStore<UsuarioRow>("UsuariosTable");

// Após apagar na API, remover linha sem refetch
await api.delete(id);
usuariosTableStore.patchItems((rows) => rows.filter((r) => r.id !== id));

// Leitura reativa
if (usuariosTableStore.hasItems.value) {
  const rows = usuariosTableStore.items.value;
}

Tipo exportado: TableSessionHandle<R> em /types.

Filtros continuam no Form Builder (table:{tableName}:filters por padrão).

persistData (opcional)

Conserva a sessão Pinia ao desmontar <TableBuilder /> (navegar para outra rota e voltar).

const config = defineTable<Filters, Row>({
  tableName: "usuarios",
  columns: [...],
  fetch: async ({ filters, page, pageSize, signalAbort }) => ({ rows, pagination: { ... } }),
  persistData: true,
  fetchOnMount: false, // vazio até a primeira busca
});

Ajuste fino: persistDataConfig: { reuseOnMount: false } força fetch ao montar mesmo com dados no Pinia.

Entrypoints públicos

Troubleshooting

Os textos da UI continuam em inglês

• Configure framework.lang em quasar.config ou fixe a extensão: configureTableBuilder({ locale: "pt" }) em src/boot/bor/bor-table-builder-defaults.ts.

O defaults boot não aparece em quasar.config

Em condições normais o install registra sozinho. Se faltar (projeto antigo ou edição manual):

npx quasar ext invoke @benjaminor-dev/table-builder

Erro de Pinia / store de filtros ou tabelas

• Pinia do host deve ir antes de Form Builder e Table Builder.
• Instale e faça boot de Form Builder e DataTable antes de Table Builder.
• Se vir erros de sessão não inicializada, verifique se <TableBuilder /> está montado e se tableName é único por tabela.

fetch em modo server sem metadados

Em pagination.mode: "server", retorne { rows, pagination } com pelo menos total, page e pageSize. Não é preciso calcular from/to/lastPage manualmente.

return { rows: items, pagination: { total, page, pageSize } };

Botão buscar desabilitado

Revise minActiveFilters e canSearch. O tooltip indica o motivo. Os valores são lidos do formulário ao vivo, não do último snapshot de chips.

Os chips não coincidem com o que vejo no drawer

É esperado: chips = última busca bem-sucedida. Abra filtros, altere valores e clique buscar para atualizar.

Cancelar durante paginação vs busca

• Busca cancelada sem linhas anteriores → mensagem «Consulta cancelada».
• Paginação, ordenação ou remover chip cancelada → reverte página/ordem/filtro e mantém linhas atuais.

Ordenar em server não faz nada

Verifique se a coluna tem sortable: true e se seu fetch usa sortBy / descending ao chamar a API.

selectedRows no template dá erro de tipos

Use tableRef.value?.selectedRows no script (ex.: com computed), não tableRef.selectedRows no template.

Stop não cancela a requisição HTTP

• Caminho A (default): seu fetch deve reencaminhar signalAbort ao cliente (fetch, axios como { signal: signalAbort }, etc.).
• Caminho B (adapter): registre configureTableBuilder({ fetchAbort: … }) no boot (ou fetchAbort: { useStore: true }) e verifique se sua camada HTTP injeta o mesmo AbortSignal do store. configureTableFetchAbort é a API de baixo nível equivalente. Se axios lançar message: "canceled", inclua isAbortError no adapter (ver README § Cancelamento).

Erros do endpoint não chegam ao formulário de filtros

Implemente onFetchError e mapeie o corpo do erro com selectFormStore(formName).setErrors(...) conforme o contrato da sua API. Verifique se formName coincide com o do form de filtros.

MIT © Benjamín Olvera R.