basalt-ui 1.27.0 → 1.28.0

package/dist/dashboard/stat-group.module.css

@@ -0,0 +1,66 @@
+/*
+ * StatGroup's column law and its optional rail, in CSS (law C9). The literals are Mantine's
+ * `--mantine-breakpoint-sm` (48em) and `--mantine-breakpoint-lg` (75em) — a `@media` condition
+ * cannot read a custom property, so the number has to be written; the COUNTS are custom properties
+ * the component sets per instance.
+ */
+
+.root {
+  display: grid;
+  /* Two KPIs abreast on a phone, never one: a KPI is a short pre-formatted number, and a single
+     column turns a four-metric row into four screens of scrolling. */
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: var(--vx-space-stack-md);
+}
+
+@media (min-width: 48em) {
+  .root {
+    grid-template-columns: repeat(var(--basalt-stat-group-cols-sm), minmax(0, 1fr));
+  }
+}
+
+@media (min-width: 75em) {
+  .root {
+    grid-template-columns: repeat(var(--basalt-stat-group-cols-lg), minmax(0, 1fr));
+  }
+}
+
+/*
+ * The rail. `column-gap: 0` and one hairline per cell, suppressed on whichever cell LEADS a row —
+ * which is why the three blocks below are bounded to mutually EXCLUSIVE ranges rather than stacked
+ * `min-width` ones. `:nth-child(3n + 1)` is more specific than the `[data-divided] > *` that draws the
+ * border, so an open-ended `sm` block would keep suppressing the wrong cells once `lg` took over.
+ */
+.root[data-divided] {
+  column-gap: 0;
+}
+
+.root[data-divided] > * {
+  border-inline-start: 1px solid var(--vx-divider);
+  padding-inline-start: var(--vx-space-stack-md);
+}
+
+@media (max-width: 47.99375em) {
+  .root[data-divided] > *:nth-child(2n + 1) {
+    border-inline-start: 0;
+    padding-inline-start: 0;
+  }
+}
+
+@media (min-width: 48em) and (max-width: 74.99375em) {
+  .root[data-divided][data-sm-cols='2'] > *:nth-child(2n + 1),
+  .root[data-divided][data-sm-cols='3'] > *:nth-child(3n + 1) {
+    border-inline-start: 0;
+    padding-inline-start: 0;
+  }
+}
+
+@media (min-width: 75em) {
+  .root[data-divided][data-cols='2'] > *:nth-child(2n + 1),
+  .root[data-divided][data-cols='3'] > *:nth-child(3n + 1),
+  .root[data-divided][data-cols='4'] > *:nth-child(4n + 1),
+  .root[data-divided][data-cols='5'] > *:nth-child(5n + 1) {
+    border-inline-start: 0;
+    padding-inline-start: 0;
+  }
+}

package/dist/dashboard/stat-group.module.css.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Typed CSS-module declaration (the S4 CSS-modules path). Named string props — not an index
+ * signature — so dot access stays verbatim under the package's strict flags.
+ */
+declare const classes: {
+  readonly root: string
+}
+export default classes

package/dist/dashboard/widget-grid.d.ts

@@ -0,0 +1,27 @@
+import type { ReactNode } from 'react';
+import type { BasaltProps } from '../common/props.js';
+/** The desktop column count. Four is the ceiling: a fifth widget column is a KPI row — `StatGroup`. */
+export type WidgetGridCols = 1 | 2 | 3 | 4;
+export type WidgetGridProps = BasaltProps & {
+    /** The DESKTOP column count (`lg` and up). Default `2`. Below that the law resolves it: `sm` gets
+     * `min(cols, 2)`, a phone gets 1. Never a responsive object — see the module docblock. */
+    cols?: WidgetGridCols;
+    /** The widgets. A plain child takes one column; wrap it in `WidgetGrid.Item` to span more. */
+    children: ReactNode;
+};
+export declare function WidgetGrid({ cols, children, className, style }: WidgetGridProps): import("react").JSX.Element;
+export declare namespace WidgetGrid {
+    var Item: typeof WidgetGridItem;
+}
+export type WidgetGridItemProps = BasaltProps & {
+    /** The DESKTOP span, clamped to the live column count at every narrower breakpoint. Default `1`. */
+    span?: WidgetGridCols;
+    /** The one widget this cell holds. */
+    children: ReactNode;
+};
+/**
+ * One cell of a {@link WidgetGrid}, spanning more than one column. Reached as `WidgetGrid.Item`.
+ */
+declare function WidgetGridItem({ span, children, className, style }: WidgetGridItemProps): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=widget-grid.d.ts.map

package/dist/dashboard/widget-grid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"widget-grid.d.ts","sourceRoot":"","sources":["../../src/dashboard/widget-grid.tsx"],"names":[],"mappings":"AA4CA,OAAO,KAAK,EAAiB,SAAS,EAAE,MAAM,OAAO,CAAA;AAErD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAGlD,uGAAuG;AACvG,MAAM,MAAM,cAAc,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;AAgB1C,MAAM,MAAM,eAAe,GAAG,WAAW,GAAG;IAC1C;8FAC0F;IAC1F,IAAI,CAAC,EAAE,cAAc,CAAA;IACrB,8FAA8F;IAC9F,QAAQ,EAAE,SAAS,CAAA;CACpB,CAAA;AAED,wBAAgB,UAAU,CAAC,EAAE,IAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,KAAK,EAAE,EAAE,eAAe,+BAoBnF;yBApBe,UAAU;;;AAsB1B,MAAM,MAAM,mBAAmB,GAAG,WAAW,GAAG;IAC9C,oGAAoG;IACpG,IAAI,CAAC,EAAE,cAAc,CAAA;IACrB,sCAAsC;IACtC,QAAQ,EAAE,SAAS,CAAA;CACpB,CAAA;AAED;;GAEG;AACH,iBAAS,cAAc,CAAC,EAAE,IAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,KAAK,EAAE,EAAE,mBAAmB,+BAkBpF"}

package/dist/dashboard/widget-grid.js

@@ -0,0 +1,41 @@
+import { jsx } from "react/jsx-runtime";
+import { createContext, useContext, useMemo } from "react";
+import { cx } from "../common/props.js";
+import classes from "./widget-grid.module.css";
+const WidgetGridColsContext = createContext({ sm: 2, lg: 2 });
+function WidgetGrid({ cols = 2, children, className, style }) {
+  const resolved = useMemo(() => ({ sm: Math.min(cols, 2), lg: cols }), [cols]);
+  return /* @__PURE__ */ jsx(WidgetGridColsContext.Provider, { value: resolved, children: /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: cx(classes.root, className),
+      "data-cols": cols,
+      style: {
+        "--basalt-widget-grid-cols-sm": resolved.sm,
+        "--basalt-widget-grid-cols-lg": resolved.lg,
+        ...style
+      },
+      children
+    }
+  ) });
+}
+function WidgetGridItem({ span = 1, children, className, style }) {
+  const cols = useContext(WidgetGridColsContext);
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: cx(classes.item, className),
+      "data-span": span,
+      style: {
+        "--basalt-widget-grid-span-sm": Math.min(span, cols.sm),
+        "--basalt-widget-grid-span-lg": Math.min(span, cols.lg),
+        ...style
+      },
+      children
+    }
+  );
+}
+WidgetGrid.Item = WidgetGridItem;
+export {
+  WidgetGrid
+};

package/dist/dashboard/widget-grid.module.css

@@ -0,0 +1,53 @@
+/*
+ * WidgetGrid's column law, in CSS (law C9 — a responsive swap belongs to the control, never to a JS
+ * media query). The two literals below are Mantine's own `--mantine-breakpoint-sm` (48em) and
+ * `--mantine-breakpoint-lg` (75em); a `@media` condition is resolved before custom properties
+ * exist, so the number has to be written — same standing constraint `content/article-layout.
+ * module.css` documents.
+ *
+ * The COUNTS are custom properties instead, set once per instance by the component: three
+ * hand-written `repeat()` blocks would have to enumerate every `cols` value, and the whole point of
+ * this primitive is that a consumer states one desktop number and basalt owns the rest.
+ */
+
+.root {
+  display: grid;
+  /* Below `sm` a widget column is always 1 — a dashboard card holds a chart, and two of them on a
+     phone is two unreadable charts. */
+  grid-template-columns: repeat(1, minmax(0, 1fr));
+  gap: var(--vx-space-stack-md);
+}
+
+@media (min-width: 48em) {
+  .root {
+    grid-template-columns: repeat(var(--basalt-widget-grid-cols-sm), minmax(0, 1fr));
+  }
+}
+
+@media (min-width: 75em) {
+  .root {
+    grid-template-columns: repeat(var(--basalt-widget-grid-cols-lg), minmax(0, 1fr));
+  }
+}
+
+/*
+ * `min-width: 0` on every cell: a grid track's default `min-width: auto` is its content's intrinsic
+ * width, so one wide `<table>` or one long unbroken value blows the whole row out instead of
+ * scrolling inside its own card.
+ */
+.item {
+  grid-column: span 1;
+  min-width: 0;
+}
+
+@media (min-width: 48em) {
+  .item {
+    grid-column: span var(--basalt-widget-grid-span-sm);
+  }
+}
+
+@media (min-width: 75em) {
+  .item {
+    grid-column: span var(--basalt-widget-grid-span-lg);
+  }
+}

package/dist/dashboard/widget-grid.module.css.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Typed CSS-module declaration (the S4 CSS-modules path). Named string props — not an index
+ * signature — so dot access stays verbatim under the package's strict flags.
+ */
+declare const classes: {
+  readonly root: string
+  readonly item: string
+}
+export default classes

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

@@ -1,6 +1,9 @@
 import type { MantineSpacing } from '@mantine/core';
-import type { ColumnDef, ColumnFiltersState, ColumnPinningState, PaginationState, RowData, SortingState } from '@tanstack/react-table';
+import type { ColumnDef, ColumnFiltersState, PaginationState, RowData, RowSelectionState, SortingState } from '@tanstack/react-table';
 import type { ReactNode } from 'react';
+import type { BasaltProps, SlotStylesProps } from '../common/props.js';
+import type { BarAction, SlotActions } from '../controls/actions.js';
+import type { QueryStateLike } from '../dashboard/query-state.js';
 /** Horizontal alignment of a column's header AND its cells. */
 export type DataTableAlign = 'left' | 'center' | 'right';
 /**
@@ -31,20 +34,29 @@ export type DataTableFacetOption = {
     /** Label shown in the pill's popover. */
     label: string;
 };
+/**
+ * A TanStack column id typed off the row shape `T` where `accessor`/manual `id` inference allows
+ * it — `Extract<keyof T, string>` for a real field name, widened by `(string & {})` so a
+ * synthetic/derived column id (no matching key on `T`) still type-checks. Defaults to `unknown` so
+ * a bare `DataTableFacet[]` / `DataTableColumnPinning` (no type argument) keeps working exactly as
+ * before. Shared by {@link DataTableFacet}'s `columnId` and {@link DataTableColumnPinning}'s
+ * `left`/`right`.
+ */
+export type DataTableColumnId<T = unknown> = Extract<keyof T, string> | (string & {});
 /**
  * Declares one faceted column filter, rendered as an `EnumFilter` pill (or `MultiSelectFilter`
  * when `multiple` is set) inside a `FilterSet` in the toolbar (`docs/CONTROLS-SPEC.md` §3).
  *
  * @example
- * const facets: DataTableFacet[] = [
+ * const facets: DataTableFacet<Employee>[] = [
  *   { columnId: 'department', label: 'Department', options: [{ value: 'Engineering', label: 'Engineering' }] },
  *   { columnId: 'role', label: 'Role', multiple: true, options: roleOptions },
  * ]
  * <BasaltDataTable data={rows} columns={columns} facets={facets} />
  */
-export type DataTableFacet = {
+export type DataTableFacet<T = unknown> = {
     /** The TanStack column id — the column's manual `id`, or its `accessorKey` string. */
-    columnId: string;
+    columnId: DataTableColumnId<T>;
     /** The pill's label — read at rest (single-select) and as the `Filters`/count fallback (multi). */
     label: string;
     /** Selectable options for this facet. */
@@ -52,6 +64,22 @@ export type DataTableFacet = {
     /** Render a `MultiSelectFilter` (any-of match) instead of an `EnumFilter` (exact match). @default false */
     multiple?: boolean;
 };
+/**
+ * Column ids pinned to each edge — the same `T`-derived id union as {@link DataTableFacet}'s
+ * `columnId`, applied to TanStack's own `ColumnPinningState` shape (`{ left, right }`, each a bare
+ * `string[]` unrelated to any row type). Structurally assignable to `ColumnPinningState`, so no
+ * cast is needed where this flows into `useState<ColumnPinningState>`.
+ */
+export type DataTableColumnPinning<T = unknown> = {
+    left?: DataTableColumnId<T>[];
+    right?: DataTableColumnId<T>[];
+};
+/**
+ * The four boxes `BasaltDataTable` paints: `root` is the outer fragment's replacement wrapper,
+ * `toolbar` is the search/facets/actions row, `table` is the Mantine `Table` itself, `footer` is
+ * the pagination bar.
+ */
+export type BasaltDataTableSlot = 'root' | 'toolbar' | 'table' | 'footer';
 /**
  * Props for {@link BasaltDataTable}.
  *
@@ -65,7 +93,7 @@ export type DataTableFacet = {
  *   emptyState: <Text c="dimmed">No results found.</Text>,
  * }
  */
-export type BasaltDataTableProps<T> = {
+export type BasaltDataTableProps<T> = BasaltProps & SlotStylesProps<BasaltDataTableSlot> & {
     /**
      * Optional heading rendered above the toolbar via `WidgetHeader tier="widget"`. `count` always
      * reads `table.getRowCount()` (C11) — never a raw `data.length` — so it tracks the row model
@@ -125,8 +153,30 @@ export type BasaltDataTableProps<T> = {
     /**
      * When true, renders skeleton placeholder rows instead of the empty-state branch.
      * The header remains visible. Use while async data is loading.
+     *
+     * Superseded by `query`, which resolves this branch AND the two this prop cannot express — pass
+     * both and `query` wins, with a dev warning.
      */
     isLoading?: boolean;
+    /**
+     * The result behind `data`, resolved into a body: pending → the skeleton rows below, error with
+     * no data → an `ErrorState` row spanning the table (with the query's own `refetch` behind
+     * Retry), anything else → the rows, or `emptyState` when none are visible.
+     *
+     * This is law C3's uniform container contract (`docs/CONTROLS-SPEC.md` §1). The table had NO
+     * error branch at all (components audit #3), so a 500 rendered *No data to display.* — the
+     * exact false claim `QueryState` was built to delete, one container over.
+     *
+     * The header, toolbar, `<thead>` and pagination bar stay drawn through every branch: only the
+     * `<tbody>` swaps, which is why this is not `QueryState` wrapped around the table. A refetch
+     * that fails while rows are already on screen keeps the rows — compose `QueryState` AROUND the
+     * table when you want its cached-data banner too.
+     *
+     * @example
+     * const q = useQuery({ queryKey: ['rows'], queryFn: () => api.rows() })
+     * <BasaltDataTable data={q.data ?? []} columns={columns} query={q} />
+     */
+    query?: QueryStateLike<unknown>;
     /**
      * Number of skeleton rows to render when `isLoading` is true.
      * @default 5
@@ -178,7 +228,7 @@ export type BasaltDataTableProps<T> = {
      * @example
      * facets={[{ columnId: 'department', label: 'Department', options: departmentOptions }]}
      */
-    facets?: DataTableFacet[];
+    facets?: DataTableFacet<T>[];
     /** Called whenever the faceted column filters change — the seam for server-side faceting. */
     onColumnFiltersChange?: (filters: ColumnFiltersState) => void;
     /**
@@ -195,8 +245,65 @@ export type BasaltDataTableProps<T> = {
      * Right-aligned toolbar slot (e.g. an "Export" button). Renders the toolbar row even when no
      * search input or facets are configured. Renamed from `toolbarActions` — the toolbar (search +
      * facets + this slot) is wrapped in `CtlSlot` (C1/C5), so its controls resolve to the `ctl` tier.
+     *
+     * Two accepted forms (law C15): a typed `BarAction[]`, projected through the same row `PageBar`
+     * and `ActionGroup` use — ≤3 inline, the rest folded into `More`, one kebab below `sm` — or an
+     * opaque `ReactNode`, rendered verbatim exactly as before.
+     */
+    actions?: SlotActions;
+    /**
+     * Makes each row openable — click, or Enter on a focused row — with the ROW's original datum.
+     * The hook that pairs a table with `PageAside`: row → detail, without the caller adding an
+     * `onClick` to every cell renderer.
+     *
+     * The row keeps its native `<tr>` semantics and takes `tabIndex=0` plus `data-activatable`,
+     * never `role="button"`: a role swap takes the row out of the table's row/cell semantics, so a
+     * screen reader stops announcing each cell's column header — which is the reason the data is in
+     * a table. Cursor and focus ring come from the module class.
+     *
+     * A click that originates inside the selection checkbox does NOT activate (the checkbox stops
+     * the event); a click on a control your own `cell` renders should do the same.
+     *
+     * @example
+     * <BasaltDataTable data={rows} columns={columns} onRowActivate={(row) => setSelected(row)} />
      */
-    actions?: ReactNode;
+    onRowActivate?: (row: T) => void;
+    /**
+     * Prepends a checkbox column (header = select-all on the page) and arms TanStack's row-selection
+     * feature. Selection is uncontrolled unless `rowSelection` is passed.
+     * @default false
+     */
+    enableRowSelection?: boolean;
+    /**
+     * Controlled selection — TanStack's own `RowSelectionState` (`Record<rowId, boolean>`), keyed by
+     * `getRowId` (row index by default). Omit for uncontrolled selection held by the table.
+     */
+    rowSelection?: RowSelectionState;
+    /** Called with the next `RowSelectionState` on every selection change, controlled or not. */
+    onRowSelectionChange?: (selection: RowSelectionState) => void;
+    /**
+     * Stable row id, handed to TanStack. Pass one whenever the selection must survive a re-sort, a
+     * page change or a refetch — the default id is the row's INDEX, so row 3 stays "selected" when a
+     * different record moves into position 3.
+     */
+    getRowId?: (row: T, index: number) => string;
+    /**
+     * The actions a selection offers, rendered in a bar above the table while at least one row is
+     * selected — and nothing at all while none is.
+     *
+     * A FUNCTION of the selected rows, not a bare array, and that is the whole signature decision:
+     * `BarActionItem.onClick` is `() => void` (the one vocabulary every home shares, unforked), so
+     * the rows have to reach the handler through the closure the caller writes here. It also means
+     * an UNCONTROLLED table can offer bulk actions at all — the selection lives inside the table,
+     * and this is how it gets out.
+     *
+     * @example
+     * bulkActions={(rows) => [
+     *   { key: 'export', label: `Export ${rows.length}`, onClick: () => exportCsv(rows) },
+     *   { key: 'delete', label: 'Delete', danger: true, onClick: () => remove(rows) },
+     * ]}
+     */
+    bulkActions?: (rows: T[]) => BarAction[];
     /**
      * Enables the bottom pagination bar ("Showing X–Y of N", rows-per-page `Select`, Mantine
      * `Pagination`) wired to TanStack's `pagination` state. Client-side by default — see
@@ -262,7 +369,7 @@ export type BasaltDataTableProps<T> = {
      */
     enablePinning?: boolean;
     /** Initial column-pinning state — which column ids stick to the left/right edge. */
-    initialColumnPinning?: ColumnPinningState;
+    initialColumnPinning?: DataTableColumnPinning<T>;
     /**
      * 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
@@ -277,12 +384,44 @@ export type BasaltDataTableProps<T> = {
     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`.
+     * turns on the CAPPED scroll container; `maxHeight` alone implies `minWidth: 0`.
+     *
+     * It is a FLOOR, not the containment switch — since the shell made `AppShell.Main` the
+     * scrollport, every table renders inside a `Table.ScrollContainer type="native"` whether or not
+     * this is set (`minWidth: 0` when it is not), so a table wider than its column scrolls inside
+     * its own card instead of widening the page. Reach for this only to hold a MINIMUM table width
+     * — e.g. so eight columns keep their readable widths and scroll rather than compress.
+     *
+     * The one table whose wrapper is MEASURED rather than declared is `stickyHeader` with neither
+     * this nor `maxHeight`; see that prop and `useMeasuredContainment` in the implementation for
+     * why, and pair it with `maxHeight` if the table must both scroll and stick.
      */
     minWidth?: number | string;
-    /** Sticky header row. Pair with `maxHeight` to stick within the table rather than the page. */
+    /**
+     * Sticky header row. Pair with `maxHeight` to stick within the table rather than the page.
+     *
+     * On its own — no `maxHeight`, no `minWidth` — the header sticks against the page's scrollport
+     * (`AppShell.Main`) only while the table FITS its container, and basalt measures that: the
+     * wrapper declares no overflow while it fits and flips to `overflow-x: auto` once the table is
+     * wider, publishing `data-contained`. The columns stay reachable either way and the page never
+     * scrolls sideways, but a sticky header cannot stick inside an uncapped overflow box — it has
+     * no scroll range — so it is inert at that width. A dev warning states the trade; pair this
+     * with `maxHeight` for a table that must both scroll and stick at every width.
+     */
     stickyHeader?: boolean;
-    /** Offset for a sticky header sitting under a fixed app header (px number or CSS length). */
+    /**
+     * Offset for a sticky header sitting under whatever chrome scrolls above it (px number or CSS
+     * length).
+     *
+     * PAGE-scroll only, and IGNORED whenever `maxHeight`/`minWidth` turn on the scroll container:
+     * that box is then the header's own scrollport, so an offset would park the `<thead>` that many
+     * pixels down inside the body — painting it over the rows instead of above them. Inside the
+     * container the header sticks to the scroller's own top edge.
+     *
+     * Inside `BasaltShell` the page's scrollport is `AppShell.Main`, and the app header sits
+     * OUTSIDE it — so the only chrome left to clear is `PageBar` row 2's band:
+     * `var(--basalt-page-bar-h, 0px)`, not the header height plus it.
+     */
     stickyHeaderOffset?: number | string;
     /** Vertical cell padding. Forwarded to Mantine `Table`. */
     verticalSpacing?: MantineSpacing;
@@ -333,5 +472,5 @@ export type BasaltDataTableProps<T> = {
  *   emptyState={<Text c="dimmed">No users found.</Text>}
  * />
  */
-export declare function BasaltDataTable<T>({ title, icon, subtitle, data, columns, enableSorting, manualSorting, striped, highlightOnHover, emptyState, isLoading, skeletonRows, initialSorting, onSortingChange, enableGlobalFilter, globalFilterPlaceholder, searchIcon, initialGlobalFilter, onGlobalFilterChange, facets, onColumnFiltersChange, manualFiltering, actions, enablePagination, pageSizeOptions, initialPagination, onPaginationChange, manualPagination, rowCount, pageCount, enablePinning, initialColumnPinning, maxHeight, minWidth, stickyHeader, stickyHeaderOffset, verticalSpacing, horizontalSpacing, withRowBorders, withTableBorder, }: BasaltDataTableProps<T>): import("react").JSX.Element;
+export declare function BasaltDataTable<T>(props: 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":"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"}