basalt-ui 1.23.1 → 1.25.0

package/dist/dashboard/query-state.js

@@ -0,0 +1,123 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Alert, Button, Center, Group, Loader, Stack, Text } from "@mantine/core";
+import { toErrorMessage } from "../query/error-message.js";
+import { EmptyState } from "./empty-state.js";
+function LoadingState({
+  variant = "page",
+  label = "Loading"
+}) {
+  const loader = /* @__PURE__ */ jsx(Loader, { size: "sm", "aria-label": label });
+  if (variant === "section") return loader;
+  return /* @__PURE__ */ jsx(Center, { py: 64, children: loader });
+}
+function ErrorState({
+  error,
+  title = "Something went wrong",
+  fallback = "The request failed.",
+  onRetry,
+  retrying = false,
+  variant = "page",
+  action
+}) {
+  const alert = /* @__PURE__ */ jsx(Alert, { color: "red", variant: "light", title, children: /* @__PURE__ */ jsxs(Stack, { gap: "sm", children: [
+    /* @__PURE__ */ jsx(Text, { size: "sm", children: toErrorMessage(error, fallback) }),
+    (onRetry ?? action) !== void 0 && /* @__PURE__ */ jsxs(Group, { gap: "xs", children: [
+      onRetry && /* @__PURE__ */ jsx(Button, { size: "xs", variant: "default", loading: retrying, onClick: onRetry, children: "Retry" }),
+      action
+    ] })
+  ] }) });
+  if (variant === "section") return alert;
+  return /* @__PURE__ */ jsx(Stack, { py: "md", children: alert });
+}
+function defaultIsEmpty(data) {
+  if (data === null || data === void 0) return true;
+  if (Array.isArray(data)) return data.length === 0;
+  if (typeof data === "object" && Array.isArray(data.data)) {
+    return data.data.length === 0;
+  }
+  return false;
+}
+const FETCH_STATUSES = /* @__PURE__ */ new Set(["fetching", "paused", "idle"]);
+function assertQueryStateLike(query) {
+  const bad = (detail) => {
+    throw new Error(
+      `QueryState: \`query\` ${detail}. It must carry { data, isError, error, fetchStatus, refetch } \u2014 a TanStack UseQueryResult does; a hand-composed one must spell every field, because a missing branch flag renders a false claim about the data instead of an error.`
+    );
+  };
+  if (query === null || typeof query !== "object")
+    bad(`is ${query === null ? "null" : typeof query}`);
+  const q = query;
+  if (!("data" in q)) bad("has no `data` key");
+  if (typeof q["isError"] !== "boolean") bad("has no boolean `isError`");
+  if (typeof q["fetchStatus"] !== "string" || !FETCH_STATUSES.has(q["fetchStatus"]))
+    bad(`has fetchStatus=${JSON.stringify(q["fetchStatus"])}, not 'fetching' | 'paused' | 'idle'`);
+  if (typeof q["refetch"] !== "function") bad("has no `refetch()`");
+}
+function QueryState({
+  query,
+  children,
+  empty,
+  isEmpty,
+  errorTitle = "Could not load",
+  errorFallback = "The request failed.",
+  errorAction,
+  variant = "page",
+  loading
+}) {
+  assertQueryStateLike(query);
+  const { data, isError, error, fetchStatus } = query;
+  const retrying = fetchStatus === "fetching";
+  const retry = () => void query.refetch();
+  if (isError && data === void 0) {
+    return /* @__PURE__ */ jsx(
+      ErrorState,
+      {
+        error,
+        title: errorTitle,
+        fallback: errorFallback,
+        onRetry: retry,
+        retrying,
+        variant,
+        ...errorAction !== void 0 && { action: errorAction }
+      }
+    );
+  }
+  if (data === void 0) {
+    if (fetchStatus === "idle" && !isError) return empty ? renderEmpty(empty, variant) : null;
+    return loading ?? /* @__PURE__ */ jsx(LoadingState, { variant });
+  }
+  const emptyNow = isEmpty ? isEmpty(data) : defaultIsEmpty(data);
+  const body = emptyNow ? empty ? renderEmpty(empty, variant) : null : typeof children === "function" ? children(data) : children;
+  if (!isError) return body;
+  return /* @__PURE__ */ jsxs(Stack, { gap: "sm", children: [
+    /* @__PURE__ */ jsx(
+      ErrorState,
+      {
+        error,
+        title: "Showing cached data",
+        fallback: "The last refresh failed.",
+        onRetry: retry,
+        retrying,
+        variant: "section"
+      }
+    ),
+    body
+  ] });
+}
+function renderEmpty(empty, variant) {
+  return /* @__PURE__ */ jsx(
+    EmptyState,
+    {
+      title: empty.title,
+      variant,
+      ...empty.description !== void 0 && { description: empty.description },
+      ...empty.icon !== void 0 && { icon: empty.icon },
+      ...empty.action !== void 0 && { action: empty.action }
+    }
+  );
+}
+export {
+  ErrorState,
+  LoadingState,
+  QueryState
+};

package/dist/dashboard/query-state.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=query-state.test.d.ts.map

package/dist/dashboard/query-state.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-state.test.d.ts","sourceRoot":"","sources":["../../src/dashboard/query-state.test.tsx"],"names":[],"mappings":""}

package/dist/data/data-table.d.ts

@@ -1,5 +1,29 @@
-import type { ColumnDef, ColumnPinningState, PaginationState, SortingState } from '@tanstack/react-table';
+import type { MantineSpacing } from '@mantine/core';
+import type { ColumnDef, ColumnFiltersState, ColumnPinningState, PaginationState, RowData, SortingState } from '@tanstack/react-table';
 import type { ReactNode } from 'react';
+/** Horizontal alignment of a column's header AND its cells. */
+export type DataTableAlign = 'left' | 'center' | 'right';
+/**
+ * Alignment lives on the column def's `meta`, not on a parallel prop array, so it travels with the
+ * column it describes and survives reordering.
+ *
+ * Declared as a module augmentation of TanStack's own `ColumnMeta` so `meta: { aling: 'right' }` is
+ * a TYPE error (excess-property check on the object literal) rather than a silently ignored key —
+ * and a wrong VALUE (`'end'`, `'centre'`) throws at render. A misspelled alignment that quietly
+ * left-aligns a money column is the class of defect that looks correct in review.
+ */
+declare module '@tanstack/react-table' {
+    interface ColumnMeta<TData extends RowData, TValue> {
+        align?: DataTableAlign;
+        /**
+         * Opt OUT of the automatic mono-numeral cell style. The table applies it whenever the cell's
+         * raw value is a number — which is right for a plain figure and wrong for a numeric accessor
+         * whose `cell` renders its own chrome (a coloured `Text`, a `Badge`, a sparkline), because the
+         * `<td>`'s mono font then overrides what the cell asked for.
+         */
+        numeral?: boolean;
+    }
+}
 /** A single selectable option inside a {@link DataTableFacet}'s Select/MultiSelect. */
 export type DataTableFacetOption = {
     /** The raw filter value, compared against the column's stringified cell value. */
@@ -50,15 +74,43 @@ export type BasaltDataTableProps<T> = {
      */
     columns: ColumnDef<T, any>[];
     /**
-     * Enable column sorting via clickable headers.
+     * Enable column sorting via clickable headers. Client-side — the rows in `data` are what get
+     * reordered.
+     *
+     * Under `manualPagination` that is one page, so leaving this on without also passing
+     * `manualSorting` is a contract violation and throws in dev — see `manualPagination`.
      * @default true
      */
     enableSorting?: boolean;
-    /** Stripe alternate rows. Forwarded to Mantine `Table`. */
-    striped?: boolean;
+    /**
+     * Hand sorting to the server: the table stops reordering `data` locally and renders it in the
+     * order given, while the headers keep toggling `SortingState` and reporting it through
+     * `onSortingChange` — which is where you re-request the sorted page.
+     *
+     * This is the required companion to `manualPagination` whenever sort headers are live; without
+     * it a server-paginated table sorts one page and the "of N" bar presents that as a sort of all N.
+     * @default false
+     * @example
+     * <BasaltDataTable
+     *   data={page.rows}
+     *   columns={columns}
+     *   enablePagination
+     *   manualPagination
+     *   manualSorting
+     *   rowCount={page.total}
+     *   onSortingChange={(s) => refetch({ sort: s[0] })}
+     * />
+     */
+    manualSorting?: boolean;
+    /** Stripe alternate rows. Forwarded to Mantine `Table` — `'odd'`/`'even'` pick the phase. */
+    striped?: boolean | 'odd' | 'even';
     /** Highlight hovered rows. Forwarded to Mantine `Table`. */
     highlightOnHover?: boolean;
-    /** Rendered when `data` is empty. Falls back to a simple message when omitted. */
+    /**
+     * Rendered when no rows are VISIBLE — `data` is empty, or a filter/page matches none of it.
+     * Falls back to a simple message when omitted. (Before 1.25.0 this tracked `data.length` alone,
+     * so a search matching nothing rendered a blank `<tbody>` with no message at all.)
+     */
     emptyState?: ReactNode;
     /**
      * When true, renders skeleton placeholder rows instead of the empty-state branch.
@@ -117,6 +169,18 @@ export type BasaltDataTableProps<T> = {
      * facets={[{ columnId: 'department', label: 'Department', options: departmentOptions }]}
      */
     facets?: DataTableFacet[];
+    /** Called whenever the faceted column filters change — the seam for server-side faceting. */
+    onColumnFiltersChange?: (filters: ColumnFiltersState) => void;
+    /**
+     * Hand filtering to the server: the table stops narrowing `data` locally and renders every row
+     * given, while the search input and facets keep reporting through `onGlobalFilterChange` /
+     * `onColumnFiltersChange` — which is where you re-request the filtered page.
+     *
+     * Required alongside `manualPagination` whenever `enableGlobalFilter` or `facets` is set;
+     * without it the controls narrow one page while "of N" keeps counting the whole set.
+     * @default false
+     */
+    manualFiltering?: boolean;
     /**
      * Right-aligned toolbar slot (e.g. an "Export" button). Renders the toolbar row even when no
      * search input or facets are configured.
@@ -145,6 +209,21 @@ export type BasaltDataTableProps<T> = {
      * Disables local pagination slicing — pass the already-paginated page of `data` plus `rowCount`
      * (and optionally `pageCount`) for server-driven pagination. `onPaginationChange` is where you
      * fetch the next page.
+     *
+     * **It imposes a contract, enforced at render.** `data` is now one page, but the pagination bar
+     * says "Showing 1–25 of 412" — so every OTHER client-side control becomes a claim about 412 rows
+     * that it can only make about 25. Each has to be resolved explicitly, because only the call site
+     * knows whether the server does the work:
+     *
+     * - `rowCount` (or `pageCount`) must be given, or "of N" counts the page and the pager collapses
+     *   to a single page nobody can leave;
+     * - sorting must be handed over with `manualSorting`, or switched off with `enableSorting={false}`;
+     * - `enableGlobalFilter` / `facets`, if used, must be handed over with `manualFiltering`;
+     * - `enablePagination` must be on, or `manualPagination` is inert and the page renders as if it
+     *   were the whole table.
+     *
+     * Unresolved, each throws in dev and degrades to the honest render in production (no sort
+     * headers, no filter controls, no "of N") — never to the plausible wrong answer.
      * @default false
      * @example
      * <BasaltDataTable
@@ -173,13 +252,51 @@ export type BasaltDataTableProps<T> = {
     enablePinning?: boolean;
     /** Initial column-pinning state — which column ids stick to the left/right edge. */
     initialColumnPinning?: ColumnPinningState;
+    /**
+     * Caps the scrolling body (px number or CSS length) so a long table cannot blow a card out
+     * vertically — the header stays put and the rows scroll under it. Renders Mantine's
+     * `Table.ScrollContainer type="native"`, which is the same node the docs sanction as the raw
+     * escape for a bespoke table: the blessed lane and the escape hatch produce identical DOM, so
+     * adopting one does not contradict the other.
+     *
+     * `type="native"` is required rather than preferred: `ScrollArea`'s custom viewport is the
+     * positioning context a sticky `<thead>` resolves against, so the default `'scrollarea'` type
+     * pins the header to the page viewport instead of the table's box.
+     */
+    maxHeight?: number | string;
+    /**
+     * `min-width` below which the body scrolls horizontally. Setting either this or `maxHeight`
+     * turns on the scroll container; `maxHeight` alone implies `minWidth: 0`.
+     */
+    minWidth?: number | string;
+    /** Sticky header row. Pair with `maxHeight` to stick within the table rather than the page. */
+    stickyHeader?: boolean;
+    /** Offset for a sticky header sitting under a fixed app header (px number or CSS length). */
+    stickyHeaderOffset?: number | string;
+    /** Vertical cell padding. Forwarded to Mantine `Table`. */
+    verticalSpacing?: MantineSpacing;
+    /** Horizontal cell padding. Forwarded to Mantine `Table`. */
+    horizontalSpacing?: MantineSpacing;
+    /** Row separators. Forwarded to Mantine `Table`. @default true (Mantine's own default) */
+    withRowBorders?: boolean;
+    /**
+     * Outer table border. Turn it OFF for a table that already sits inside a `Card`/`ChartCard`,
+     * where the card owns the frame and a second one reads as a nested box.
+     * @default true
+     */
+    withTableBorder?: boolean;
 };
 /**
  * A sortable data table backed by TanStack Table and rendered with Mantine primitives.
  * Generic over `T` — column types are inferred from `ColumnDef<T>`.
  *
- * Sorting is local/client-side (no `any`). When `enableSorting` is `false` the table
- * is read-only. An `emptyState` node is rendered when `data` is empty.
+ * Sorting is local/client-side by default (no `any`); `manualSorting` hands it to the server.
+ * When `enableSorting` is `false` the table is read-only. An `emptyState` node is rendered
+ * whenever no rows are visible — empty `data`, or a filter that matches none of it.
+ *
+ * `manualPagination` imposes a contract on the rest of the props (see its docblock): every
+ * client-side control it would turn into a false claim about the unseen rows must be handed to the
+ * server or switched off, and an unresolved one throws in dev rather than misreporting.
  *
  * Toolbar (search + facets), pagination, and column pinning are opt-in chrome layered on top —
  * see the corresponding props below. None of them change rendering unless explicitly enabled.
@@ -194,5 +311,5 @@ export type BasaltDataTableProps<T> = {
  *   emptyState={<Text c="dimmed">No users found.</Text>}
  * />
  */
-export declare function BasaltDataTable<T>({ data, columns, enableSorting, striped, highlightOnHover, emptyState, isLoading, skeletonRows, initialSorting, onSortingChange, enableGlobalFilter, globalFilterPlaceholder, searchIcon, initialGlobalFilter, onGlobalFilterChange, facets, toolbarActions, enablePagination, pageSizeOptions, initialPagination, onPaginationChange, manualPagination, rowCount, pageCount, enablePinning, initialColumnPinning, }: BasaltDataTableProps<T>): import("react").JSX.Element;
+export declare function BasaltDataTable<T>({ data, columns, enableSorting, manualSorting, striped, highlightOnHover, emptyState, isLoading, skeletonRows, initialSorting, onSortingChange, enableGlobalFilter, globalFilterPlaceholder, searchIcon, initialGlobalFilter, onGlobalFilterChange, facets, onColumnFiltersChange, manualFiltering, toolbarActions, enablePagination, pageSizeOptions, initialPagination, onPaginationChange, manualPagination, rowCount, pageCount, enablePinning, initialColumnPinning, maxHeight, minWidth, stickyHeader, stickyHeaderOffset, verticalSpacing, horizontalSpacing, withRowBorders, withTableBorder, }: BasaltDataTableProps<T>): import("react").JSX.Element;
 //# sourceMappingURL=data-table.d.ts.map

package/dist/data/data-table.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"data-table.d.ts","sourceRoot":"","sources":["../../src/data/data-table.tsx"],"names":[],"mappings":"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"}
+{"version":3,"file":"data-table.d.ts","sourceRoot":"","sources":["../../src/data/data-table.tsx"],"names":[],"mappings":"AA4CA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AACnD,OAAO,KAAK,EAEV,SAAS,EACT,kBAAkB,EAClB,kBAAkB,EAElB,eAAe,EACf,OAAO,EACP,YAAY,EAGb,MAAM,uBAAuB,CAAA;AAS9B,OAAO,KAAK,EAAiB,SAAS,EAAE,MAAM,OAAO,CAAA;AAMrD,+DAA+D;AAC/D,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,QAAQ,GAAG,OAAO,CAAA;AAExD;;;;;;;;GAQG;AACH,OAAO,QAAQ,uBAAuB,CAAC;IAGrC,UAAU,UAAU,CAAC,KAAK,SAAS,OAAO,EAAE,MAAM;QAChD,KAAK,CAAC,EAAE,cAAc,CAAA;QACtB;;;;;WAKG;QACH,OAAO,CAAC,EAAE,OAAO,CAAA;KAClB;CACF;AAmBD,uFAAuF;AACvF,MAAM,MAAM,oBAAoB,GAAG;IACjC,kFAAkF;IAClF,KAAK,EAAE,MAAM,CAAA;IACb,sDAAsD;IACtD,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED;;;;;;;;;;GAUG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,sFAAsF;IACtF,QAAQ,EAAE,MAAM,CAAA;IAChB,yDAAyD;IACzD,KAAK,EAAE,MAAM,CAAA;IACb,yCAAyC;IACzC,OAAO,EAAE,oBAAoB,EAAE,CAAA;IAC/B,mGAAmG;IACnG,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB,CAAA;AAID;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,oBAAoB,CAAC,CAAC,IAAI;IACpC,sBAAsB;IACtB,IAAI,EAAE,CAAC,EAAE,CAAA;IACT;;;OAGG;IAKH,OAAO,EAAE,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAA;IAC5B;;;;;;;OAOG;IACH,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB;;;;;;;;;;;;;;;;;;OAkBG;IACH,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,6FAA6F;IAC7F,OAAO,CAAC,EAAE,OAAO,GAAG,KAAK,GAAG,MAAM,CAAA;IAClC,4DAA4D;IAC5D,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B;;;;OAIG;IACH,UAAU,CAAC,EAAE,SAAS,CAAA;IACtB;;;OAGG;IACH,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB;;;;;;;OAOG;IACH,cAAc,CAAC,EAAE,YAAY,CAAA;IAC7B;;;OAGG;IACH,eAAe,CAAC,EAAE,CAAC,OAAO,EAAE,YAAY,KAAK,IAAI,CAAA;IAIjD;;;;;;OAMG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAA;IAC5B;;;OAGG;IACH,uBAAuB,CAAC,EAAE,MAAM,CAAA;IAChC;;;OAGG;IACH,UAAU,CAAC,EAAE,SAAS,CAAA;IACtB;;;OAGG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAA;IAC5B,gEAAgE;IAChE,oBAAoB,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IAC9C;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,cAAc,EAAE,CAAA;IACzB,6FAA6F;IAC7F,qBAAqB,CAAC,EAAE,CAAC,OAAO,EAAE,kBAAkB,KAAK,IAAI,CAAA;IAC7D;;;;;;;;OAQG;IACH,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB;;;OAGG;IACH,cAAc,CAAC,EAAE,SAAS,CAAA;IAI1B;;;;;OAKG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,EAAE,CAAA;IAC1B;;;OAGG;IACH,iBAAiB,CAAC,EAAE,eAAe,CAAA;IACnC,6DAA6D;IAC7D,kBAAkB,CAAC,EAAE,CAAC,UAAU,EAAE,eAAe,KAAK,IAAI,CAAA;IAC1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B,iHAAiH;IACjH,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,2HAA2H;IAC3H,SAAS,CAAC,EAAE,MAAM,CAAA;IAIlB;;;;;;;OAOG;IACH,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,oFAAoF;IACpF,oBAAoB,CAAC,EAAE,kBAAkB,CAAA;IAIzC;;;;;;;;;;OAUG;IACH,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IAC3B;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IAC1B,+FAA+F;IAC/F,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,6FAA6F;IAC7F,kBAAkB,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IACpC,2DAA2D;IAC3D,eAAe,CAAC,EAAE,cAAc,CAAA;IAChC,6DAA6D;IAC7D,iBAAiB,CAAC,EAAE,cAAc,CAAA;IAClC,0FAA0F;IAC1F,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB;;;;OAIG;IACH,eAAe,CAAC,EAAE,OAAO,CAAA;CAC1B,CAAA;AAiLD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,EACjC,IAAI,EACJ,OAAO,EACP,aAAoB,EACpB,aAAqB,EACrB,OAAO,EACP,gBAAgB,EAChB,UAAU,EACV,SAAiB,EACjB,YAAgB,EAChB,cAAc,EACd,eAAe,EACf,kBAA0B,EAC1B,uBAAmC,EACnC,UAAU,EACV,mBAAmB,EACnB,oBAAoB,EACpB,MAAM,EACN,qBAAqB,EACrB,eAAuB,EACvB,cAAc,EACd,gBAAwB,EACxB,eAA2C,EAC3C,iBAAiB,EACjB,kBAAkB,EAClB,gBAAwB,EACxB,QAAQ,EACR,SAAS,EACT,aAAqB,EACrB,oBAAoB,EACpB,SAAS,EACT,QAAQ,EACR,YAAY,EACZ,kBAAkB,EAClB,eAAe,EACf,iBAAiB,EACjB,cAAc,EACd,eAAsB,GACvB,EAAE,oBAAoB,CAAC,CAAC,CAAC,+BAuXzB"}

package/dist/data/data-table.js

@@ -20,6 +20,17 @@ import {
 } from "@tanstack/react-table";
 import { useCallback, useMemo, useState } from "react";
 import { alpha, VX } from "../tokens/index.js";
+const ALIGNMENTS = /* @__PURE__ */ new Set(["left", "center", "right"]);
+function resolveAlign(column) {
+  const align = column.columnDef.meta?.align;
+  if (align === void 0) return void 0;
+  if (!ALIGNMENTS.has(align)) {
+    throw new Error(
+      `BasaltDataTable: column "${column.id}" has meta.align=${JSON.stringify(align)} \u2014 expected 'left' | 'center' | 'right'.`
+    );
+  }
+  return align;
+}
 function SortIndicator({ direction }) {
   if (!direction) return null;
   return /* @__PURE__ */ jsx(Box, { component: "span", ml: 4, "aria-hidden": true, children: direction === "asc" ? "\u2191" : "\u2193" });
@@ -74,10 +85,43 @@ function getPinnedCellStyle(table, column) {
     boxShadow: isEdge ? `-4px 0 6px -4px ${alpha(VX.ink, 0.18)}` : void 0
   };
 }
+function isDev() {
+  return process.env["NODE_ENV"] !== "production";
+}
+const BREACH_REMEDY = {
+  inert: "`enablePagination` is not set, so `manualPagination` never reaches the table and the server page renders as if it were the whole set, with no bar to say otherwise. Pass `enablePagination`, or drop `manualPagination`.",
+  total: 'neither `rowCount` nor `pageCount` was given, so "of N" counts only the rows on this page and the pager collapses to one page nobody can leave. Pass `rowCount={total}`.',
+  sorting: 'client-side sorting is still armed. It reorders only the rows in `data` \u2014 one page \u2014 while the header chevron and "of N" together present it as a sort of all of them. Pass `manualSorting` and sort in the request you make from `onSortingChange`, or `enableSorting={false}`.',
+  filtering: 'the search input / facets still filter client-side. They narrow only the rows in `data` \u2014 one page \u2014 while "of N" keeps counting the whole set. Pass `manualFiltering` and filter in the request you make from `onGlobalFilterChange` / `onColumnFiltersChange`, or drop `enableGlobalFilter` / `facets`.'
+};
+function manualPaginationBreaches(config) {
+  if (!config.manualPagination) return [];
+  if (!config.enablePagination) return ["inert"];
+  const breaches = [];
+  if (config.rowCount === void 0 && config.pageCount === void 0) breaches.push("total");
+  const anyColumnMaySort = config.columns.some((column) => column.enableSorting !== false);
+  if (config.enableSorting && anyColumnMaySort && !config.manualSorting) breaches.push("sorting");
+  if ((config.enableGlobalFilter || config.hasFacets) && !config.manualFiltering)
+    breaches.push("filtering");
+  return breaches;
+}
+function manualPaginationMessage(breaches) {
+  return "BasaltDataTable: `manualPagination` is set, so `data` is one server page \u2014 but:\n  \xB7 " + breaches.map((breach) => BREACH_REMEDY[breach]).join("\n  \xB7 ") + "\nEach has to be resolved explicitly: only the call site knows whether the server does the work, so there is no default that is not a guess about the data.";
+}
+const reportedBreaches = /* @__PURE__ */ new Set();
+function enforceManualPaginationContract(breaches) {
+  if (breaches.length === 0) return;
+  const message = manualPaginationMessage(breaches);
+  if (isDev()) throw new Error(message);
+  if (reportedBreaches.has(message)) return;
+  reportedBreaches.add(message);
+  console.error(message);
+}
 function BasaltDataTable({
   data,
   columns,
   enableSorting = true,
+  manualSorting = false,
   striped,
   highlightOnHover,
   emptyState,
@@ -91,6 +135,8 @@ function BasaltDataTable({
   initialGlobalFilter,
   onGlobalFilterChange,
   facets,
+  onColumnFiltersChange,
+  manualFiltering = false,
   toolbarActions,
   enablePagination = false,
   pageSizeOptions = DEFAULT_PAGE_SIZE_OPTIONS,
@@ -100,7 +146,15 @@ function BasaltDataTable({
   rowCount,
   pageCount,
   enablePinning = false,
-  initialColumnPinning
+  initialColumnPinning,
+  maxHeight,
+  minWidth,
+  stickyHeader,
+  stickyHeaderOffset,
+  verticalSpacing,
+  horizontalSpacing,
+  withRowBorders,
+  withTableBorder = true
 }) {
   const [sorting, setSorting] = useState(initialSorting ?? []);
   const [globalFilter, setGlobalFilter] = useState(initialGlobalFilter ?? "");
@@ -129,6 +183,16 @@ function BasaltDataTable({
     },
     [onGlobalFilterChange]
   );
+  const handleColumnFiltersChange = useCallback(
+    (updater) => {
+      setColumnFilters((prev) => {
+        const next = typeof updater === "function" ? updater(prev) : updater;
+        onColumnFiltersChange?.(next);
+        return next;
+      });
+    },
+    [onColumnFiltersChange]
+  );
   const handlePaginationChange = useCallback(
     (updater) => {
       setPagination((prev) => {
@@ -151,6 +215,23 @@ function BasaltDataTable({
       return { ...column, filterFn };
     });
   }, [columns, facets]);
+  const hasFacets = Boolean(facets && facets.length > 0);
+  const breaches = manualPaginationBreaches({
+    columns,
+    enablePagination,
+    manualPagination,
+    rowCount,
+    pageCount,
+    enableSorting,
+    manualSorting,
+    enableGlobalFilter,
+    hasFacets,
+    manualFiltering
+  });
+  enforceManualPaginationContract(breaches);
+  const sortingEnabled = enableSorting && !breaches.includes("sorting");
+  const filteringEnabled = !breaches.includes("filtering");
+  const totalIsAuthoritative = !breaches.includes("total");
   const table = useReactTable({
     data,
     columns: tableColumns,
@@ -163,35 +244,51 @@ function BasaltDataTable({
     },
     onSortingChange: handleSortingChange,
     onGlobalFilterChange: handleGlobalFilterChange,
-    onColumnFiltersChange: setColumnFilters,
+    onColumnFiltersChange: handleColumnFiltersChange,
     onColumnPinningChange: setColumnPinning,
     ...enablePagination && { onPaginationChange: handlePaginationChange },
     getCoreRowModel: getCoreRowModel(),
     getSortedRowModel: getSortedRowModel(),
     getFilteredRowModel: getFilteredRowModel(),
+    // Both row models stay installed and are BYPASSED by these flags, which is TanStack's own
+    // seam — so a degraded table renders `data` in the order and completeness the server sent it.
+    // Forced only by a BREACH, never by `enableSorting={false}` on its own: that pair still applies
+    // an `initialSorting` today (it disables the header control, not the row model) and a table
+    // that is not misreporting has no business losing it.
+    manualSorting: manualSorting || breaches.includes("sorting"),
+    manualFiltering: manualFiltering || breaches.includes("filtering"),
     ...enablePagination && {
       getPaginationRowModel: getPaginationRowModel(),
       manualPagination,
       ...manualPagination && rowCount !== void 0 && { rowCount },
       ...manualPagination && pageCount !== void 0 && { pageCount }
     },
-    enableSorting,
+    enableSorting: sortingEnabled,
     enableColumnPinning: enablePinning
   });
-  const showToolbar = enableGlobalFilter || Boolean(facets && facets.length > 0) || Boolean(toolbarActions);
+  const showSearch = enableGlobalFilter && filteringEnabled;
+  const showFacets = hasFacets && filteringEnabled;
+  const showToolbar = showSearch || showFacets || Boolean(toolbarActions);
   const headerGroups = enablePinning ? getOrderedHeaderGroups(table) : table.getHeaderGroups();
+  const rows = table.getRowModel().rows;
   const tableNode = /* @__PURE__ */ jsxs(
     Table,
     {
       ...striped !== void 0 && { striped },
       ...highlightOnHover !== void 0 && { highlightOnHover },
-      withTableBorder: true,
+      ...stickyHeader !== void 0 && { stickyHeader },
+      ...stickyHeaderOffset !== void 0 && { stickyHeaderOffset },
+      ...verticalSpacing !== void 0 && { verticalSpacing },
+      ...horizontalSpacing !== void 0 && { horizontalSpacing },
+      ...withRowBorders !== void 0 && { withRowBorders },
+      withTableBorder,
       children: [
         /* @__PURE__ */ jsx(Table.Thead, { children: headerGroups.map((headerGroup) => /* @__PURE__ */ jsx(Table.Tr, { children: headerGroup.headers.map((header) => {
-          const canSort = enableSorting && header.column.getCanSort();
+          const canSort = sortingEnabled && header.column.getCanSort();
           const sorted = header.column.getIsSorted();
           const toggleSorting = header.column.getToggleSortingHandler();
           const pinnedStyle = enablePinning ? getPinnedCellStyle(table, header.column) : void 0;
+          const align = resolveAlign(header.column);
           return /* @__PURE__ */ jsxs(
             Table.Th,
             {
@@ -205,6 +302,7 @@ function BasaltDataTable({
               "aria-sort": canSort ? sorted === "asc" ? "ascending" : sorted === "desc" ? "descending" : "none" : void 0,
               style: {
                 ...canSort ? { cursor: "pointer", userSelect: "none" } : void 0,
+                ...align !== void 0 && { textAlign: align },
                 ...pinnedStyle
               },
               children: [
@@ -215,7 +313,7 @@ function BasaltDataTable({
             header.id
           );
         }) }, headerGroup.id)) }),
-        /* @__PURE__ */ jsx(Table.Tbody, { children: isLoading ? Array.from({ length: skeletonRows }, (_, rowIndex) => /* @__PURE__ */ jsx(Table.Tr, { children: columns.map((_2, colIndex) => /* @__PURE__ */ jsx(Table.Td, { children: /* @__PURE__ */ jsx(Skeleton, { height: 16, radius: "sm" }) }, `skeleton-${rowIndex}-${colIndex}`)) }, `skeleton-${rowIndex}`)) : data.length === 0 ? /* @__PURE__ */ jsx(Table.Tr, { children: /* @__PURE__ */ jsx(Table.Td, { colSpan: columns.length, children: emptyState ?? /* @__PURE__ */ jsx(Text, { c: "dimmed", ta: "center", size: "sm", py: "sm", children: "No data to display." }) }) }) : table.getRowModel().rows.map((row) => {
+        /* @__PURE__ */ jsx(Table.Tbody, { children: isLoading ? Array.from({ length: skeletonRows }, (_, rowIndex) => /* @__PURE__ */ jsx(Table.Tr, { children: columns.map((_2, colIndex) => /* @__PURE__ */ jsx(Table.Td, { children: /* @__PURE__ */ jsx(Skeleton, { height: 16, radius: "sm" }) }, `skeleton-${rowIndex}-${colIndex}`)) }, `skeleton-${rowIndex}`)) : rows.length === 0 ? /* @__PURE__ */ jsx(Table.Tr, { children: /* @__PURE__ */ jsx(Table.Td, { colSpan: columns.length, children: emptyState ?? /* @__PURE__ */ jsx(Text, { c: "dimmed", ta: "center", size: "sm", py: "sm", children: "No data to display." }) }) }) : rows.map((row) => {
           const cells = enablePinning ? [
             ...row.getLeftVisibleCells(),
             ...row.getCenterVisibleCells(),
@@ -223,11 +321,13 @@ function BasaltDataTable({
           ] : row.getVisibleCells();
           return /* @__PURE__ */ jsx(Table.Tr, { children: cells.map((cell) => {
             const pinnedStyle = enablePinning ? getPinnedCellStyle(table, cell.column) : void 0;
+            const align = resolveAlign(cell.column);
             return /* @__PURE__ */ jsx(
               Table.Td,
               {
                 style: {
-                  ...typeof cell.getValue() === "number" ? NUMERIC_CELL_STYLE : void 0,
+                  ...typeof cell.getValue() === "number" && cell.column.columnDef.meta?.numeral !== false ? NUMERIC_CELL_STYLE : void 0,
+                  ...align !== void 0 && { textAlign: align },
                   ...pinnedStyle
                 },
                 children: flexRender(cell.column.columnDef.cell, cell.getContext())
@@ -239,6 +339,7 @@ function BasaltDataTable({
       ]
     }
   );
+  const scrolls = maxHeight !== void 0 || minWidth !== void 0;
   const paginationState = table.getState().pagination;
   const total = table.getRowCount();
   const rangeStart = total === 0 ? 0 : paginationState.pageIndex * paginationState.pageSize + 1;
@@ -246,7 +347,7 @@ function BasaltDataTable({
   return /* @__PURE__ */ jsxs(Fragment, { children: [
     showToolbar && /* @__PURE__ */ jsxs(Group, { justify: "space-between", align: "flex-end", wrap: "wrap", gap: "xs", mb: "xs", children: [
       /* @__PURE__ */ jsxs(Group, { gap: "xs", wrap: "wrap", align: "flex-end", children: [
-        enableGlobalFilter && /* @__PURE__ */ jsx(
+        showSearch && /* @__PURE__ */ jsx(
           TextInput,
           {
             size: "xs",
@@ -258,7 +359,7 @@ function BasaltDataTable({
             w: 220
           }
         ),
-        facets?.map((facet) => {
+        showFacets && facets?.map((facet) => {
           const column = table.getColumn(facet.columnId);
           if (!column) return null;
           if (facet.multiple) {
@@ -297,15 +398,22 @@ function BasaltDataTable({
       ] }),
       toolbarActions
     ] }),
-    enablePinning ? /* @__PURE__ */ jsx(Box, { style: { overflowX: "auto" }, children: tableNode }) : tableNode,
+    scrolls ? /* @__PURE__ */ jsx(
+      Table.ScrollContainer,
+      {
+        type: "native",
+        minWidth: minWidth ?? 0,
+        ...maxHeight !== void 0 && { maxHeight },
+        children: tableNode
+      }
+    ) : enablePinning ? /* @__PURE__ */ jsx(Box, { style: { overflowX: "auto" }, children: tableNode }) : tableNode,
     enablePagination && /* @__PURE__ */ jsxs(Group, { justify: "space-between", mt: "xs", wrap: "wrap", gap: "xs", align: "center", children: [
       /* @__PURE__ */ jsxs(Text, { style: RANGE_LABEL_STYLE, children: [
         "Showing ",
         rangeStart,
         "\u2013",
         rangeEnd,
-        " of ",
-        total
+        totalIsAuthoritative ? ` of ${total}` : ""
       ] }),
       /* @__PURE__ */ jsxs(Group, { gap: "xs", align: "center", children: [
         /* @__PURE__ */ jsx(

package/dist/data/data-table.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data-table.test.d.ts.map

package/dist/data/data-table.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-table.test.d.ts","sourceRoot":"","sources":["../../src/data/data-table.test.tsx"],"names":[],"mappings":""}

package/dist/data/table.d.ts

@@ -19,6 +19,6 @@
  * <BasaltDataTable data={rows} columns={columns} enableGlobalFilter enablePagination />
  */
 export { BasaltDataTable } from './data-table.js';
-export type { BasaltDataTableProps, DataTableFacet, DataTableFacetOption } from './data-table.js';
-export { createColumnHelper, useReactTable, flexRender, getCoreRowModel, getSortedRowModel, getFilteredRowModel, getPaginationRowModel, type ColumnDef, type SortingState, type ColumnHelper, type PaginationState, type ColumnPinningState, } from '@tanstack/react-table';
+export type { BasaltDataTableProps, DataTableAlign, DataTableFacet, DataTableFacetOption, } from './data-table.js';
+export { createColumnHelper, useReactTable, flexRender, getCoreRowModel, getSortedRowModel, getFilteredRowModel, getPaginationRowModel, type ColumnDef, type SortingState, type ColumnHelper, type PaginationState, type ColumnPinningState, type ColumnFiltersState, } from '@tanstack/react-table';
 //# sourceMappingURL=table.d.ts.map

package/dist/data/table.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"table.d.ts","sourceRoot":"","sources":["../../src/data/table.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAC9C,YAAY,EAAE,oBAAoB,EAAE,cAAc,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAA;AAS9F,OAAO,EACL,kBAAkB,EAClB,aAAa,EACb,UAAU,EACV,eAAe,EACf,iBAAiB,EACjB,mBAAmB,EACnB,qBAAqB,EACrB,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,eAAe,EACpB,KAAK,kBAAkB,GACxB,MAAM,uBAAuB,CAAA"}
+{"version":3,"file":"table.d.ts","sourceRoot":"","sources":["../../src/data/table.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAC9C,YAAY,EACV,oBAAoB,EACpB,cAAc,EACd,cAAc,EACd,oBAAoB,GACrB,MAAM,cAAc,CAAA;AASrB,OAAO,EACL,kBAAkB,EAClB,aAAa,EACb,UAAU,EACV,eAAe,EACf,iBAAiB,EACjB,mBAAmB,EACnB,qBAAqB,EACrB,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,eAAe,EACpB,KAAK,kBAAkB,EAEvB,KAAK,kBAAkB,GACxB,MAAM,uBAAuB,CAAA"}

package/dist/guard/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/guard/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/guard/index.ts"],"names":[],"mappings":"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"}