@squirkle-ui/datagrid 0.0.0-stage → 0.1.0

package/dist/types/engine.d.ts

@@ -0,0 +1,53 @@
+import type { AggFunc, CellValue, ColumnDef, DisplayRow, FilterCondition, FilterModel, RowData, SortItem } from './types';
+export declare const colIdOf: <T extends RowData>(c: ColumnDef<T>) => string;
+export declare function makeGetter<T extends RowData>(col: ColumnDef<T>): (row: T) => CellValue;
+export declare function filterKindOf<T extends RowData>(col: ColumnDef<T>): FilterCondition['kind'];
+export declare function matchCondition(value: CellValue, c: FilterCondition): boolean;
+export declare function filterRows<T extends RowData>(rows: T[], columns: ColumnDef<T>[], model: FilterModel, quick: string): number[];
+/** Sorts row indices; keys are extracted once per row (decorate-sort-undecorate). */
+export declare function sortIndices<T extends RowData>(rows: T[], indices: number[], columns: ColumnDef<T>[], sort: SortItem[]): number[];
+export declare function aggregate(values: CellValue[], fn: AggFunc): CellValue;
+export interface GroupNode {
+    key: CellValue;
+    colId: string;
+    id: string;
+    level: number;
+    children: GroupNode[];
+    /** Leaf source indices (in sorted order). */
+    leaves: number[];
+    agg: Record<string, CellValue>;
+}
+/** Groups sorted indices by one or more columns. Group order follows the first occurrence in sorted data. */
+export declare function groupRows<T extends RowData>(rows: T[], indices: number[], columns: ColumnDef<T>[], groupBy: string[]): GroupNode[];
+/** Builds a tree from `getDataPath(row)` (e.g. ['Org', 'Team', 'Alice']); missing parents become filler groups. */
+export declare function treeRows<T extends RowData>(rows: T[], indices: number[], columns: ColumnDef<T>[], getDataPath: (row: T) => string[]): GroupNode[];
+export interface FlattenOptions {
+    expanded: Set<string>;
+    /** Open every group regardless of `expanded` (until the user collapses one). */
+    expandAll?: boolean;
+    collapsed?: Set<string>;
+    rowId: (row: RowData, index: number) => string;
+    detailOpen?: Set<string>;
+    tree?: boolean;
+}
+/** Turns groups (or plain indices) into the displayed row list. */
+export declare function flatten<T extends RowData>(rows: T[], indices: number[], groups: GroupNode[] | null, opts: FlattenOptions): DisplayRow<T>[];
+export declare function allGroupIds(groups: GroupNode[]): string[];
+/** Row offsets for virtualization with mixed row heights (data/group vs. detail). */
+export declare function rowLayout(rows: DisplayRow[], rowHeight: number, detailHeight: number): {
+    offsets: Float64Array<ArrayBuffer>;
+    total: number;
+    indexAt: (y: number) => number;
+};
+/**
+ * Pivot: one output row per combination of `groupBy` values, one column per pivot value × value column.
+ * Returns plain rows plus generated column defs, so the result renders like any other data.
+ */
+export declare function pivotRows<T extends RowData>(rows: T[], indices: number[], columns: ColumnDef<T>[], groupBy: string[], pivotCol: string): {
+    rows: RowData[];
+    columns: ColumnDef<RowData>[];
+};
+/** RFC 4180 CSV. */
+export declare function toCsv(header: string[], body: string[][], sep?: string): string;
+/** Parses tab-separated clipboard text into a 2D array. */
+export declare const parseTsv: (text: string) => string[][];

package/dist/types/index.d.ts

@@ -0,0 +1,6 @@
+import SqDataGrid from './SqDataGrid.vue';
+export { SqDataGrid };
+export declare const componentNames: readonly ["SqDataGrid"];
+export * from './types';
+export * from './engine';
+export default SqDataGrid;

package/dist/types/types.d.ts

@@ -0,0 +1,118 @@
+export type CellValue = unknown;
+export type RowData = Record<string, unknown>;
+export type ColumnType = 'text' | 'number' | 'date' | 'boolean';
+export type FilterKind = 'text' | 'number' | 'date' | 'set';
+export type AggName = 'sum' | 'avg' | 'min' | 'max' | 'count' | 'first' | 'last';
+export type AggFunc = AggName | ((values: CellValue[]) => CellValue);
+export interface CellParams<T = RowData> {
+    value: CellValue;
+    row: T;
+    column: ColumnDef<T>;
+    rowIndex: number;
+}
+export interface ColumnDef<T = RowData> {
+    /** Path into the row (`address.city`). Also the default colId. */
+    field?: string;
+    colId?: string;
+    headerName?: string;
+    /** One-level header group label (adjacent columns with the same group share a header cell). */
+    group?: string;
+    type?: ColumnType;
+    width?: number;
+    minWidth?: number;
+    maxWidth?: number;
+    /** Share of remaining width (like CSS flex-grow). */
+    flex?: number;
+    pinned?: 'left' | 'right' | null;
+    hide?: boolean;
+    sortable?: boolean;
+    resizable?: boolean;
+    /** true = infer from type. */
+    filter?: FilterKind | boolean;
+    /** Show in floating filter row. */
+    floatingFilter?: boolean;
+    editable?: boolean | ((row: T) => boolean);
+    cellEditor?: 'text' | 'number' | 'date' | 'select' | 'checkbox';
+    cellEditorParams?: {
+        values?: CellValue[];
+    };
+    valueGetter?: (row: T) => CellValue;
+    valueSetter?: (row: T, value: CellValue) => void;
+    valueFormatter?: (value: CellValue, row: T) => string;
+    /** Value parser for edited / pasted text. */
+    valueParser?: (text: string, row: T) => CellValue;
+    comparator?: (a: CellValue, b: CellValue, rowA: T, rowB: T) => number;
+    aggFunc?: AggFunc;
+    /** Group rows by this column initially. */
+    rowGroup?: boolean;
+    /** Use as a pivot column (values become columns). */
+    pivot?: boolean;
+    align?: 'left' | 'center' | 'right';
+    cellClass?: string | ((p: CellParams<T>) => string | undefined);
+    cellStyle?: Record<string, string> | ((p: CellParams<T>) => Record<string, string> | undefined);
+    headerClass?: string;
+    tooltip?: boolean | ((p: CellParams<T>) => string);
+    /** Render a checkbox for row selection in this column. */
+    checkboxSelection?: boolean;
+    headerCheckboxSelection?: boolean;
+    lockPosition?: boolean;
+    suppressMenu?: boolean;
+}
+export interface SortItem {
+    colId: string;
+    sort: 'asc' | 'desc';
+}
+export type TextOp = 'contains' | 'notContains' | 'equals' | 'notEqual' | 'startsWith' | 'endsWith' | 'blank' | 'notBlank';
+export type NumberOp = 'equals' | 'notEqual' | 'gt' | 'gte' | 'lt' | 'lte' | 'between' | 'blank' | 'notBlank';
+export interface FilterCondition {
+    kind: FilterKind;
+    op?: TextOp | NumberOp;
+    value?: CellValue;
+    valueTo?: CellValue;
+    /** Set filter: allowed values. */
+    values?: CellValue[];
+}
+export type FilterModel = Record<string, FilterCondition>;
+export interface ColumnState {
+    colId: string;
+    width: number;
+    hide: boolean;
+    pinned: 'left' | 'right' | null;
+}
+export interface DisplayRow<T = RowData> {
+    kind: 'data' | 'group' | 'detail' | 'loading';
+    id: string;
+    data: T | null;
+    level: number;
+    /** Index into the source rows (data rows). */
+    sourceIndex?: number;
+    group?: {
+        key: CellValue;
+        colId: string;
+        count: number;
+        expanded: boolean;
+        agg: Record<string, CellValue>;
+        leafIds: string[];
+    };
+}
+export interface GetRowsParams {
+    startRow: number;
+    endRow: number;
+    sortModel: SortItem[];
+    filterModel: FilterModel;
+    quickFilter: string;
+}
+export interface GetRowsResult<T = RowData> {
+    rows: T[];
+    /** Total row count when known (enables an exact scrollbar). */
+    lastRow?: number;
+}
+export interface Datasource<T = RowData> {
+    getRows: (params: GetRowsParams) => Promise<GetRowsResult<T>>;
+}
+export interface CellRange {
+    startRow: number;
+    endRow: number;
+    startCol: number;
+    endCol: number;
+}