@inandu-solutions/grid-react 0.1.0 → 0.1.2

package/dist/core/tree.d.ts

@@ -1,28 +0,0 @@
-/**
- * Tree-data flattening (#3) — pure, framework-agnostic. Walks a nested-children hierarchy into the
- * flat list of rows that should render right now: a node's children appear directly below it, but
- * only while that node is expanded. Filtering keeps a node when it (or any descendant) matches, and
- * force-expands the ancestors of a match so it's visible; an optional comparator sorts each level.
- */
-export interface TreeVisibleRow<T> {
-    row: T;
-    /** 0 for a root, +1 per level. Drives the first cell's indentation. */
-    depth: number;
-    /** Has at least one (surviving) child — i.e. worth showing a toggle. */
-    expandable: boolean;
-    /** Currently showing its children. */
-    expanded: boolean;
-}
-export interface FlattenTreeOptions<T> {
-    /** A node's children array (or `undefined` / `[]` for a leaf). */
-    getChildren: (row: T) => readonly T[] | undefined;
-    /** Whether `row` is expanded — consulted only when there is no active `match`. */
-    isExpanded: (row: T) => boolean;
-    /** When set, a node survives iff it or a descendant returns `true`; matches render expanded. */
-    match?: (row: T) => boolean;
-    /** Sorts the siblings at every level (applied after filtering). */
-    compare?: (a: T, b: T) => number;
-}
-export declare function flattenTree<T>(roots: readonly T[], options: FlattenTreeOptions<T>): TreeVisibleRow<T>[];
-/** Every node in the hierarchy, depth-first — used for "expand all" / counting. */
-export declare function collectTreeRows<T>(roots: readonly T[], getChildren: (row: T) => readonly T[] | undefined): T[];

package/dist/core/types.d.ts

@@ -1,46 +0,0 @@
-/** How a column's raw cell value is interpreted and formatted. See `InanduColumnComponent.type`. */
-export type InanduColumnType = 'string' | 'number' | 'boolean' | 'date';
-/** Which side of the grid a `sticky="true"` column pins to. See `InanduColumnComponent.stickySide`. */
-export type InanduColumnStickySide = 'left' | 'right';
-/** Aggregate shown in a group's header row when the grid is grouped. See `InanduColumnComponent.aggregate`. */
-export type InanduColumnAggregate = 'sum' | 'avg' | 'min' | 'max' | 'count' | '';
-/** A grid row — a plain bag of field values. The grid never assumes any particular key. */
-export type InanduGridRow = Record<string, unknown>;
-/**
- * The subset of a column definition the pure helpers read, expressed as the signal-getter shape
- * `InanduColumnComponent` already exposes (so an `InanduColumnComponent` instance satisfies this
- * structurally, with no adapter). A non-Angular consumer can pass any object with these five
- * zero-arg accessors — e.g. `{ field: () => 'name', type: () => 'string', ... }`.
- */
-export interface ColumnConfig {
-    field(): string;
-    type(): InanduColumnType;
-    format(): string;
-    order(): number | undefined;
-    aggregate(): InanduColumnAggregate;
-}
-/** Raw values from a single column's filter controls; which keys are used depends on that column's `type`. */
-export interface InanduGridColumnFilterValue {
-    /** `'string'` columns. */
-    text?: string;
-    /** `'number'` columns. */
-    min?: string;
-    max?: string;
-    /** `'date'` columns, `yyyy-mm-dd` (native `<input type="date">` value format). */
-    from?: string;
-    to?: string;
-    /** `'boolean'` columns: `''` (no filter), `'true'`, or `'false'`. */
-    bool?: string;
-    /**
-     * Excel-style "set filter" — an explicit list of the column's own *formatted* display values to
-     * match (OR within the column, same as every other filter key combines with AND across
-     * columns). Works the same regardless of `type` — unlike `text`/`min`/`max`/`from`/`to`/`bool`,
-     * which are each specific to one `type` — since it compares against the already-formatted
-     * string, not the raw value. Whenever this key is *present* (defined) at all, it takes over
-     * matching for the column entirely and the type-specific keys above are ignored — including an
-     * **empty array**, which means "every value unchecked" and matches nothing, not "no
-     * constraint". Omit the key (or set it to `undefined`) for "no constraint" instead. See
-     * `matchesColumnFilter`/`hasMeaningfulFilterValue`.
-     */
-    values?: string[];
-}

package/dist/hooks/useInanduGrid.d.ts

@@ -1,187 +0,0 @@
-import { InanduColumnAggregate, InanduColumnStickySide, InanduColumnType, InanduGridColumnFilterValue, InanduGridRow, TreeVisibleRow } from '../core';
-/**
- * Plain-value column definition for the React API — friendlier than the core's `ColumnConfig`
- * getter shape (`field()`, `type()`, ...), which exists to match grid-angular's signal-based
- * columns. `toColumnConfig` below adapts one to the other so the ported core needs no changes.
- */
-export interface InanduGridColumn {
-    field: string;
-    headerText?: string;
-    type?: InanduColumnType;
-    format?: string;
-    order?: number;
-    aggregate?: InanduColumnAggregate;
-    /** Whether this column can be picked in the "group by" control. Default: true. */
-    groupable?: boolean;
-    /** Whether this field shows an editable control while its row is in edit/add mode. Default: false. */
-    editable?: boolean;
-    required?: boolean;
-    /** `'number'` columns only. */
-    min?: number;
-    /** `'number'` columns only. */
-    max?: number;
-    /** Checked against the raw (unparsed) draft value, `'string'`/`'number'`/`'date'` columns only. */
-    pattern?: string;
-    /** Runs after required/min/max/pattern all pass, against the parsed value and the row's other parsed fields (for cross-field checks). */
-    validator?: (parsed: unknown, parsedRow: Record<string, unknown>) => string | null;
-    /** Runs only once every synchronous rule (above) has already passed for this field; every field's async check runs concurrently. */
-    asyncValidator?: (parsed: unknown, parsedRow: Record<string, unknown>) => Promise<string | null>;
-    /** Whether this column can be hidden via the column-visibility toggle. Default: true. */
-    hideable?: boolean;
-    /** Pins the column to that side of the table, `position: sticky`, regardless of scroll. Unset: not pinned. */
-    pinned?: InanduColumnStickySide;
-    /** Fixed column width in px — also what `stickyOffset`/`stickyOffsetRight` stack against. Default (unset): 80, same fallback grid-angular's `effectiveWidth() || 80` uses. */
-    width?: number;
-    /** Whether this column's header can be dragged to reorder columns. Default: true. */
-    reorder?: boolean;
-}
-/** Passed to `onRowSave` — everything `saveRow()` parsed and validated for one already-existing row. */
-export interface InanduGridRowSave {
-    row: InanduGridRow;
-    values: Record<string, unknown>;
-}
-/** One cell update from a `pasteAt()` call — one entry per pasted cell that landed on an existing row and an editable column. */
-export interface InanduGridCellPaste {
-    row: InanduGridRow;
-    field: string;
-    value: unknown;
-}
-export interface InanduGridSort {
-    field: string;
-    direction: 'asc' | 'desc';
-}
-/** One bucket of `useInanduGrid`'s `groups` — mirrors grid-angular's `groupedRows`. */
-export interface InanduGridGroup {
-    /** The grouped column's *formatted* display value for every row in this bucket. */
-    key: string;
-    rows: InanduGridRow[];
-    /** One entry per column with `aggregate` set, keyed by that column's field. */
-    aggregates: Record<string, number>;
-}
-export interface UseInanduGridOptions {
-    rows: InanduGridRow[];
-    columns: InanduGridColumn[];
-    locale?: string;
-    /** Drives validation-message translation. Default: `locale`'s primary subtag. */
-    lang?: string;
-    /** 0 disables pagination — `visibleRows` is the full sorted/filtered set. Default: 0. */
-    pageSize?: number;
-    /** Whether the caller renders a select-checkbox column — `stickyOffset()` needs to know, since that column (when present) is always sticky-left too. Default: false. */
-    selectable?: boolean;
-    /** `window.confirm()`-gates `deleteRow()`, same as grid-angular. Unset: deletes immediately. */
-    deleteConfirmMessage?: string;
-    /** `window.confirm()`-gates `deleteSelectedRows()`. Unset: deletes immediately. */
-    bulkDeleteConfirmMessage?: string;
-    /** Emitted by `saveRow()` once validation passes — the grid never mutates `rows` itself; applying the change is the caller's job. */
-    onRowSave?: (event: InanduGridRowSave) => void;
-    /** Emitted by `saveNewRow()` once validation passes. No row reference — it doesn't exist in `rows` yet. */
-    onRowCreate?: (values: Record<string, unknown>) => void;
-    /** Emitted by `deleteRow()` (after confirmation, if any). */
-    onRowDelete?: (row: InanduGridRow) => void;
-    /** Emitted by `deleteSelectedRows()` (after confirmation, if any) — every currently-selected row. */
-    onRowsDelete?: (rows: InanduGridRow[]) => void;
-    /** Emitted by `pasteAt()` with every parsed cell update — the grid never mutates `rows` itself. */
-    onCellsPaste?: (updates: InanduGridCellPaste[]) => void;
-    /** Emitted by `onRowDrop()` with the fully reordered row array — the grid never mutates `rows` itself. */
-    onRowOrderChange?: (rows: InanduGridRow[]) => void;
-    /**
-     * Turns on tree mode: the name of the field on each row holding its child rows (a nested array
-     * of the same shape). `rows` is then the root rows; free-text/column filters keep a node when it
-     * or any descendant matches, and the active sort orders each level of siblings. Auto-disabled
-     * while grouped, same restriction grid-angular's `treeChildrenKey` has (there it also excludes
-     * virtual-scroll/server-side, neither of which this port has). Unset (default): tree mode off.
-     */
-    treeChildrenKey?: string;
-    /** Initial expand state for tree mode: `'none'` (default), `'all'`, or a max depth to open to. */
-    treeDefaultExpanded?: 'none' | 'all' | number;
-    /** Whether master-detail is on — the caller checks this itself (by passing a `renderDetail`), this only controls `toggleRowExpanded`'s accordion behavior. Off (any number of rows can be expanded at once) by default. */
-    singleDetailExpand?: boolean;
-    /**
-     * Opt-in row virtualization for large datasets — bypasses pagination entirely (same as grouping),
-     * feeding the windowing logic the full sorted/filtered set instead. Auto-disables grouping,
-     * master-detail, tree data, row drag-reorder and clipboard, same restrictions grid-angular's
-     * `virtualScroll` has (there it also covers server-side infinite-scroll, which this port doesn't
-     * have). The actual DOM windowing (which rows are mounted, given a real scroll position) is the
-     * `<InanduGrid>` component's job, not this hook's — it has no way to observe scroll state itself.
-     */
-    virtualScroll?: boolean;
-}
-/**
- * Headless engine for the grid: owns sort + per-column filter + pagination state and derives
- * `visibleRows` (the current page) and `filteredRowCount` (before pagination) from `rows` using
- * the same pure core as grid-angular. No rendering — `<InanduGrid>` is one consumer of this hook,
- * not the only way to use it.
- */
-export declare function useInanduGrid({ rows, columns, locale, lang, pageSize, selectable, deleteConfirmMessage, bulkDeleteConfirmMessage, onRowSave, onRowCreate, onRowDelete, onRowsDelete, onCellsPaste, onRowOrderChange, treeChildrenKey, treeDefaultExpanded, singleDetailExpand, virtualScroll, }: UseInanduGridOptions): {
-    visibleColumns: InanduGridColumn[];
-    stickyOffset: (field: string) => number;
-    stickyOffsetRight: (field: string) => number;
-    hideableColumns: InanduGridColumn[];
-    isColumnHidden: (field: string) => boolean;
-    toggleColumnVisibility: (field: string) => void;
-    setColumnOrder: (fields: readonly string[]) => void;
-    draggingField: string | undefined;
-    onColumnDragStart: (field: string) => void;
-    onColumnDrop: (targetField: string) => void;
-    effectiveWidth: (field: string) => number;
-    isColumnResized: (field: string) => boolean;
-    setColumnWidth: (field: string, width: number) => void;
-    draggingRow: InanduGridRow | undefined;
-    onRowDragStart: (row: InanduGridRow) => void;
-    onRowDrop: (targetRow: InanduGridRow) => void;
-    hasTreeData: boolean;
-    treeRows: TreeVisibleRow<InanduGridRow>[];
-    isTreeRowExpanded: (row: InanduGridRow) => boolean;
-    toggleTreeRow: (row: InanduGridRow) => void;
-    setAllTreeRowsExpanded: (expanded: boolean) => void;
-    isRowExpanded: (row: InanduGridRow) => boolean;
-    toggleRowExpanded: (row: InanduGridRow) => void;
-    hasVirtualScroll: boolean;
-    visibleRows: InanduGridRow[];
-    /** Same "what's on screen right now" set the select-all checkbox and CSV/Excel/PDF export use — the current page, or every group's rows while grouped. */
-    exportRows: InanduGridRow[];
-    filteredRowCount: number;
-    sortCriteria: InanduGridSort[];
-    setSort: import('react').Dispatch<import('react').SetStateAction<InanduGridSort[]>>;
-    toggleSort: (field: string, additive?: boolean) => void;
-    sortDirectionFor: (field: string) => "asc" | "desc" | undefined;
-    sortPriorityFor: (field: string) => number | undefined;
-    filterValues: Record<string, InanduGridColumnFilterValue>;
-    setFilterValue: (field: string, value: InanduGridColumnFilterValue) => void;
-    filterQuery: string;
-    setFilterQuery: (query: string) => void;
-    page: number;
-    setPage: import('react').Dispatch<import('react').SetStateAction<number>>;
-    pageCount: number;
-    groupByField: string | undefined;
-    setGroupByField: import('react').Dispatch<import('react').SetStateAction<string | undefined>>;
-    groups: InanduGridGroup[] | null;
-    totals: Record<string, number>;
-    selectedRows: Set<InanduGridRow>;
-    isRowSelected: (row: InanduGridRow) => boolean;
-    toggleRowSelection: (row: InanduGridRow) => void;
-    allSelected: boolean;
-    someSelected: boolean;
-    toggleSelectAll: () => void;
-    clearSelection: () => void;
-    editableColumns: InanduGridColumn[];
-    editingRow: InanduGridRow | undefined;
-    isAddingRow: boolean;
-    rowDraft: Record<string, unknown>;
-    fieldErrors: Record<string, string>;
-    isValidating: boolean;
-    isEditingRow: (row: InanduGridRow) => boolean;
-    isAnotherRowEditing: (row: InanduGridRow) => boolean;
-    startEditingRow: (row: InanduGridRow) => void;
-    cancelRowEdit: () => void;
-    setRowDraftValue: (field: string, value: unknown) => void;
-    saveRow: (row: InanduGridRow) => Promise<void>;
-    deleteRow: (row: InanduGridRow) => void;
-    deleteSelectedRows: () => void;
-    startAddingRow: () => void;
-    cancelAddRow: () => void;
-    saveNewRow: () => Promise<void>;
-    validateCell: (column: InanduGridColumn, value: unknown, row?: Record<string, unknown>) => string | null;
-    copyCellText: (rowIndex: number, field: string) => string;
-    pasteAt: (anchorRowIndex: number, anchorField: string, text: string) => void;
-};