@youp-grid/core 0.1.0

package/README.md

@@ -0,0 +1,11 @@
+# @youp-grid/core
+
+Framework-agnostic data grid core for Youp Grid.
+
+```sh
+npm install @youp-grid/core
+```
+
+```ts
+import { buildRowModel, type ColumnDef } from "@youp-grid/core";
+```

package/dist/aggregation.d.ts

@@ -0,0 +1,2 @@
+import type { AggregationResult, AggregationRule, ResolvedColumnDef, RowNode } from "./types.ts";
+export declare function applyAggregation<TRow>(rows: readonly RowNode<TRow>[], columns: readonly ResolvedColumnDef<TRow>[], rules?: readonly AggregationRule[]): AggregationResult[];

package/dist/aggregation.js

@@ -0,0 +1,58 @@
+import { getColumnById } from "./columns.js";
+export function applyAggregation(rows, columns, rules = []) {
+    return rules
+        .map((rule) => {
+        const column = getColumnById(columns, rule.columnId);
+        if (!column) {
+            return undefined;
+        }
+        return aggregateColumn(rows, column, rule);
+    })
+        .filter((result) => Boolean(result));
+}
+function aggregateColumn(rows, column, rule) {
+    const numericValues = getNumericValues(rows, column);
+    return {
+        columnId: column.id,
+        function: rule.function,
+        label: rule.label ?? getAggregationLabel(rule.function),
+        value: getAggregationValue(rule.function, rows.length, numericValues),
+        rowCount: rows.length,
+        valueCount: numericValues.length,
+    };
+}
+function getNumericValues(rows, column) {
+    return rows
+        .map((row) => column.accessor(row.original))
+        .filter((value) => typeof value === "number" && Number.isFinite(value));
+}
+function getAggregationValue(fn, rowCount, values) {
+    switch (fn) {
+        case "count":
+            return rowCount;
+        case "sum":
+            return values.reduce((sum, value) => sum + value, 0);
+        case "avg":
+            return values.length > 0
+                ? values.reduce((sum, value) => sum + value, 0) / values.length
+                : undefined;
+        case "min":
+            return values.length > 0 ? Math.min(...values) : undefined;
+        case "max":
+            return values.length > 0 ? Math.max(...values) : undefined;
+    }
+}
+function getAggregationLabel(fn) {
+    switch (fn) {
+        case "sum":
+            return "Sum";
+        case "avg":
+            return "Avg";
+        case "min":
+            return "Min";
+        case "max":
+            return "Max";
+        case "count":
+            return "Count";
+    }
+}

package/dist/clipboard.d.ts

@@ -0,0 +1,33 @@
+import type { ResolvedColumnDef, RowNode } from "./types.ts";
+export type GridCellCoordinate = {
+    rowIndex: number;
+    columnIndex: number;
+};
+export type GridCellRange = {
+    anchor: GridCellCoordinate;
+    focus: GridCellCoordinate;
+};
+export type NormalizedGridCellRange = {
+    startRowIndex: number;
+    endRowIndex: number;
+    startColumnIndex: number;
+    endColumnIndex: number;
+};
+export type ClipboardPasteCell = GridCellCoordinate & {
+    value: string;
+};
+export declare function normalizeCellRange(range: GridCellRange): NormalizedGridCellRange;
+export declare function isCellInRange(rowIndex: number, columnIndex: number, range: GridCellRange): boolean;
+export declare function serializeGridRange<TRow>(options: {
+    rows: readonly RowNode<TRow>[];
+    columns: readonly ResolvedColumnDef<TRow>[];
+    range: GridCellRange;
+}): string;
+export declare function parseClipboardText(text: string): string[][];
+export declare function getClipboardPasteCells(options: {
+    values: readonly (readonly string[])[];
+    startCell: GridCellCoordinate;
+    rowCount: number;
+    columnCount: number;
+    fillRange?: NormalizedGridCellRange;
+}): ClipboardPasteCell[];

package/dist/clipboard.js

@@ -0,0 +1,79 @@
+export function normalizeCellRange(range) {
+    return {
+        startRowIndex: Math.min(range.anchor.rowIndex, range.focus.rowIndex),
+        endRowIndex: Math.max(range.anchor.rowIndex, range.focus.rowIndex),
+        startColumnIndex: Math.min(range.anchor.columnIndex, range.focus.columnIndex),
+        endColumnIndex: Math.max(range.anchor.columnIndex, range.focus.columnIndex),
+    };
+}
+export function isCellInRange(rowIndex, columnIndex, range) {
+    const normalized = normalizeCellRange(range);
+    return (rowIndex >= normalized.startRowIndex &&
+        rowIndex <= normalized.endRowIndex &&
+        columnIndex >= normalized.startColumnIndex &&
+        columnIndex <= normalized.endColumnIndex);
+}
+export function serializeGridRange(options) {
+    const range = normalizeCellRange(options.range);
+    const lines = [];
+    for (let rowIndex = range.startRowIndex; rowIndex <= range.endRowIndex; rowIndex += 1) {
+        const row = options.rows[rowIndex];
+        if (!row) {
+            continue;
+        }
+        const values = [];
+        for (let columnIndex = range.startColumnIndex; columnIndex <= range.endColumnIndex; columnIndex += 1) {
+            const column = options.columns[columnIndex];
+            const value = column ? column.accessor(row.original) : "";
+            values.push(escapeClipboardCell(formatClipboardValue(value)));
+        }
+        lines.push(values.join("\t"));
+    }
+    return lines.join("\n");
+}
+export function parseClipboardText(text) {
+    const normalizedText = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+    const trimmedText = normalizedText.endsWith("\n") ? normalizedText.slice(0, -1) : normalizedText;
+    if (!trimmedText) {
+        return [];
+    }
+    return trimmedText.split("\n").map((line) => {
+        return line.split("\t").map((cell) => {
+            return cell.replace(/\\n/g, "\n").replace(/\\t/g, "\t").replace(/\\\\/g, "\\");
+        });
+    });
+}
+export function getClipboardPasteCells(options) {
+    if (options.values.length === 0) {
+        return [];
+    }
+    const rowLimit = options.fillRange
+        ? options.fillRange.endRowIndex - options.fillRange.startRowIndex + 1
+        : options.values.length;
+    const columnLimit = options.fillRange
+        ? options.fillRange.endColumnIndex - options.fillRange.startColumnIndex + 1
+        : Math.max(...options.values.map((row) => row.length));
+    const cells = [];
+    for (let rowOffset = 0; rowOffset < rowLimit; rowOffset += 1) {
+        const rowIndex = options.startCell.rowIndex + rowOffset;
+        if (rowIndex < 0 || rowIndex >= options.rowCount) {
+            continue;
+        }
+        for (let columnOffset = 0; columnOffset < columnLimit; columnOffset += 1) {
+            const columnIndex = options.startCell.columnIndex + columnOffset;
+            if (columnIndex < 0 || columnIndex >= options.columnCount) {
+                continue;
+            }
+            const valueRow = options.values[rowOffset % options.values.length] ?? [""];
+            const value = valueRow[columnOffset % Math.max(1, valueRow.length)] ?? "";
+            cells.push({ rowIndex, columnIndex, value });
+        }
+    }
+    return cells;
+}
+function formatClipboardValue(value) {
+    return value == null ? "" : String(value);
+}
+function escapeClipboardCell(value) {
+    return value.replace(/\\/g, "\\\\").replace(/\t/g, "\\t").replace(/\n/g, "\\n");
+}

package/dist/column-state.d.ts

@@ -0,0 +1,7 @@
+import type { ColumnState, GridState, ResolvedColumnDef } from "./types.ts";
+export declare function applyColumnState<TRow>(columns: readonly ResolvedColumnDef<TRow>[], columnStates?: readonly ColumnState[]): ResolvedColumnDef<TRow>[];
+export declare function getVisibleColumns<TRow>(columns: readonly ResolvedColumnDef<TRow>[]): ResolvedColumnDef<TRow>[];
+export declare function setColumnHidden(state: GridState, columnId: string, hidden: boolean): GridState;
+export declare function setColumnWidth(state: GridState, columnId: string, width: number): GridState;
+export declare function setColumnPinned(state: GridState, columnId: string, pinned: ColumnState["pinned"] | undefined): GridState;
+export declare function setColumnOrder(state: GridState, columnIds: readonly string[]): GridState;

package/dist/column-state.js

@@ -0,0 +1,66 @@
+const MIN_COLUMN_WIDTH = 24;
+export function applyColumnState(columns, columnStates = []) {
+    if (columnStates.length === 0) {
+        return [...columns];
+    }
+    const stateById = new Map(columnStates.map((state) => [state.columnId, state]));
+    return columns
+        .map((column, index) => {
+        const state = stateById.get(column.id);
+        return {
+            ...column,
+            hidden: state?.hidden ?? column.hidden,
+            pinned: state?.pinned ?? column.pinned,
+            width: state?.width ?? column.width,
+            order: state?.order ?? index,
+        };
+    })
+        .sort((left, right) => {
+        return (left.order ?? 0) - (right.order ?? 0);
+    })
+        .map(({ order, ...column }) => column);
+}
+export function getVisibleColumns(columns) {
+    return columns.filter((column) => !column.hidden);
+}
+export function setColumnHidden(state, columnId, hidden) {
+    return updateColumnState(state, columnId, { hidden });
+}
+export function setColumnWidth(state, columnId, width) {
+    return updateColumnState(state, columnId, {
+        width: Math.max(MIN_COLUMN_WIDTH, Math.round(width)),
+    });
+}
+export function setColumnPinned(state, columnId, pinned) {
+    return updateColumnState(state, columnId, { pinned });
+}
+export function setColumnOrder(state, columnIds) {
+    const knownColumnIds = new Set(columnIds);
+    const existingStates = (state.columns ?? []).filter((column) => knownColumnIds.has(column.columnId));
+    const statesById = new Map(existingStates.map((column) => [column.columnId, column]));
+    const orderedStates = columnIds.map((columnId, order) => ({
+        ...statesById.get(columnId),
+        columnId,
+        order,
+    }));
+    return {
+        ...state,
+        columns: orderedStates,
+    };
+}
+function updateColumnState(state, columnId, patch) {
+    const columns = state.columns ?? [];
+    const existing = columns.find((column) => column.columnId === columnId);
+    const nextColumnState = {
+        ...existing,
+        columnId,
+        ...patch,
+    };
+    return {
+        ...state,
+        columns: [
+            ...columns.filter((column) => column.columnId !== columnId),
+            nextColumnState,
+        ],
+    };
+}

package/dist/columns.d.ts

@@ -0,0 +1,3 @@
+import type { ColumnDef, ResolvedColumnDef } from "./types.ts";
+export declare function normalizeColumns<TRow>(columns: readonly ColumnDef<TRow>[]): ResolvedColumnDef<TRow>[];
+export declare function getColumnById<TRow>(columns: readonly ResolvedColumnDef<TRow>[], columnId: string): ResolvedColumnDef<TRow> | undefined;

package/dist/columns.js

@@ -0,0 +1,44 @@
+export function normalizeColumns(columns) {
+    const seen = new Set();
+    return columns.map((column) => {
+        const id = resolveColumnId(column);
+        if (seen.has(id)) {
+            throw new Error(`Duplicate grid column id: ${id}`);
+        }
+        seen.add(id);
+        return {
+            ...column,
+            id,
+            headerName: column.headerName ?? id,
+            accessor: column.accessor ?? createFieldAccessor(column.field),
+        };
+    });
+}
+export function getColumnById(columns, columnId) {
+    return columns.find((column) => column.id === columnId);
+}
+function resolveColumnId(column) {
+    if (column.id) {
+        return column.id;
+    }
+    if (column.field) {
+        return String(column.field);
+    }
+    throw new Error("Column requires either `id` or `field`.");
+}
+function createFieldAccessor(field) {
+    if (!field) {
+        throw new Error("Column without `field` requires an explicit `accessor`.");
+    }
+    return (row) => {
+        return getNestedValue(row, String(field));
+    };
+}
+function getNestedValue(row, path) {
+    return path.split(".").reduce((value, key) => {
+        if (value == null || typeof value !== "object") {
+            return undefined;
+        }
+        return value[key];
+    }, row);
+}

package/dist/csv.d.ts

@@ -0,0 +1,15 @@
+import type { ResolvedColumnDef, RowNode } from "./types.ts";
+export type CsvCellFormatter<TRow> = (context: {
+    row: RowNode<TRow>;
+    column: ResolvedColumnDef<TRow>;
+    value: unknown;
+}) => unknown;
+export type ExportGridCsvOptions<TRow> = {
+    rows: readonly RowNode<TRow>[];
+    columns: readonly ResolvedColumnDef<TRow>[];
+    includeHeaders?: boolean;
+    delimiter?: string;
+    lineBreak?: string;
+    formatCell?: CsvCellFormatter<TRow>;
+};
+export declare function exportGridCsv<TRow>(options: ExportGridCsvOptions<TRow>): string;

package/dist/csv.js

@@ -0,0 +1,30 @@
+export function exportGridCsv(options) {
+    const delimiter = options.delimiter ?? ",";
+    const lineBreak = options.lineBreak ?? "\n";
+    const lines = [];
+    if (options.includeHeaders ?? true) {
+        lines.push(options.columns.map((column) => escapeCsvCell(column.headerName, delimiter)).join(delimiter));
+    }
+    for (const row of options.rows) {
+        lines.push(options.columns
+            .map((column) => {
+            const value = column.accessor(row.original);
+            const formattedValue = options.formatCell
+                ? options.formatCell({ row, column, value })
+                : formatCsvValue(column, row.original, value);
+            return escapeCsvCell(formattedValue, delimiter);
+        })
+            .join(delimiter));
+    }
+    return lines.join(lineBreak);
+}
+function formatCsvValue(column, row, value) {
+    return column.valueFormatter ? column.valueFormatter(value, row) : value;
+}
+function escapeCsvCell(value, delimiter) {
+    const text = value == null ? "" : String(value);
+    if (!text.includes(delimiter) && !text.includes("\"") && !text.includes("\n") && !text.includes("\r")) {
+        return text;
+    }
+    return `"${text.replace(/"/g, "\"\"")}"`;
+}

package/dist/fill-handle.d.ts

@@ -0,0 +1,17 @@
+import type { GridCellCoordinate, NormalizedGridCellRange } from "./clipboard.ts";
+export type GridFillHandleCell<TValue = unknown> = GridCellCoordinate & {
+    sourceRowIndex: number;
+    sourceColumnIndex: number;
+    value: TValue;
+};
+export declare function getFillHandleTargetRange(options: {
+    sourceRange: NormalizedGridCellRange;
+    targetCell: GridCellCoordinate;
+    rowCount: number;
+    columnCount: number;
+}): NormalizedGridCellRange | undefined;
+export declare function getFillHandleCells<TValue>(options: {
+    sourceRange: NormalizedGridCellRange;
+    targetRange: NormalizedGridCellRange;
+    getValue: (cell: GridCellCoordinate) => TValue;
+}): GridFillHandleCell<TValue>[];

package/dist/fill-handle.js

@@ -0,0 +1,73 @@
+export function getFillHandleTargetRange(options) {
+    if (options.rowCount === 0 || options.columnCount === 0) {
+        return undefined;
+    }
+    const targetRowIndex = clamp(options.targetCell.rowIndex, 0, options.rowCount - 1);
+    const targetColumnIndex = clamp(options.targetCell.columnIndex, 0, options.columnCount - 1);
+    const range = options.sourceRange;
+    const targetInSourceRows = targetRowIndex >= range.startRowIndex && targetRowIndex <= range.endRowIndex;
+    const targetInSourceColumns = targetColumnIndex >= range.startColumnIndex && targetColumnIndex <= range.endColumnIndex;
+    if (targetInSourceRows && targetInSourceColumns) {
+        return undefined;
+    }
+    if (targetRowIndex > range.endRowIndex) {
+        return {
+            startRowIndex: range.endRowIndex + 1,
+            endRowIndex: targetRowIndex,
+            startColumnIndex: range.startColumnIndex,
+            endColumnIndex: range.endColumnIndex,
+        };
+    }
+    if (targetRowIndex < range.startRowIndex) {
+        return {
+            startRowIndex: targetRowIndex,
+            endRowIndex: range.startRowIndex - 1,
+            startColumnIndex: range.startColumnIndex,
+            endColumnIndex: range.endColumnIndex,
+        };
+    }
+    if (targetColumnIndex > range.endColumnIndex) {
+        return {
+            startRowIndex: range.startRowIndex,
+            endRowIndex: range.endRowIndex,
+            startColumnIndex: range.endColumnIndex + 1,
+            endColumnIndex: targetColumnIndex,
+        };
+    }
+    if (targetColumnIndex < range.startColumnIndex) {
+        return {
+            startRowIndex: range.startRowIndex,
+            endRowIndex: range.endRowIndex,
+            startColumnIndex: targetColumnIndex,
+            endColumnIndex: range.startColumnIndex - 1,
+        };
+    }
+    return undefined;
+}
+export function getFillHandleCells(options) {
+    const sourceRowCount = options.sourceRange.endRowIndex - options.sourceRange.startRowIndex + 1;
+    const sourceColumnCount = options.sourceRange.endColumnIndex - options.sourceRange.startColumnIndex + 1;
+    const cells = [];
+    for (let rowIndex = options.targetRange.startRowIndex; rowIndex <= options.targetRange.endRowIndex; rowIndex += 1) {
+        const sourceRowIndex = options.sourceRange.startRowIndex +
+            ((rowIndex - options.targetRange.startRowIndex) % sourceRowCount);
+        for (let columnIndex = options.targetRange.startColumnIndex; columnIndex <= options.targetRange.endColumnIndex; columnIndex += 1) {
+            const sourceColumnIndex = options.sourceRange.startColumnIndex +
+                ((columnIndex - options.targetRange.startColumnIndex) % sourceColumnCount);
+            cells.push({
+                rowIndex,
+                columnIndex,
+                sourceRowIndex,
+                sourceColumnIndex,
+                value: options.getValue({
+                    rowIndex: sourceRowIndex,
+                    columnIndex: sourceColumnIndex,
+                }),
+            });
+        }
+    }
+    return cells;
+}
+function clamp(value, min, max) {
+    return Math.min(Math.max(value, min), max);
+}

package/dist/filtering.d.ts

@@ -0,0 +1,3 @@
+import type { FilterRule, ResolvedColumnDef, RowNode } from "./types.ts";
+export declare function applyFilters<TRow>(rows: readonly RowNode<TRow>[], columns: readonly ResolvedColumnDef<TRow>[], filters?: readonly FilterRule[]): RowNode<TRow>[];
+export declare function defaultFilterPredicate(value: unknown, filter: FilterRule): boolean;

package/dist/filtering.js

@@ -0,0 +1,68 @@
+import { getColumnById } from "./columns.js";
+export function applyFilters(rows, columns, filters = []) {
+    const activeFilters = filters.filter((filter) => hasUsableFilterValue(filter));
+    if (activeFilters.length === 0) {
+        return [...rows];
+    }
+    return rows.filter((row) => {
+        return activeFilters.every((filter) => {
+            const column = getColumnById(columns, filter.columnId);
+            if (!column) {
+                return true;
+            }
+            const value = column.accessor(row.original);
+            if (column.filterPredicate) {
+                return column.filterPredicate(value, filter, row.original);
+            }
+            return defaultFilterPredicate(value, filter);
+        });
+    });
+}
+export function defaultFilterPredicate(value, filter) {
+    switch (filter.operator) {
+        case "contains":
+            return stringify(value).includes(stringify(filter.value));
+        case "equals":
+            return value === filter.value;
+        case "startsWith":
+            return stringify(value).startsWith(stringify(filter.value));
+        case "endsWith":
+            return stringify(value).endsWith(stringify(filter.value));
+        case "gt":
+            return comparePrimitive(value, filter.value) > 0;
+        case "gte":
+            return comparePrimitive(value, filter.value) >= 0;
+        case "lt":
+            return comparePrimitive(value, filter.value) < 0;
+        case "lte":
+            return comparePrimitive(value, filter.value) <= 0;
+        case "between":
+            return isBetween(value, filter.value);
+        case "isEmpty":
+            return value == null || value === "";
+        case "isNotEmpty":
+            return value != null && value !== "";
+        case "in":
+            return Array.isArray(filter.value) && filter.value.includes(value);
+    }
+}
+function hasUsableFilterValue(filter) {
+    return (filter.operator === "isEmpty" ||
+        filter.operator === "isNotEmpty" ||
+        filter.value !== undefined);
+}
+function stringify(value) {
+    return String(value ?? "").toLocaleLowerCase();
+}
+function comparePrimitive(left, right) {
+    if (typeof left === "number" && typeof right === "number") {
+        return left - right;
+    }
+    return stringify(left).localeCompare(stringify(right));
+}
+function isBetween(value, range) {
+    if (!Array.isArray(range) || range.length !== 2) {
+        return true;
+    }
+    return comparePrimitive(value, range[0]) >= 0 && comparePrimitive(value, range[1]) <= 0;
+}

package/dist/history.d.ts

@@ -0,0 +1,28 @@
+import type { GridRowId } from "./types.ts";
+export type GridCellValueHistoryChange = {
+    rowId: GridRowId;
+    rowIndex: number;
+    columnId: string;
+    previousValue: unknown;
+    value: unknown;
+};
+export type GridValueHistoryEntry = {
+    changes: readonly GridCellValueHistoryChange[];
+};
+export type GridValueHistoryState = {
+    undoStack: GridValueHistoryEntry[];
+    redoStack: GridValueHistoryEntry[];
+};
+export declare function createValueHistoryState(): GridValueHistoryState;
+export declare function pushValueHistoryEntry(state: GridValueHistoryState, entry: GridValueHistoryEntry, options?: {
+    maxEntries?: number;
+}): GridValueHistoryState;
+export declare function undoValueHistory(state: GridValueHistoryState): {
+    state: GridValueHistoryState;
+    entry?: GridValueHistoryEntry;
+};
+export declare function redoValueHistory(state: GridValueHistoryState): {
+    state: GridValueHistoryState;
+    entry?: GridValueHistoryEntry;
+};
+export declare function invertValueHistoryEntry(entry: GridValueHistoryEntry): GridValueHistoryEntry;

package/dist/history.js

@@ -0,0 +1,54 @@
+export function createValueHistoryState() {
+    return {
+        undoStack: [],
+        redoStack: [],
+    };
+}
+export function pushValueHistoryEntry(state, entry, options = {}) {
+    if (entry.changes.length === 0) {
+        return state;
+    }
+    const maxEntries = options.maxEntries ?? 100;
+    const nextEntry = {
+        changes: [...entry.changes],
+    };
+    return {
+        undoStack: [...state.undoStack, nextEntry].slice(-maxEntries),
+        redoStack: [],
+    };
+}
+export function undoValueHistory(state) {
+    const entry = state.undoStack[state.undoStack.length - 1];
+    if (!entry) {
+        return { state };
+    }
+    return {
+        state: {
+            undoStack: state.undoStack.slice(0, -1),
+            redoStack: [...state.redoStack, entry],
+        },
+        entry,
+    };
+}
+export function redoValueHistory(state) {
+    const entry = state.redoStack[state.redoStack.length - 1];
+    if (!entry) {
+        return { state };
+    }
+    return {
+        state: {
+            undoStack: [...state.undoStack, entry],
+            redoStack: state.redoStack.slice(0, -1),
+        },
+        entry,
+    };
+}
+export function invertValueHistoryEntry(entry) {
+    return {
+        changes: entry.changes.map((change) => ({
+            ...change,
+            previousValue: change.value,
+            value: change.previousValue,
+        })),
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+export { applyColumnState, getVisibleColumns, setColumnHidden, setColumnOrder, setColumnPinned, setColumnWidth, } from "./column-state.ts";
+export { applyAggregation } from "./aggregation.ts";
+export { isCellInRange, getClipboardPasteCells, normalizeCellRange, parseClipboardText, serializeGridRange, } from "./clipboard.ts";
+export type { ClipboardPasteCell, GridCellCoordinate, GridCellRange, NormalizedGridCellRange, } from "./clipboard.ts";
+export { getColumnById, normalizeColumns } from "./columns.ts";
+export { getFillHandleCells, getFillHandleTargetRange } from "./fill-handle.ts";
+export type { GridFillHandleCell } from "./fill-handle.ts";
+export { exportGridCsv } from "./csv.ts";
+export type { CsvCellFormatter, ExportGridCsvOptions } from "./csv.ts";
+export { applyFilters, defaultFilterPredicate } from "./filtering.ts";
+export { getInfiniteScrollTrigger } from "./infinite-scroll.ts";
+export { applyPagination } from "./pagination.ts";
+export { buildRowModel } from "./row-model.ts";
+export { applyRowGrouping, isRowGroupNode } from "./row-grouping.ts";
+export { applySorting } from "./sorting.ts";
+export { clearSelection, setRowSelected, setSelectedRows, toggleRowSelected } from "./selection.ts";
+export { clearFilter, clearSort, acknowledgeRemoteCache, cancelRemoteRequest, createRemoteCacheKey, createGridState, failRemoteRequest, finishRemoteRequest, invalidateRemoteCache, isActiveRemoteRequest, setCursorPage, setCursorPageSize, setCursorPagination, setAggregation, setFilter, setPagination, setRemoteCache, setRowGrouping, setSort, startRemoteRequest, toggleRowGroupExpanded, toggleSort, } from "./state.ts";
+export { getVirtualRange } from "./virtualizer.ts";
+export { createValueHistoryState, invertValueHistoryEntry, pushValueHistoryEntry, redoValueHistory, undoValueHistory, } from "./history.ts";
+export type { GridCellValueHistoryChange, GridValueHistoryEntry, GridValueHistoryState, } from "./history.ts";
+export type { Accessor, AggregationFunctionName, AggregationResult, AggregationRule, BuildRowModelOptions, ColumnPin, ColumnState, ColumnComparator, ColumnDef, ColumnFilterPredicate, CursorPaginationState, FilterOperator, FilterRule, GridRowId, GridRowModelType, GridState, InfiniteScrollTrigger, InfiniteScrollTriggerOptions, PaginationState, ResolvedColumnDef, RemoteCacheState, RemoteRequestState, RemoteRequestStatus, RowModel, RowDisplayNode, RowGroupNode, RowGroupingState, RowNode, SortDirection, SortRule, ValueFormatter, ValueParser, VirtualItem, VirtualRange, VirtualRangeOptions, } from "./types.ts";

package/dist/index.js

@@ -0,0 +1,16 @@
+export { applyColumnState, getVisibleColumns, setColumnHidden, setColumnOrder, setColumnPinned, setColumnWidth, } from "./column-state.js";
+export { applyAggregation } from "./aggregation.js";
+export { isCellInRange, getClipboardPasteCells, normalizeCellRange, parseClipboardText, serializeGridRange, } from "./clipboard.js";
+export { getColumnById, normalizeColumns } from "./columns.js";
+export { getFillHandleCells, getFillHandleTargetRange } from "./fill-handle.js";
+export { exportGridCsv } from "./csv.js";
+export { applyFilters, defaultFilterPredicate } from "./filtering.js";
+export { getInfiniteScrollTrigger } from "./infinite-scroll.js";
+export { applyPagination } from "./pagination.js";
+export { buildRowModel } from "./row-model.js";
+export { applyRowGrouping, isRowGroupNode } from "./row-grouping.js";
+export { applySorting } from "./sorting.js";
+export { clearSelection, setRowSelected, setSelectedRows, toggleRowSelected } from "./selection.js";
+export { clearFilter, clearSort, acknowledgeRemoteCache, cancelRemoteRequest, createRemoteCacheKey, createGridState, failRemoteRequest, finishRemoteRequest, invalidateRemoteCache, isActiveRemoteRequest, setCursorPage, setCursorPageSize, setCursorPagination, setAggregation, setFilter, setPagination, setRemoteCache, setRowGrouping, setSort, startRemoteRequest, toggleRowGroupExpanded, toggleSort, } from "./state.js";
+export { getVirtualRange } from "./virtualizer.js";
+export { createValueHistoryState, invertValueHistoryEntry, pushValueHistoryEntry, redoValueHistory, undoValueHistory, } from "./history.js";

package/dist/infinite-scroll.d.ts

@@ -0,0 +1,2 @@
+import type { InfiniteScrollTrigger, InfiniteScrollTriggerOptions } from "./types.ts";
+export declare function getInfiniteScrollTrigger(options: InfiniteScrollTriggerOptions): InfiniteScrollTrigger;