@crewlethq/ui 0.38.0 → 0.40.0

package/dist/Charts/Histogram.d.ts

@@ -0,0 +1,71 @@
+import type { ReactNode } from 'react';
+export interface HistogramBar {
+    /** The bucket's start, epoch milliseconds. It is also the bar's key. */
+    t: number;
+    /** How many things fell in the bucket. */
+    v: number;
+    /**
+     * How many of `v` failed, where the caller has the split. Drawn as the
+     * danger-toned foot of the same fill, so the column's height is still the
+     * bucket's whole count. Absent draws the plain fill, because a split the
+     * data did not carry is not a split of zero.
+     */
+    part?: number | undefined;
+}
+export interface HistogramProps {
+    bars: HistogramBar[];
+    /** What the chart is, as the name of its group: "Turns that ended over the window". */
+    label: string;
+    /**
+     * The total and what it is a total of, read in place of the picture:
+     * "212 turns in this window". Required, and never summed here: the caller
+     * knows whether the bars cover the whole window or only the rows it holds,
+     * and a number whose scope is guessed is wrong on the second caller.
+     */
+    summary: string;
+    /** A bar's own sentence, for its tooltip and its accessible name. */
+    formatTitle: (bar: HistogramBar, index: number) => string;
+    /**
+     * A tick's label, which turns the axis on. Left out, the chart draws no
+     * dates, for a strip narrower than its own labels.
+     */
+    formatTick?: ((bar: HistogramBar, index: number) => string) | undefined;
+    /**
+     * Narrow the window to one bar. Given, every bar is a button; left out, the
+     * bars are a picture and take no tab stop.
+     */
+    onSelect?: ((bar: HistogramBar, index: number) => void) | undefined;
+    /** The plot's height in pixels. */
+    height?: number | undefined;
+    /** What the chart says in place of the bars when it has none. */
+    emptyLabel?: ReactNode;
+    className?: string | undefined;
+}
+/**
+ * Which bars get a label: the first, the last, and an even whole stride
+ * between, so a seven-day window reads every other day rather than gaps of
+ * two, one, two and one days (which reads as days missing from the data).
+ * The stride is the smallest whole number of bars that keeps the labels at or
+ * under five, preferring one that lands exactly on the last bar; where none
+ * does, a label nearer the last one than half a stride gives way to it.
+ */
+export declare function histogramTicks(bars: number): number[];
+/**
+ * A log's own time axis: where in a window things happened, which a page of
+ * rows cannot say.
+ *
+ * THE SLOT IS THE CONTROL AND THE FILL INSIDE IT IS THE BAR. The fill takes
+ * the column proportion `StackedColumns` uses, so one bucket and ninety draw
+ * with the same geometry, while the click target stays the whole slot.
+ *
+ * THE HEIGHT IS THE TRUE RATIO, with a floor in pixels rather than percent:
+ * a percentage floor grows with the panel and draws a bucket of 4 and one of
+ * 400 at the same height. An empty bucket stands one pixel under the smallest
+ * real count, because a zero-height element is invisible and an empty stretch
+ * would read as a gap in the chart rather than a quiet stretch in the data.
+ *
+ * A BUTTON WHEN IT DOES SOMETHING AND A DIV WHEN IT DOES NOT: a keyboard
+ * reader tabbing through eighty inert controls is worse served than one told
+ * there is nothing to operate.
+ */
+export declare function Histogram({ bars, label, summary, formatTitle, formatTick, onSelect, height, emptyLabel, className, }: HistogramProps): import("react").JSX.Element;

package/dist/Charts/index.d.ts

@@ -8,6 +8,8 @@ export { StackedBar } from './StackedBar.js';
 export type { StackedBarProps, StackedSegment } from './StackedBar.js';
 export { ActivityStrip } from './ActivityStrip.js';
 export type { ActivityBucket, ActivityStripProps } from './ActivityStrip.js';
+export { Histogram, histogramTicks } from './Histogram.js';
+export type { HistogramBar, HistogramProps } from './Histogram.js';
 export { TimeSeries, Sparkline } from './TimeSeries.js';
 export type { Series, SeriesPoint, SparklineProps, TimeSeriesProps } from './TimeSeries.js';
 export { StackedColumns, niceScale } from './StackedColumns.js';

package/dist/Charts/index.js

@@ -1,3 +1,3 @@
-export { ActivityStrip, BarList, ChartEmpty, ChartTooltip, DATA_COLORS, DATA_COLOR_OTHER, Legend, Sparkline, StackedBar, StackedColumns, TimeSeries, dataColor, niceScale, useChartHover } from '../chunk-HG5VF3TZ.js';
+export { ActivityStrip, BarList, ChartEmpty, ChartTooltip, DATA_COLORS, DATA_COLOR_OTHER, Histogram, Legend, Sparkline, StackedBar, StackedColumns, TimeSeries, dataColor, histogramTicks, niceScale, useChartHover } from '../chunk-HMVQQEHW.js';
 import '../chunk-BZFWDIV6.js';
 import '../chunk-ODEQTPFM.js';

package/dist/{Charts-MBJG72BS.css → Charts-TZ744HT6.css}

@@ -978,3 +978,121 @@
   transform: translateY(-50%);
   pointer-events: none;
 }
+
+/* ─── Histogram, a log's own time axis ─────────────────────────── */
+
+/*
+ * Time runs left to right on this axis in every writing direction, as it does
+ * on every chart, and the ticks are placed on physical sides to match.
+ */
+.crewlet-histogram {
+  display: flex;
+  flex-direction: column;
+  min-width: 0;
+  direction: ltr;
+}
+
+/* The plot's bottom border is the axis line the ticks hang under. */
+.crewlet-histogram__plot {
+  display: flex;
+  align-items: flex-end;
+  gap: 1px;
+  width: 100%;
+  height: var(--crewlet-histogram-height, 96px);
+  padding: var(--spacing-1) 0;
+  border-bottom: 1px solid var(--color-border-hover);
+}
+
+/* The slot is the control, and the whole of it is the target. */
+.crewlet-histogram__bar {
+  all: unset;
+  flex: 1 1 0;
+  min-width: 2px;
+  height: 100%;
+  display: flex;
+  align-items: flex-end;
+  justify-content: center;
+}
+
+button.crewlet-histogram__bar {
+  cursor: pointer;
+}
+
+/* A slot draws no edge, so its ring stands off it. `all: unset` takes the
+   baseline ring away; this states it again at a weight the reset cannot
+   out-rank. */
+.crewlet-histogram__bar:focus-visible {
+  outline: 2px solid var(--color-focus);
+  outline-offset: 2px;
+}
+
+/*
+ * A count is data, so it is drawn in the data ramp; the accent is kept for the
+ * bar the reader is pointing at, the selection a click is about to make. The
+ * fill stacks from its foot, so the failed share sits at its bottom. Floors in
+ * pixels: an empty bucket at two, the smallest real count at three.
+ */
+.crewlet-histogram__fill {
+  display: flex;
+  flex-direction: column;
+  justify-content: flex-end;
+  overflow: hidden;
+  width: 63%;
+  min-width: 2px;
+  max-width: var(--spacing-7);
+  height: var(--crewlet-histogram-fill, 0%);
+  min-height: 3px;
+  background: var(--color-data-1);
+  border-radius: var(--radius-sm) var(--radius-sm) 0 0;
+  transition: background var(--motion-duration-fast) var(--motion-easing-default);
+}
+
+.crewlet-histogram__part {
+  display: block;
+  width: 100%;
+  height: var(--crewlet-histogram-part, 0%);
+  background: var(--color-feedback-danger);
+}
+
+button.crewlet-histogram__bar:hover > .crewlet-histogram__fill,
+button.crewlet-histogram__bar:focus-visible > .crewlet-histogram__fill {
+  background: var(--color-brand-accent);
+}
+
+/* An empty bucket is a visible floor in the tone an axis is ruled in:
+   present, and plainly not a quantity. */
+.crewlet-histogram__bar[data-empty] > .crewlet-histogram__fill {
+  min-height: 2px;
+  background: var(--color-border-strong);
+}
+
+button.crewlet-histogram__bar[data-empty]:hover > .crewlet-histogram__fill,
+button.crewlet-histogram__bar[data-empty]:focus-visible > .crewlet-histogram__fill {
+  background: var(--color-border-strong-hover);
+}
+
+/*
+ * The dates under the bars. Absolutely placed, so a tick sits over the bucket
+ * it names; the row states its own height because absolutely placed children
+ * contribute none.
+ */
+.crewlet-histogram__axis {
+  position: relative;
+  height: calc(var(--font-size-2xs) * var(--font-line-height-normal));
+  margin-top: 2px;
+}
+
+.crewlet-histogram__tick {
+  position: absolute;
+  top: 0;
+  font-size: var(--font-size-2xs);
+  color: var(--color-text-tertiary);
+  font-variant-numeric: tabular-nums;
+  white-space: nowrap;
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .crewlet-histogram__fill {
+    transition: none;
+  }
+}

package/dist/CodeBlock/index.js

@@ -1,4 +1,4 @@
-export { CodeBlock } from '../chunk-GDDE4UM7.js';
+export { CodeBlock } from '../chunk-SEC2GR2V.js';
 import '../chunk-W46LPU4R.js';
 import '../chunk-STJ7QBC3.js';
 import '../chunk-DTIW4CHZ.js';

package/dist/{CodeBlock-GYNJ2HI6.css → CodeBlock-N5ETJF24.css}

@@ -16,6 +16,19 @@
   min-width: 0;
 }
 
+/*
+ * A BLOCK THAT IS A CARD'S CONTENT IS THAT CARD'S SURFACE. Placed straight in
+ * a card (with `padding="none"`), it gives up its own edge, corner and ground,
+ * so the card's head rule is the only line over the code and there is no box
+ * inside a box. In a padded body it stays a well, which is what tells code
+ * from the prose beside it.
+ */
+.crewlet-card > .crewlet-codeblock {
+  border: 0;
+  border-radius: var(--radius-none);
+  background: transparent;
+}
+
 .crewlet-codeblock__header {
   display: flex;
   align-items: center;

package/dist/CommandPalette/index.js

@@ -1,8 +1,8 @@
-export { CommandPalette } from '../chunk-PAQXOP2M.js';
-import '../chunk-SVGARBDY.js';
+export { CommandPalette } from '../chunk-XGBUUQDU.js';
+import '../chunk-IAGYPTEJ.js';
 import '../chunk-7KHM2FZH.js';
-import '../chunk-SMBKXWML.js';
 import '../chunk-TYONQSOK.js';
+import '../chunk-SMBKXWML.js';
 import '../chunk-BHHIIK3M.js';
 import '../chunk-PQADV6P6.js';
 import '../chunk-OMV5W53A.js';

package/dist/CommentThread/index.js

@@ -1,13 +1,13 @@
-export { COMMENT_THREAD_LABELS, CommentThread } from '../chunk-PT6WKXKW.js';
+export { COMMENT_THREAD_LABELS, CommentThread } from '../chunk-MMPKN7WV.js';
 import '../chunk-CI3VPIJN.js';
 import '../chunk-3CZ7XAVY.js';
 import '../chunk-EUCC37WY.js';
 import '../chunk-5AQBPHZD.js';
 import '../chunk-PZKHBB7D.js';
 import '../chunk-PWG3VHRQ.js';
-import '../chunk-ETVEGR2Y.js';
-import '../chunk-SMBKXWML.js';
+import '../chunk-ISA2O2BK.js';
 import '../chunk-TYONQSOK.js';
+import '../chunk-SMBKXWML.js';
 import '../chunk-BHHIIK3M.js';
 import '../chunk-PQADV6P6.js';
 import '../chunk-OG6CL3EB.js';

package/dist/Composer/index.js

@@ -1,6 +1,6 @@
-export { COMPOSER_COUNTER_AT, Composer } from '../chunk-ETVEGR2Y.js';
-import '../chunk-SMBKXWML.js';
+export { COMPOSER_COUNTER_AT, Composer } from '../chunk-ISA2O2BK.js';
 import '../chunk-TYONQSOK.js';
+import '../chunk-SMBKXWML.js';
 import '../chunk-PQADV6P6.js';
 import '../chunk-4FQT6ZAY.js';
 import '../chunk-NUZHC6MM.js';

package/dist/DataGrid/DataGrid.d.ts

@@ -0,0 +1,267 @@
+import { type MouseEvent as ReactMouseEvent, type KeyboardEvent as ReactKeyboardEvent, type ReactNode, type Ref } from 'react';
+/**
+ * What activated a row: a click, a key on the row's overlay, or the
+ * application's own keymap driving the cursor (a native `KeyboardEvent`).
+ * Each carries the modifier keys a handler reads to open in a new tab.
+ */
+export type DataGridActivationEvent = ReactMouseEvent | ReactKeyboardEvent | KeyboardEvent;
+/** One column of a [DataGrid]. */
+export interface DataGridColumn<T> {
+    key: string;
+    header: ReactNode;
+    cell: (row: T) => ReactNode;
+    /** The value sorted on. Omit to make the column unsortable. */
+    sortValue?: ((row: T) => string | number | null | undefined) | undefined;
+    align?: 'left' | 'right' | undefined;
+    /**
+     * The column's name where `header` cannot carry one: a glyph head, or none
+     * at all. Drawn by the card layout a grid takes on a phone, where every value
+     * names itself, and said to assistive technology over a glyph head.
+     */
+    label?: string | undefined;
+    /**
+     * A column of ROW ACTIONS: every cell is a control that names itself (a
+     * "Revoke" button, an icon button with its own label). On the phone's card
+     * such a cell draws no name beside it, since the control is its own name;
+     * its head stays empty, since a word over a column of buttons says nothing
+     * the buttons do not.
+     */
+    action?: boolean | undefined;
+    /** Shrink to content (up to a fifth of the grid) and never wrap. */
+    shrink?: boolean | undefined;
+    /**
+     * On a grid drawn with `phoneRows="compact"`, a cell of the row's FIRST line
+     * (what the row is: a key, a title), where every other cell is a fact about
+     * it on the line under.
+     */
+    phoneLead?: boolean | undefined;
+    /** Left off the compact phone row, whose contract is two lines. */
+    phoneOmit?: boolean | undefined;
+    /** An exact track, in place of the computed one. */
+    width?: string | undefined;
+    /** Hidden unless the column set (`cols`) names it. */
+    optional?: boolean | undefined;
+    /**
+     * The narrowest a FLEXIBLE column may be drawn: its track is
+     * `minmax(floor, 1fr)` rather than `minmax(0, 1fr)`. For the column that is
+     * the point of the list (a title, a name), which at zero gave way to every
+     * content-sized column beside it.
+     */
+    floor?: string | undefined;
+    /**
+     * The order this column GIVES WAY in when the grid cannot draw every column
+     * at its size: the lowest number goes first, and a column without one never
+     * goes. A grid that cannot fit drops columns rather than cutting them off at
+     * its clipped edge, and says which it dropped.
+     */
+    drop?: number | undefined;
+}
+/** One column a reader may turn on or off, as a [ColumnChooser] offers it. */
+export interface ColumnChoice {
+    key: string;
+    label: string;
+    /** Off until the column set names it. */
+    optional?: boolean | undefined;
+}
+/**
+ * The choices a chooser offers, DERIVED from the columns a grid draws, so a
+ * column added to a grid appears in its menu with no second edit. The cell
+ * renderers are never called: a name and a flag are properties of the column.
+ */
+export declare function columnChoicesOf<T>(columns: readonly DataGridColumn<T>[]): ColumnChoice[];
+/** One box in a [ChooserList]. */
+export interface ChooserItem<K extends string = string> {
+    key: K;
+    label: ReactNode;
+    checked: boolean;
+}
+export interface ChooserListProps<K extends string = string> {
+    /** The heading above the boxes, which also names the group. */
+    label: string;
+    items: readonly ChooserItem<K>[];
+    onToggle: (key: K) => void;
+}
+/**
+ * A short checklist of what a view shows, in two columns under a quiet
+ * heading: the columns a grid draws ([ColumnChooser]), the facts a card
+ * carries. Native checkboxes in a named group, each row its box's label, so
+ * the whole row takes the pointer.
+ */
+export declare function ChooserList<K extends string = string>({ label, items, onToggle }: ChooserListProps<K>): import("react").JSX.Element | null;
+export interface ColumnChooserProps {
+    choices: readonly ColumnChoice[];
+    /** The column set as it stands (`key,key`), empty for the default set. */
+    value: string;
+    onChange: (cols: string) => void;
+    /** The heading above the boxes. */
+    label?: string | undefined;
+}
+/**
+ * The checkbox list a reader chooses a grid's columns with.
+ *
+ * AN EMPTY VALUE IS THE DEFAULT SET, NOT AN EMPTY GRID, as [DataGrid] reads
+ * it, so the boxes show the default until somebody moves one. It writes the
+ * DECLARATION order, never the click order: the value carries an order as well
+ * as a selection, and a value built from the order boxes were ticked in would
+ * rearrange the grid with every tick.
+ */
+export declare function ColumnChooser({ choices, value, onChange, label }: ColumnChooserProps): import("react").JSX.Element;
+/** A group of rows, as a grouped answer sends it: its own count and a page of rows. */
+export interface DataGridBand<T> {
+    key: string;
+    label: ReactNode;
+    /** The group value's own mark, drawn before the label (a sibling, so no ellipsis eats it). */
+    mark?: ReactNode;
+    /** The count over the WHOLE group, where the source gave one. */
+    total?: number | undefined;
+    rows: T[];
+    /**
+     * The bands INSIDE this one, where the answer was grouped twice: a band
+     * carries rows OR sub-bands, never both, as the answer arrives.
+     */
+    bands?: DataGridBand<T>[] | undefined;
+    /** A per-band aggregate line, or the way to what the band did not fit. */
+    footer?: ReactNode;
+}
+/** The words a grid says, for an application that says them otherwise. */
+export interface DataGridLabels {
+    /** "Hidden to fit: Due and Updated". */
+    hiddenToFit: (names: string) => string;
+    loadMore: string;
+    showEveryColumn: string;
+    /** Joins the last two names of a list: "Due and Updated". */
+    and: string;
+}
+/**
+ * What an application drives a grid's cursor with. The grid binds no keys of
+ * its own: an application with a keymap decides which of several grids on a
+ * screen a keystroke is for, and moves that one.
+ */
+export interface DataGridHandle {
+    /** Moves the cursor row by `by` rows, clamped, and scrolls it into view. */
+    step: (by: number) => void;
+    /** Activates the cursor row, as a click on it would. False when there is none. */
+    activate: (event: ReactKeyboardEvent | KeyboardEvent) => boolean;
+    /** How many rows the grid draws, its bands' rows included. */
+    rowCount: () => number;
+}
+export interface DataGridProps<T> {
+    rows?: T[] | undefined;
+    bands?: DataGridBand<T>[] | undefined;
+    columns: DataGridColumn<T>[];
+    rowKey: (row: T) => string;
+    /** A plain click, or Enter on the cursor row. The row is still a link when `rowHref` is given. */
+    onRowActivate?: ((row: T, event: DataGridActivationEvent) => void) | undefined;
+    /** The row's object's page: a real link stretched over the row, so a new tab and copying it work. */
+    rowHref?: ((row: T) => string) | undefined;
+    /** The row the reader is on (the object a page or a side panel shows): tinted and announced as current. */
+    isSelected?: ((row: T) => boolean) | undefined;
+    isFailed?: ((row: T) => boolean) | undefined;
+    /**
+     * The sort as `key` or `-key` (descending), empty for the rows' own order.
+     * Controlled, so an application keeps it where it keeps state (an address).
+     */
+    sort?: string | undefined;
+    /** A sortable head pressed: ascending, then descending, then unsorted. */
+    onSortChange?: ((sort: string) => void) | undefined;
+    /** The rows arrive ordered by their source (a paged answer ordered over the whole set). */
+    serverSorted?: boolean | undefined;
+    /** The column set as `key,key`, in the order to draw it; empty for every column not `optional`. */
+    cols?: string | undefined;
+    /** The way back from a column set: drawn as "Show every column" while one is set. */
+    onColsChange?: ((cols: string) => void) | undefined;
+    /** What an empty grid says, and the one control that is its next step. */
+    empty?: {
+        title: ReactNode;
+        hint?: ReactNode;
+        icon?: ReactNode;
+        action?: ReactNode;
+    } | undefined;
+    footer?: ReactNode;
+    onLoadMore?: (() => void) | undefined;
+    /** "40 of 312 loaded": what an export would actually contain. */
+    loadedNote?: string | undefined;
+    /**
+     * HOW A ROW IS DRAWN ON A PHONE, where there are no columns: `labelled` (a
+     * card of one named line per value, which every grid can take) or `compact`
+     * (two lines with no names: the lead cells, then every other value as a run
+     * of marks, for a list scanned by the dozen).
+     */
+    phoneRows?: 'labelled' | 'compact' | undefined;
+    /**
+     * The grid is a card's body: no edge, corner or ground of its own and one
+     * rule above its head. A grid straight in a `Card` is flush without this.
+     */
+    flush?: boolean | undefined;
+    /** For an application driving the cursor from its own keymap. */
+    handleRef?: Ref<DataGridHandle> | undefined;
+    /** The reader pressed inside the grid: which grid the keyboard means. */
+    onPointerDown?: (() => void) | undefined;
+    labels?: Partial<DataGridLabels> | undefined;
+    /** What the table is, for assistive technology: its card's title, by id or in words. */
+    'aria-label'?: string | undefined;
+    'aria-labelledby'?: string | undefined;
+    className?: string | undefined;
+}
+/** `-updated` as `{key: "updated", desc: true}`. */
+export declare function parseGridSort(raw: string): {
+    key: string;
+    desc: boolean;
+} | null;
+/** What the fit has decided for one set of columns, at one width. */
+export interface GridFit {
+    /** The column set it was decided for. */
+    readonly set: string;
+    /** The grid's width when it last decided. */
+    readonly width: number;
+    /** The keys it dropped, in the order it dropped them. */
+    readonly dropped: readonly string[];
+}
+/**
+ * The next fit, or null when this one stands. PURE, so the rules are held
+ * without a layout engine:
+ *
+ * - the grid GREW past the width columns were dropped at: start again from all
+ *   of them (the next pass drops again only what still does not fit);
+ * - the tracks OVERRUN the grid: drop the visible column with the lowest
+ *   `drop`, if there is one;
+ * - otherwise remember a narrower width, so growing back past it re-tries.
+ */
+export declare function fitGridColumns({ fit, width, overflows, visible, }: {
+    fit: GridFit;
+    width: number;
+    overflows: boolean;
+    visible: readonly {
+        key: string;
+        drop?: number | undefined;
+    }[];
+}): GridFit | null;
+/**
+ * A list as columns: sortable heads, optional and give-way columns, bands for
+ * a grouped answer, a row link stretched over each row, and a card per row on
+ * a phone.
+ *
+ * ONE TRACK LIST, ON THE GRID. The head, the bands and every row are
+ * `subgrid` passthroughs, so a head cell and a cell twenty rows down size the
+ * same track; each row being its own grid sized its columns against its own
+ * cells alone, and no value sat under the head that named it.
+ *
+ * A SHRINK COLUMN IS CAPPED (`fit-content(20%)`): `max-content` grows without
+ * a ceiling and grid resolves it before any flexible column, so one long value
+ * starved the title to zero and still overflowed.
+ *
+ * COLUMNS THAT DO NOT FIT GIVE WAY IN ORDER (`drop`), measured after every
+ * commit in a layout effect so the intermediate shapes never paint, and the
+ * foot names what the width took. Not on a phone, where a row is a card.
+ *
+ * THE ROW'S LINK IS AN OVERLAY, NOT THE ROW: a row that was an anchor made
+ * every linking cell an anchor inside an anchor, and the parser closes the
+ * outer one at the inner, so the row stopped being clickable from that cell
+ * on. Stretched over the row it keeps a real href, and the cells' own links
+ * and buttons sit above it.
+ *
+ * The grid makes no scrollport of its own (`overflow: clip`), which is what
+ * lets its head stick against the page's scroller; an application whose
+ * scroller carries a sticky bar sets `--crewlet-data-grid-sticky-top`.
+ */
+export declare function DataGrid<T>({ rows, bands, columns, rowKey, onRowActivate, rowHref, isSelected, isFailed, sort: sortRaw, onSortChange, serverSorted, cols: colsRaw, onColsChange, empty, footer, onLoadMore, loadedNote, phoneRows, flush, handleRef, onPointerDown, labels, 'aria-label': ariaLabel, 'aria-labelledby': ariaLabelledby, className, }: DataGridProps<T>): import("react").JSX.Element;

package/dist/DataGrid/index.d.ts

@@ -0,0 +1,3 @@
+import './DataGrid.css';
+export { ChooserList, ColumnChooser, DataGrid, columnChoicesOf, fitGridColumns, parseGridSort } from './DataGrid.js';
+export type { ColumnChoice, ChooserItem, ChooserListProps, ColumnChooserProps, DataGridActivationEvent, DataGridBand, DataGridColumn, DataGridHandle, DataGridLabels, DataGridProps, GridFit, } from './DataGrid.js';

package/dist/DataGrid/index.js

@@ -0,0 +1,7 @@
+export { ChooserList, ColumnChooser, DataGrid, columnChoicesOf, fitGridColumns, parseGridSort } from '../chunk-XIDD7PJO.js';
+import '../chunk-RA2ULG6H.js';
+import '../chunk-PQADV6P6.js';
+import '../chunk-RTPQDNW3.js';
+import '../chunk-OG6CL3EB.js';
+import '../chunk-BZFWDIV6.js';
+import '../chunk-ODEQTPFM.js';