@x12i/data 0.0.0-stage → 1.1.0

package/dist/index.d.ts

@@ -0,0 +1,394 @@
+import { C as ColumnDef, a as CellType, b as ColumnAlign, c as ColumnEditor, d as ColumnFilterType, S as SortModelItem, F as FormatContext, e as FilterOperator, f as FilterModelItem, A as AggregateName, g as SortDirection, G as GroupModelItem, h as GetRowsRequest, i as ServerDataSource } from './messages-BF20Mq97.js';
+export { j as AggregateFn, k as CaptureViewOptions, l as CellFormatter, m as ColumnLayout, n as ColumnOption, o as ColumnPin, p as ColumnPinning, q as ColumnState, D as DataGridMessageOverrides, r as DataGridMessages, s as DelimitedOptions, E as EMPTY_SELECTION, t as FILTER_OPERATORS, u as FormatLabels, v as GetRowsOptions, w as GetRowsResult, x as GridViewState, L as LocalStorageSavedViewStoreOptions, y as SAVED_VIEW_VERSION, z as SavedView, B as SavedViewStore, H as SavedViewSummary, I as SelectionState, J as SelectionSummary, K as SerializedSelection, M as StatusTone, N as StorageLike, O as applySavedView, P as captureView, Q as clearSelection, R as countSelected, T as createCellFormatter, U as createLocalStorageSavedViewStore, V as createMemorySavedViewStore, W as createSelection, X as createViewState, Y as defaultFormatLabels, Z as defaultMessages, _ as defineColumns, $ as deserializeSelection, a0 as escapeCsvField, a1 as escapeDelimitedField, a2 as exportableColumns, a3 as formatCellValue, a4 as gridToCsv, a5 as gridToTsv, a6 as isSelected, a7 as isSelectionEmpty, a8 as layoutColumns, a9 as moveColumn, aa as moveColumnTo, ab as parseDelimited, ac as parseSavedView, ad as resizeColumn, ae as resolveColumnOrder, af as resolveDateFormatOptions, ag as resolveMessages, ah as resolveNumberFormatOptions, ai as resolveSelectedIds, aj as selectAll, ak as selectAllExceptNone, al as selectOnly, am as selectRange, an as serializeSelection, ao as setColumnFilter, ap as setPinning, aq as setSort, ar as sortRank, as as summarizeSelection, at as toggleGroup, au as toggleRow, av as toggleSort } from './messages-BF20Mq97.js';
+
+declare const DEFAULT_COLUMN_WIDTH = 160;
+declare const DEFAULT_COLUMN_MIN_WIDTH = 64;
+declare const DEFAULT_COLUMN_MAX_WIDTH = 1200;
+/** Reads the value of a column from a row: `accessor`, else `field`, else `undefined`. */
+declare function getColumnValue<Row>(column: ColumnDef<Row>, row: Row): unknown;
+/** The column's `field`, or its `id` when it has none. This is the name a server sees. */
+declare function columnFieldName<Row>(column: ColumnDef<Row>): string;
+declare function isNumericCellType(cellType: CellType | undefined): boolean;
+/** The alignment of a column: its `align`, or `end` for numbers and `start` otherwise. */
+declare function resolveColumnAlign<Row>(column: ColumnDef<Row>): ColumnAlign;
+/** The filter type of a column: `filterType`, else derived from `cellType`. */
+declare function resolveFilterType<Row>(column: ColumnDef<Row>): ColumnFilterType;
+/** The editor of a column: `editor`, else derived from `cellType`. */
+declare function resolveEditor<Row>(column: ColumnDef<Row>): ColumnEditor;
+declare function isSortable<Row>(column: ColumnDef<Row>): boolean;
+declare function isFilterable<Row>(column: ColumnDef<Row>): boolean;
+declare function isResizable<Row>(column: ColumnDef<Row>): boolean;
+declare function isEditable<Row>(column: ColumnDef<Row>, row: Row): boolean;
+/** Clamps a width to the column's `minWidth` and `maxWidth`. */
+declare function clampColumnWidth<Row>(column: ColumnDef<Row>, width: number): number;
+/** The width of a column before any resize: `width`, clamped, or the default. */
+declare function initialColumnWidth<Row>(column: ColumnDef<Row>): number;
+/** Looks columns up by id. The first column with an id wins. */
+declare function indexColumns<Row>(columns: readonly ColumnDef<Row>[]): Map<string, ColumnDef<Row>>;
+
+/** Small value helpers shared by the sort, filter, format and export engines. */
+/** `YYYY-MM-DD`. Such a value names a calendar day, not an instant. */
+declare function isDateOnlyString(value: unknown): value is string;
+/** `null`, `undefined`, an empty string, `NaN` and an empty array. `0` and `false` are values. */
+declare function isEmptyValue(value: unknown): boolean;
+/** A finite number from a number, bigint or numeric string; `NaN` for anything else. */
+declare function toNumber(value: unknown): number;
+/** Milliseconds since the epoch from a `Date`, number or date string; `NaN` for anything else. */
+declare function toTimestamp(value: unknown): number;
+/** A `Date` from a date-like value, or `null` when it is not a valid date. */
+declare function toDate(value: unknown): Date | null;
+/** Plain text for any value. Arrays join with a comma, dates use ISO format, `null` is empty. */
+declare function toText(value: unknown): string;
+/** Lower-cases and strips diacritics so "José" matches "jose". */
+declare function normalizeText(value: string, locale?: string): string;
+/** A boolean from a boolean or the strings `true`/`false`; `null` for anything else. */
+declare function toBoolean(value: unknown): boolean | null;
+
+interface SortOptions {
+    /** BCP 47 locale for string comparison. Defaults to the runtime locale. */
+    locale?: string;
+    /** Compare digit runs as numbers, so "item 2" sorts before "item 10". Default `true`. */
+    numeric?: boolean;
+    /** Ignore case and accents when comparing strings. Default `true`. */
+    caseInsensitive?: boolean;
+}
+/** A comparable key: numbers and strings compare naturally, `null` always sorts last. */
+type SortKey = number | string | null;
+declare function createCollator(options?: SortOptions): Intl.Collator;
+/** The key a value sorts by. Numbers, dates and booleans become numbers; the rest become text. */
+declare function toSortKey(value: unknown): SortKey;
+/**
+ * Compares two values the way the grid sorts them: numbers by size, dates by
+ * time, booleans false before true, strings with a locale-aware collator, and
+ * empty values last. Returns a negative, zero or positive number (ascending).
+ */
+declare function compareValues(a: unknown, b: unknown, collator?: Intl.Collator): number;
+/**
+ * Sorts a list of row indexes by the sort model. The sort is stable, locale
+ * aware and multi-column: later items break ties of earlier ones. Empty values
+ * sort last in both directions. A column's `comparator` replaces the default.
+ * Items naming an unknown column are ignored.
+ *
+ * Works on indexes so a 100,000-row sort moves numbers, not row objects.
+ */
+declare function sortIndexes<Row>(rows: readonly Row[], indexes: readonly number[], sort: readonly SortModelItem[], columns: readonly ColumnDef<Row>[], options?: SortOptions): number[];
+/** Sorts rows and returns a new array. See `sortIndexes`. */
+declare function sortRows<Row>(rows: readonly Row[], sort: readonly SortModelItem[], columns: readonly ColumnDef<Row>[], options?: SortOptions): Row[];
+
+interface FilterContext {
+    locale?: string;
+    /** IANA time zone that decides where a calendar day starts for date filters. */
+    timeZone?: string;
+}
+/** The operators each filter type offers, in menu order. */
+declare const OPERATORS_BY_FILTER_TYPE: Record<ColumnFilterType, readonly FilterOperator[]>;
+declare function operatorsFor(type: ColumnFilterType): readonly FilterOperator[];
+/** `is-empty` and `is-not-empty` take no value. */
+declare function isValuelessOperator(operator: FilterOperator): boolean;
+/**
+ * Whether a filter item narrows anything. An item with no usable value (an empty
+ * text box, `in` with no choices) is ignored instead of hiding every row.
+ */
+declare function isFilterEffective(item: FilterModelItem): boolean;
+/** The `YYYY-MM-DD` of a filter value: a date-only string, or the local day of a `Date`. */
+declare function toDayString(value: unknown): string | null;
+/** Milliseconds at the start of a `YYYY-MM-DD` day in a time zone (local when none). */
+declare function dayStart(day: string, timeZone?: string): number;
+/** The `YYYY-MM-DD` after a given day. */
+declare function nextDay(day: string): string;
+type ValuePredicate = (value: unknown) => boolean;
+/**
+ * Compiles one filter item into a predicate on a cell value. Empty values match
+ * only `is-empty`, `not-equals` and `not-contains`. An item with no usable value
+ * matches everything.
+ */
+declare function createValuePredicate<Row>(item: FilterModelItem, column: ColumnDef<Row>, ctx?: FilterContext): ValuePredicate;
+/** Whether one value passes one filter item. Convenience over `createValuePredicate`. */
+declare function matchesFilter<Row>(value: unknown, item: FilterModelItem, column: ColumnDef<Row>, ctx?: FilterContext): boolean;
+/** Splits quick-search text into normalized tokens. Every token must match. */
+declare function parseQuickFilter(text: string, locale?: string): string[];
+declare function isSearchable<Row>(column: ColumnDef<Row>): boolean;
+/**
+ * Builds the text each row is searched by: the formatted text of every
+ * searchable column, normalized. Build it once per rows and columns (React:
+ * `useMemo`) and pass it to `filterIndexes`, so typing in the quick search box
+ * does not format every cell again.
+ */
+declare function createSearchIndex<Row>(rows: readonly Row[], columns: readonly ColumnDef<Row>[], ctx?: FormatContext): string[];
+interface FilterIndexesOptions<Row> extends FilterContext {
+    /** Quick-search text. Every whitespace-separated token must appear in the row. */
+    quickFilter?: string;
+    /** From `createSearchIndex`, aligned to `rows`. Built on demand when absent. */
+    searchIndex?: readonly string[];
+    /** Columns the quick search reads when no `searchIndex` is given. Defaults to `columns`. */
+    searchColumns?: readonly ColumnDef<Row>[];
+    labels?: FormatContext["labels"];
+}
+/**
+ * Returns the indexes of the rows that pass every column filter and the quick
+ * filter, in their original order. Filters on different columns combine with
+ * AND, and so do several filters on one column. Items naming an unknown column
+ * are ignored.
+ */
+declare function filterIndexes<Row>(rows: readonly Row[], filter: readonly FilterModelItem[], columns: readonly ColumnDef<Row>[], options?: FilterIndexesOptions<Row>): number[];
+/** Distinct values of a column, for set filters. Capped so a huge column cannot stall the UI. */
+declare function distinctValues<Row>(rows: readonly Row[], column: ColumnDef<Row>, limit?: number): unknown[];
+
+interface AggregateOptions {
+    /** Return the original value of the earliest or latest entry, for date columns. */
+    dates?: boolean;
+}
+/**
+ * Reduces values to one: `sum`, `avg`, `min`, `max` over the numeric values, or
+ * `count` of non-empty values. Non-numeric values are skipped. `sum` of nothing
+ * is `0`; `avg`, `min` and `max` of nothing are `null`.
+ */
+declare function aggregateValues(values: readonly unknown[], name: AggregateName, options?: AggregateOptions): unknown;
+/** The aggregate of one column over some rows, or `undefined` when the column has none. */
+declare function computeAggregate<Row>(column: ColumnDef<Row>, rows: readonly Row[]): unknown;
+/** The aggregates of every column that declares one, keyed by column id. */
+declare function computeAggregates<Row>(columns: readonly ColumnDef<Row>[], rows: readonly Row[]): Record<string, unknown>;
+
+interface GroupNode {
+    /** Stable path id, for example `region=EMEA/country=DE`. Use it as the expansion key. */
+    id: string;
+    /** The id of the column grouped by at this level. */
+    field: string;
+    /** The grouped value, as the first row of the group holds it. */
+    value: unknown;
+    /** 0 for the outermost level. */
+    depth: number;
+    /** Indexes (into the rows array) of every row below this group, in view order. */
+    indexes: number[];
+    /** Sub-groups. Empty at the innermost level. */
+    children: GroupNode[];
+    /** Aggregates of the columns that declare one, over every row below. */
+    aggregates: Record<string, unknown>;
+}
+interface GroupOptions extends SortOptions {
+    /**
+     * How to order groups: `first` keeps the order rows arrive in, `asc` and
+     * `desc` sort by group value. A function picks per column id.
+     */
+    order?: "first" | SortDirection | ((field: string) => "first" | SortDirection);
+}
+/**
+ * Splits row indexes into nested groups by the group model, one level per item,
+ * and aggregates each group. Items naming an unknown column are ignored. With no
+ * usable group item the result is empty.
+ */
+declare function buildGroupTree<Row>(rows: readonly Row[], indexes: readonly number[], group: readonly GroupModelItem[], columns: readonly ColumnDef<Row>[], options?: GroupOptions): GroupNode[];
+
+interface ViewOptions<Row> extends FilterIndexesOptions<Row>, SortOptions {
+    sort?: readonly SortModelItem[];
+    filter?: readonly FilterModelItem[];
+}
+/**
+ * The client-side pipeline: filter (columns, then quick search), then sort.
+ * Returns the indexes of the surviving rows in presentation order. It never
+ * copies a row, so 100,000 rows cost two integer arrays.
+ */
+declare function computeViewIndexes<Row>(rows: readonly Row[], columns: readonly ColumnDef<Row>[], options?: ViewOptions<Row>): number[];
+/** A row as the grid lays it out: a data row, a group header, or a detail panel. */
+type DisplayRow<Row> = {
+    kind: "data";
+    /** The row id from `getRowId`. */
+    id: string;
+    row: Row;
+    /** Index into the source rows array. */
+    index: number;
+    /** Number of group levels above the row. `aria-level` is `depth + 1`. */
+    depth: number;
+} | {
+    kind: "group";
+    /** The group path id. */
+    id: string;
+    field: string;
+    value: unknown;
+    depth: number;
+    /** Rows below the group, at every depth. */
+    count: number;
+    expanded: boolean;
+    aggregates: Record<string, unknown>;
+} | {
+    kind: "detail";
+    id: string;
+    /** The id of the data row this panel belongs to. */
+    parentId: string;
+    row: Row;
+    index: number;
+    depth: number;
+};
+interface DisplayOptions<Row> {
+    getRowId: (row: Row, index: number) => string;
+    group?: readonly GroupModelItem[];
+    /** Per group id. Groups without an entry follow `groupsExpandedByDefault`. */
+    groupExpansion?: Readonly<Record<string, boolean>>;
+    groupsExpandedByDefault?: boolean;
+    /** Row ids whose detail panel is open. */
+    expandedRows?: Readonly<Record<string, boolean>>;
+    /** Insert a `detail` row below each expanded data row. */
+    withDetail?: boolean;
+    sort?: readonly SortModelItem[];
+    locale?: string;
+}
+/**
+ * Turns presentation-ordered indexes into the flat list the grid renders:
+ * data rows, group headers for the group model, and detail rows below expanded
+ * rows. Collapsed groups hide everything below them. Groups appear in ascending
+ * order of their value unless the sort model sorts the group column.
+ */
+declare function buildDisplayRows<Row>(rows: readonly Row[], indexes: readonly number[], columns: readonly ColumnDef<Row>[], options: DisplayOptions<Row>): {
+    rows: DisplayRow<Row>[];
+    groups: GroupNode[];
+};
+
+/**
+ * The keyboard model of the grid as a pure function: `(state, key, bounds)`
+ * returns the next state. It knows nothing about the DOM, so it is the same on
+ * the server, in tests and in the component.
+ *
+ * Coordinates are positions in the grid as a screen reader sees it: row 0 is
+ * the header row, rows 1 and up are the body, column 0 is the first column.
+ */
+interface NavState {
+    row: number;
+    col: number;
+}
+interface NavBounds {
+    /** Rows including the header row. */
+    rowCount: number;
+    columnCount: number;
+    /** Rows moved by PageUp and PageDown. Use the number of visible rows. */
+    pageSize: number;
+    /** Right-to-left: ArrowLeft moves forward and ArrowRight moves back. */
+    rtl?: boolean;
+}
+interface NavKeyInput {
+    key: string;
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+    shiftKey?: boolean;
+    altKey?: boolean;
+}
+/** Whether the key is one the model handles, so the caller can stop the page from scrolling. */
+declare function isNavigationKey(input: NavKeyInput): boolean;
+/** Keeps a position inside the grid, for example after rows or columns disappear. */
+declare function clampNav(state: NavState, bounds: NavBounds): NavState;
+/**
+ * Moves the cursor for a key press. Returns the same object when the key is not
+ * a navigation key or the cursor cannot move, so `next === state` means "nothing
+ * to do".
+ *
+ * - Arrow keys move one cell; they stop at the edges (no wrap).
+ * - Home and End jump to the first and last column of the row.
+ * - Ctrl+Home and Ctrl+End jump to the first and last cell of the grid.
+ * - PageUp and PageDown move `pageSize` rows.
+ * - In right-to-left, ArrowLeft and ArrowRight swap.
+ */
+declare function navigate(state: NavState, input: NavKeyInput, bounds: NavBounds): NavState;
+
+/** What a server query depends on. A change to any part throws the cached rows out of date. */
+interface ServerQuery {
+    sort: SortModelItem[];
+    filter: FilterModelItem[];
+    group: GroupModelItem[];
+    quickFilter?: string;
+}
+/** An abort error: what a data source should reject with when its `signal` aborts. */
+declare function createAbortError(message?: string): Error;
+declare function isAbortError(error: unknown): boolean;
+/**
+ * Translates a grid query (which names columns by `id`) into what a server
+ * sees: the data field of each column (`column.field ?? column.id`).
+ */
+declare function toServerQuery<Row>(columns: readonly ColumnDef<Row>[], query: ServerQuery): ServerQuery;
+/** The inverse of `toServerQuery`, for data sources that reuse the headless engine. */
+declare function fromServerQuery<Row>(columns: readonly ColumnDef<Row>[], query: ServerQuery): ServerQuery;
+interface ClientDataSourceOptions {
+    /** Simulated network delay in milliseconds, or a function returning one. Default 0. */
+    latency?: number | (() => number);
+    locale?: string;
+    /** Throw this for requests the function accepts, to exercise error states. */
+    fail?: (request: GetRowsRequest) => unknown;
+}
+/**
+ * A `ServerDataSource` over an in-memory array: it filters, sorts and pages with
+ * the headless engine. Use it to try server mode without a backend, in tests,
+ * and in demos. It honors the `signal` like a real fetch.
+ */
+declare function createClientDataSource<Row>(rows: readonly Row[], columns: readonly ColumnDef<Row>[], options?: ClientDataSourceOptions): ServerDataSource<Row>;
+type BlockStatus = "idle" | "loading" | "loaded" | "error";
+interface ServerStoreSnapshot {
+    /** Changes whenever anything the grid could show changes. */
+    readonly version: number;
+    /** Total rows matching the query, or `null` before the first answer. */
+    readonly total: number | null;
+    /** At least one request is in flight. */
+    readonly loading: boolean;
+    /** The error of the most recent failed request, or `null`. */
+    readonly error: unknown;
+    /**
+     * What is on screen came from before the last query change and is being
+     * replaced: the total, or a block in the rows last asked for. Blocks outside
+     * that window stay stale quietly until they are scrolled to.
+     */
+    readonly stale: boolean;
+}
+interface ServerRowStoreOptions<Row> {
+    dataSource: ServerDataSource<Row>;
+    /** Rows per request. In paged mode use the page size. */
+    blockSize: number;
+    query?: ServerQuery;
+}
+interface ServerRowStore<Row> {
+    subscribe(listener: () => void): () => void;
+    getSnapshot(): ServerStoreSnapshot;
+    /**
+     * Changes what the server is asked for. Requests in flight are aborted. Rows
+     * already loaded stay visible and flagged stale until fresh blocks replace them
+     * (stale-while-revalidate). Returns `false` when the query is unchanged.
+     */
+    setQuery(query: ServerQuery): boolean;
+    /** Changes the rows per request. Cached rows no longer line up, so they are dropped. */
+    setBlockSize(size: number): void;
+    /** Makes sure every block overlapping `[startRow, endRow)` is loaded or loading. */
+    request(startRow: number, endRow: number): void;
+    /** The row at an index, or `undefined` while it is not loaded. Stale rows are returned. */
+    getRow(index: number): Row | undefined;
+    getBlockStatus(index: number): BlockStatus;
+    /** Whether the row at an index is from before the last query change. */
+    isStale(index: number): boolean;
+    /** Requests again every block that failed. */
+    retry(): void;
+    /** Drops everything and loads again from the first block on the next `request`. */
+    reset(): void;
+    /** Aborts requests and stops notifying. */
+    destroy(): void;
+}
+/**
+ * The cache behind server mode: fixed-size blocks, one request per block, an
+ * `AbortSignal` per request, stale-while-revalidate on query changes and retry
+ * for failed blocks. It also follows cursor-paged APIs: when an answer carries
+ * `nextCursor`, later blocks are requested one after another with that cursor.
+ *
+ * It is framework free; React reads it with `useSyncExternalStore`.
+ */
+declare function createServerRowStore<Row>(options: ServerRowStoreOptions<Row>): ServerRowStore<Row>;
+
+type MessageValues = Readonly<Record<string, string | number>>;
+/**
+ * The ICU MessageFormat subset the grid's messages use:
+ *
+ * - `{name}`: the value; numbers are formatted for the locale.
+ * - `{count, plural, =0 {none} one {# row} other {# rows}}`: plural categories
+ *   from `Intl.PluralRules`, exact `=N` matches, and `#` for the number.
+ * - `{kind, select, a {...} other {...}}`: choose by string value.
+ *
+ * Apostrophes are plain characters; there is no quoting. A missing value renders
+ * as an empty string rather than throwing.
+ */
+declare function formatMessage(template: string, values?: MessageValues, locale?: string): string;
+
+export { AggregateName, CellType, ColumnAlign, ColumnDef, ColumnEditor, ColumnFilterType, DEFAULT_COLUMN_MAX_WIDTH, DEFAULT_COLUMN_MIN_WIDTH, DEFAULT_COLUMN_WIDTH, FilterModelItem, FilterOperator, FormatContext, GetRowsRequest, GroupModelItem, OPERATORS_BY_FILTER_TYPE, ServerDataSource, SortDirection, SortModelItem, aggregateValues, buildDisplayRows, buildGroupTree, clampColumnWidth, clampNav, columnFieldName, compareValues, computeAggregate, computeAggregates, computeViewIndexes, createAbortError, createClientDataSource, createCollator, createSearchIndex, createServerRowStore, createValuePredicate, dayStart, distinctValues, filterIndexes, formatMessage, fromServerQuery, getColumnValue, indexColumns, initialColumnWidth, isAbortError, isDateOnlyString, isEditable, isEmptyValue, isFilterEffective, isFilterable, isNavigationKey, isNumericCellType, isResizable, isSearchable, isSortable, isValuelessOperator, matchesFilter, navigate, nextDay, normalizeText, operatorsFor, parseQuickFilter, resolveColumnAlign, resolveEditor, resolveFilterType, sortIndexes, sortRows, toBoolean, toDate, toDayString, toNumber, toServerQuery, toSortKey, toText, toTimestamp };
+export type { AggregateOptions, BlockStatus, ClientDataSourceOptions, DisplayOptions, DisplayRow, FilterContext, FilterIndexesOptions, GroupNode, GroupOptions, MessageValues, NavBounds, NavKeyInput, NavState, ServerQuery, ServerRowStore, ServerRowStoreOptions, ServerStoreSnapshot, SortOptions, ViewOptions };

package/dist/index.js

@@ -0,0 +1,219 @@
+import {
+  DEFAULT_COLUMN_MAX_WIDTH,
+  DEFAULT_COLUMN_MIN_WIDTH,
+  DEFAULT_COLUMN_WIDTH,
+  EMPTY_SELECTION,
+  FILTER_OPERATORS,
+  OPERATORS_BY_FILTER_TYPE,
+  SAVED_VIEW_VERSION,
+  aggregateValues,
+  applySavedView,
+  buildDisplayRows,
+  buildGroupTree,
+  captureView,
+  clampColumnWidth,
+  clampNav,
+  clearSelection,
+  columnFieldName,
+  compareValues,
+  computeAggregate,
+  computeAggregates,
+  computeViewIndexes,
+  countSelected,
+  createAbortError,
+  createCellFormatter,
+  createClientDataSource,
+  createCollator,
+  createLocalStorageSavedViewStore,
+  createMemorySavedViewStore,
+  createSearchIndex,
+  createSelection,
+  createServerRowStore,
+  createValuePredicate,
+  createViewState,
+  dayStart,
+  defaultFormatLabels,
+  defaultMessages,
+  defineColumns,
+  deserializeSelection,
+  distinctValues,
+  escapeCsvField,
+  escapeDelimitedField,
+  exportableColumns,
+  filterIndexes,
+  formatCellValue,
+  formatMessage,
+  fromServerQuery,
+  getColumnValue,
+  gridToCsv,
+  gridToTsv,
+  indexColumns,
+  initialColumnWidth,
+  isAbortError,
+  isDateOnlyString,
+  isEditable,
+  isEmptyValue,
+  isFilterEffective,
+  isFilterable,
+  isNavigationKey,
+  isNumericCellType,
+  isResizable,
+  isSearchable,
+  isSelected,
+  isSelectionEmpty,
+  isSortable,
+  isValuelessOperator,
+  layoutColumns,
+  matchesFilter,
+  moveColumn,
+  moveColumnTo,
+  navigate,
+  nextDay,
+  normalizeText,
+  operatorsFor,
+  parseDelimited,
+  parseQuickFilter,
+  parseSavedView,
+  resizeColumn,
+  resolveColumnAlign,
+  resolveColumnOrder,
+  resolveDateFormatOptions,
+  resolveEditor,
+  resolveFilterType,
+  resolveMessages,
+  resolveNumberFormatOptions,
+  resolveSelectedIds,
+  selectAll,
+  selectAllExceptNone,
+  selectOnly,
+  selectRange,
+  serializeSelection,
+  setColumnFilter,
+  setPinning,
+  setSort,
+  sortIndexes,
+  sortRank,
+  sortRows,
+  summarizeSelection,
+  toBoolean,
+  toDate,
+  toDayString,
+  toNumber,
+  toServerQuery,
+  toSortKey,
+  toText,
+  toTimestamp,
+  toggleGroup,
+  toggleRow,
+  toggleSort
+} from "./chunk-ASP4ABDG.js";
+export {
+  DEFAULT_COLUMN_MAX_WIDTH,
+  DEFAULT_COLUMN_MIN_WIDTH,
+  DEFAULT_COLUMN_WIDTH,
+  EMPTY_SELECTION,
+  FILTER_OPERATORS,
+  OPERATORS_BY_FILTER_TYPE,
+  SAVED_VIEW_VERSION,
+  aggregateValues,
+  applySavedView,
+  buildDisplayRows,
+  buildGroupTree,
+  captureView,
+  clampColumnWidth,
+  clampNav,
+  clearSelection,
+  columnFieldName,
+  compareValues,
+  computeAggregate,
+  computeAggregates,
+  computeViewIndexes,
+  countSelected,
+  createAbortError,
+  createCellFormatter,
+  createClientDataSource,
+  createCollator,
+  createLocalStorageSavedViewStore,
+  createMemorySavedViewStore,
+  createSearchIndex,
+  createSelection,
+  createServerRowStore,
+  createValuePredicate,
+  createViewState,
+  dayStart,
+  defaultFormatLabels,
+  defaultMessages,
+  defineColumns,
+  deserializeSelection,
+  distinctValues,
+  escapeCsvField,
+  escapeDelimitedField,
+  exportableColumns,
+  filterIndexes,
+  formatCellValue,
+  formatMessage,
+  fromServerQuery,
+  getColumnValue,
+  gridToCsv,
+  gridToTsv,
+  indexColumns,
+  initialColumnWidth,
+  isAbortError,
+  isDateOnlyString,
+  isEditable,
+  isEmptyValue,
+  isFilterEffective,
+  isFilterable,
+  isNavigationKey,
+  isNumericCellType,
+  isResizable,
+  isSearchable,
+  isSelected,
+  isSelectionEmpty,
+  isSortable,
+  isValuelessOperator,
+  layoutColumns,
+  matchesFilter,
+  moveColumn,
+  moveColumnTo,
+  navigate,
+  nextDay,
+  normalizeText,
+  operatorsFor,
+  parseDelimited,
+  parseQuickFilter,
+  parseSavedView,
+  resizeColumn,
+  resolveColumnAlign,
+  resolveColumnOrder,
+  resolveDateFormatOptions,
+  resolveEditor,
+  resolveFilterType,
+  resolveMessages,
+  resolveNumberFormatOptions,
+  resolveSelectedIds,
+  selectAll,
+  selectAllExceptNone,
+  selectOnly,
+  selectRange,
+  serializeSelection,
+  setColumnFilter,
+  setPinning,
+  setSort,
+  sortIndexes,
+  sortRank,
+  sortRows,
+  summarizeSelection,
+  toBoolean,
+  toDate,
+  toDayString,
+  toNumber,
+  toServerQuery,
+  toSortKey,
+  toText,
+  toTimestamp,
+  toggleGroup,
+  toggleRow,
+  toggleSort
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}