@iris-ui-kit/react 0.3.0 → 0.3.1

package/dist/grid.d.ts

@@ -0,0 +1,324 @@
+import { GridCoreOptions, GridFeature, GridCore, GridFilterValues, GridFilteringModel, GridColumnVisibility, GridColumnWidths, GridColumnPinned, GridColumnPin, GridColumnsModel, GridColumnsState, GridExpansionKey, ExpansionMode, ExpansionModel, GridPaginationChange, GridPaginationModel, GridPaginationState, GridRowKey, GridRowsTransaction, GridRowsModel, SelectionKey, SelectionMode, SortState, GridSortingModel, GridClipboardFeatureOptions, GridClipboardModel, GridEditingFeatureOptions, GridEditingKey, GridEditingValidation, GridEditingCommit, GridEditingModel, GridRangeChange, GridRangeModel, GridVirtualRangeChange, GridVirtualModel } from '@iris-ui-kit/core/grid';
+import { FilterRule, SelectionModel, TableCopyFormat, TableClipboardRange, CellEditState, CellRangeState, CellRange } from '@iris-ui-kit/core';
+
+interface UseGridCoreOptions<Row extends Record<string, unknown>> extends GridCoreOptions<Row> {
+    readonly features?: readonly GridFeature<Row>[];
+}
+/**
+ * React lifecycle bridge for one framework-agnostic Grid Core. Features are
+ * captured on the first render; use `core.use()` for an explicit late install.
+ */
+declare function useGridCore<Row extends Record<string, unknown> = Record<string, unknown>>(options?: UseGridCoreOptions<Row>): GridCore<Row>;
+
+interface GridFilterColumn<Row> {
+    key: string;
+    filterMethod?: (value: unknown, row: Row, filterValue: string) => boolean;
+}
+interface GridFilterQuery {
+    readonly filters: Readonly<Record<string, string>>;
+    readonly inValues: Readonly<Record<string, readonly string[]>>;
+    readonly rules: readonly FilterRule[];
+}
+interface UseGridFilteringOptions<Row, Column extends GridFilterColumn<Row> = GridFilterColumn<Row>> {
+    columns: Column[];
+    getValue: (row: Row, column: Column) => unknown;
+    filters?: Record<string, string>;
+    defaultFilters?: Record<string, string>;
+    onFiltersChange?: (filters: Record<string, string>) => void;
+    filterValues?: GridFilterValues;
+    defaultFilterValues?: GridFilterValues;
+    onFilterValuesChange?: (filterValues: GridFilterValues) => void;
+    /** Treat missing filter props as controlled empty maps. */
+    controlled?: boolean;
+    formFilters?: Record<string, string>;
+    query?: GridFilterQuery;
+    proxy?: boolean;
+    remote?: boolean;
+}
+interface UseGridFilteringResult<Row> {
+    core: GridCore;
+    model: GridFilteringModel;
+    filters: Record<string, string>;
+    filterValues: GridFilterValues;
+    filteredData: Row[];
+}
+/** Installs filtering state in Grid Core and derives the React row view. */
+declare function useGridFiltering<Row extends Record<string, unknown> = Record<string, unknown>, Column extends GridFilterColumn<Row> = GridFilterColumn<Row>>(core: GridCore<Row>, data: Row[], options: UseGridFilteringOptions<Row, Column>): UseGridFilteringResult<Row>;
+
+interface UseGridColumnsOptions {
+    visibility?: GridColumnVisibility;
+    defaultVisibility?: GridColumnVisibility;
+    visibilityControlled?: boolean;
+    onVisibilityChange?: (visibility: GridColumnVisibility) => void;
+    order?: string[];
+    defaultOrder?: string[];
+    /** Keeps the legacy `undefined` order controlled as an empty source-order override. */
+    orderControlled?: boolean;
+    onOrderChange?: (order: string[] | undefined) => void;
+    widths?: GridColumnWidths;
+    defaultWidths?: GridColumnWidths;
+    onWidthsChange?: (widths: GridColumnWidths) => void;
+    pinned?: GridColumnPinned;
+    defaultPinned?: GridColumnPinned;
+    onPinnedChange?: (key: string, side: GridColumnPin) => void;
+}
+interface UseGridColumnsResult {
+    model: GridColumnsModel;
+    state: GridColumnsState;
+    controlled: {
+        visibility: boolean;
+        order: boolean;
+        widths: boolean;
+        pinned: boolean;
+    };
+    setVisibility(visibility: GridColumnVisibility): void;
+    toggleVisibility(key: string): void;
+    setOrder(order: string[] | undefined): void;
+    clearOrder(): void;
+    setWidths(widths: GridColumnWidths): void;
+    setWidth(key: string, width: number): void;
+    resetWidths(): void;
+    setPinned(key: string, side: GridColumnPin): void;
+}
+/** Installs the four column-state channels and mirrors optional controlled props. */
+declare function useGridColumns<Row extends Record<string, unknown> = Record<string, unknown>>(core: GridCore<Row>, options?: UseGridColumnsOptions): UseGridColumnsResult;
+
+interface UseGridExpansionOptions<K extends GridExpansionKey = string> {
+    mode?: ExpansionMode;
+    defaultValue?: K[];
+    onChange?: (keys: K[]) => void;
+    getKeys?: () => readonly K[];
+}
+interface UseGridExpansionResult<K extends GridExpansionKey = string> {
+    core: GridCore;
+    model: ExpansionModel<K>;
+    expandedKeys: K[];
+}
+/** Installs one expansion feature and bridges its store into React. */
+declare function useGridExpansion<Row extends Record<string, unknown> = Record<string, unknown>, K extends GridExpansionKey = string>(core: GridCore<Row>, options?: UseGridExpansionOptions<K>): UseGridExpansionResult<K>;
+
+interface UseGridPaginationOptions {
+    page?: number;
+    defaultPage?: number;
+    pageSize?: number;
+    defaultPageSize?: number;
+    total?: number;
+    defaultTotal?: number;
+    onChange?: (change: GridPaginationChange) => void;
+}
+interface UseGridPaginationResult {
+    model: GridPaginationModel;
+    pagination: GridPaginationState;
+    controlled: boolean;
+    setPage(page: number): void;
+    setPageSize(pageSize: number): void;
+    setPagination(page: number, pageSize: number): void;
+}
+/** Installs pagination in Grid Core and mirrors optional controlled proxy state. */
+declare function useGridPagination<Row extends Record<string, unknown> = Record<string, unknown>>(core: GridCore<Row>, options?: UseGridPaginationOptions): UseGridPaginationResult;
+
+interface UseGridRowsOptions<Row extends Record<string, unknown>, Meta = unknown> {
+    cloneDefaultRows?: boolean;
+    rowKeyField?: string;
+    getRowKey?: (row: Row, index: number) => GridRowKey | undefined;
+    /** Read nested rows when the source is a tree; omitted keeps flat-row semantics. */
+    getChildren?: (row: Row) => readonly Row[] | undefined;
+    /** Replace nested rows immutably when `getChildren` is not a direct property. */
+    setChildren?: (row: Row, children: Row[]) => Row;
+    onBeforeRowsChange?: (transaction: GridRowsTransaction<Row, Meta>) => void;
+    onRowsChange?: (transaction: GridRowsTransaction<Row, Meta>) => void;
+}
+interface UseGridRowsResult<Row extends Record<string, unknown>, Meta = unknown> {
+    model: GridRowsModel<Row, Meta>;
+    rows: Row[];
+}
+/** Installs the single Grid Core row source and bridges it to React rendering. */
+declare function useGridRows<Row extends Record<string, unknown> = Record<string, unknown>, Meta = unknown>(core: GridCore<Row>, initialRows: readonly Row[], options?: UseGridRowsOptions<Row, Meta>): UseGridRowsResult<Row, Meta>;
+
+interface UseGridSelectionOptions<K extends SelectionKey = string> {
+    mode?: SelectionMode;
+    value?: K[];
+    defaultValue?: K[];
+    onChange?: (keys: K[]) => void;
+    getKeys?: () => readonly K[];
+}
+interface UseGridSelectionResult<K extends SelectionKey = string> {
+    core: GridCore;
+    model: SelectionModel<K>;
+    selection: K[];
+    controlled: boolean;
+    /** Rebase mutations on the latest controlled prop before applying them. */
+    rebase(): void;
+}
+/** Selection feature + React controlled/uncontrolled reactivity bridge. */
+declare function useGridSelection<Row extends Record<string, unknown> = Record<string, unknown>, K extends SelectionKey = string>(core: GridCore<Row>, options?: UseGridSelectionOptions<K>): UseGridSelectionResult<K>;
+
+interface GridSortColumn<Row> {
+    key: string;
+    dataIndex?: keyof Row | string;
+    formula?: string;
+    sortable?: boolean;
+    sorter?: (a: Row, b: Row) => number;
+    sortBy?: string;
+    sortType?: 'number' | 'string' | 'auto';
+}
+interface UseGridSortingOptions<Row> {
+    leafColumns: GridSortColumn<Row>[];
+    sort?: SortState | null;
+    defaultSort?: SortState | null;
+    onSortChange?: (next: SortState | null) => void;
+    multiSort?: boolean;
+    multiSortState?: SortState[];
+    defaultMultiSort?: SortState[];
+    onMultiSortChange?: (next: SortState[]) => void;
+    formulaTables?: Record<string, Row[]>;
+}
+interface UseGridSortingResult<Row> {
+    core: GridCore;
+    model: GridSortingModel;
+    sortState: SortState | null;
+    cycleSort: (column: GridSortColumn<Row>) => void;
+    setSort: (next: SortState | null) => void;
+    sortComparator: ((a: Row, b: Row) => number) | null;
+    sortedData: Row[];
+    multiSortState: SortState[];
+    cycleMultiSort: (column: GridSortColumn<Row>) => void;
+    setMultiSort: (next: SortState[]) => void;
+    multiSortComparator: ((a: Row, b: Row) => number) | null;
+}
+/** Installs sorting state in Grid Core and derives React column comparators. */
+declare function useGridSorting<Row extends Record<string, unknown> = Record<string, unknown>>(core: GridCore<Row>, data: Row[], options: UseGridSortingOptions<Row>): UseGridSortingResult<Row>;
+
+interface LegacyGridRowsProps<Row extends Record<string, unknown>, Meta = unknown> {
+    readonly data?: Row[];
+    readonly keepSource?: boolean;
+    readonly rowKeyField?: string;
+    readonly getRowKey?: (row: Row, index: number) => GridRowKey | undefined;
+    readonly getChildren?: UseGridRowsOptions<Row, Meta>['getChildren'];
+    readonly setChildren?: UseGridRowsOptions<Row, Meta>['setChildren'];
+    readonly beforeChange?: UseGridRowsOptions<Row, Meta>['onBeforeRowsChange'];
+    readonly onChange?: UseGridRowsOptions<Row, Meta>['onRowsChange'];
+}
+interface LegacyGridColumnsProps {
+    readonly columnVisibility?: UseGridColumnsOptions['visibility'];
+    readonly onColumnVisibilityChange?: UseGridColumnsOptions['onVisibilityChange'];
+    readonly columnOrder?: UseGridColumnsOptions['order'];
+    readonly onColumnOrderChange?: UseGridColumnsOptions['onOrderChange'];
+    readonly columnWidths?: UseGridColumnsOptions['widths'];
+    readonly defaultColumnWidths?: UseGridColumnsOptions['defaultWidths'];
+    readonly onColumnWidthsChange?: UseGridColumnsOptions['onWidthsChange'];
+    readonly pinnedColumns?: UseGridColumnsOptions['pinned'];
+    readonly onColumnPinnedChange?: UseGridColumnsOptions['onPinnedChange'];
+}
+/** Map the four legacy column channels into one feature boundary. */
+declare function toGridColumnsOptions(props: LegacyGridColumnsProps): UseGridColumnsOptions;
+interface LegacyGridRowsOptions<Row extends Record<string, unknown>, Meta = unknown> {
+    readonly initialRows: Row[];
+    readonly options: UseGridRowsOptions<Row, Meta>;
+}
+/** Map the legacy `data` ownership contract into the rows feature boundary. */
+declare function toGridRowsOptions<Row extends Record<string, unknown>, Meta = unknown>(props: LegacyGridRowsProps<Row, Meta>): LegacyGridRowsOptions<Row, Meta>;
+interface LegacyGridSelectionProps<K extends SelectionKey = string> {
+    readonly selectable?: 'none' | 'single' | 'multi';
+    readonly selection?: K[];
+    readonly defaultSelection?: K[];
+    readonly onSelectionChange?: (keys: K[]) => void;
+}
+/** `none` still uses a dormant multiple model, matching the legacy Table. */
+declare function toGridSelectionOptions<K extends SelectionKey = string>(props: LegacyGridSelectionProps<K>): UseGridSelectionOptions<K>;
+interface LegacyGridExpansionProps<K extends GridExpansionKey = string> {
+    readonly defaultExpandedRowKeys?: readonly K[];
+    readonly onChange?: (keys: string[]) => void;
+}
+declare function toGridExpansionOptions<K extends GridExpansionKey = string>(props: LegacyGridExpansionProps<K>): UseGridExpansionOptions<string>;
+interface LegacyGridPaginationProxyConfig {
+    readonly defaultPage?: number;
+    readonly pageSize?: number;
+    readonly onPageChange?: (page: number, pageSize: number) => void;
+}
+interface LegacyGridPaginationState {
+    readonly page: number;
+    readonly pageSize: number;
+    readonly total: number;
+}
+interface LegacyGridPaginationProps {
+    readonly proxyConfig?: LegacyGridPaginationProxyConfig;
+    readonly state?: LegacyGridPaginationState;
+    readonly request?: (pagination: Pick<LegacyGridPaginationState, 'page' | 'pageSize'>) => void;
+}
+/** Map proxy pagination into a controlled feature; request policy stays outside core. */
+declare function toGridPaginationOptions(props: LegacyGridPaginationProps): UseGridPaginationOptions;
+interface LegacyGridSortingProps<Row extends Record<string, unknown>> {
+    readonly columns: GridSortColumn<Row>[];
+    readonly sort?: UseGridSortingOptions<Row>['sort'];
+    readonly defaultSort?: UseGridSortingOptions<Row>['defaultSort'];
+    readonly onSortChange?: UseGridSortingOptions<Row>['onSortChange'];
+    readonly multiSort?: boolean;
+    readonly multiSortState?: UseGridSortingOptions<Row>['multiSortState'];
+    readonly defaultMultiSort?: UseGridSortingOptions<Row>['defaultMultiSort'];
+    readonly onMultiSortChange?: UseGridSortingOptions<Row>['onMultiSortChange'];
+    readonly formulaTables?: UseGridSortingOptions<Row>['formulaTables'];
+}
+declare function toGridSortingOptions<Row extends Record<string, unknown>>(props: LegacyGridSortingProps<Row>): UseGridSortingOptions<Row>;
+interface LegacyGridFilteringProps<Row extends Record<string, unknown>, Column extends GridFilterColumn<Row>> extends Omit<UseGridFilteringOptions<Row, Column>, 'controlled' | 'proxy' | 'remote'> {
+    readonly proxy?: unknown;
+    readonly remoteFilter?: boolean;
+}
+declare function toGridFilteringOptions<Row extends Record<string, unknown>, Column extends GridFilterColumn<Row>>(props: LegacyGridFilteringProps<Row, Column>): UseGridFilteringOptions<Row, Column>;
+
+type UseGridClipboardOptions<Row extends Record<string, unknown>> = GridClipboardFeatureOptions<Row>;
+interface UseGridClipboardResult<Row extends Record<string, unknown>> {
+    core: GridCore<Row>;
+    model: GridClipboardModel;
+    serialize(format?: TableCopyFormat, copyWithFormat?: boolean): string | null;
+    paste(text: string, range?: TableClipboardRange): boolean;
+}
+/** Installs clipboard pure logic while leaving system clipboard I/O in React. */
+declare function useGridClipboard<Row extends Record<string, unknown> = Record<string, unknown>>(core: GridCore<Row>, options: UseGridClipboardOptions<Row>): UseGridClipboardResult<Row>;
+
+interface UseGridEditingOptions<Row extends Record<string, unknown>> extends Omit<GridEditingFeatureOptions<Row>, 'onStateChange' | 'onCommit'> {
+    onStateChange?: (state: CellEditState<GridEditingKey>) => void;
+    onValidation?: (validation: GridEditingValidation) => void;
+    onCommit?: (commit: GridEditingCommit<Row>) => void;
+}
+interface UseGridEditingResult<Row extends Record<string, unknown>> {
+    core: GridCore<Row>;
+    model: GridEditingModel;
+    state: CellEditState<GridEditingKey>;
+    startCellEdit(rowKey: GridEditingKey, columnKey: string, initialDraft?: unknown): boolean;
+    setCellDraft(value: unknown): void;
+    cancelCellEdit(): void;
+    commitCellEdit(value?: unknown): boolean;
+    isCellEditing(rowKey: GridEditingKey, columnKey: string): boolean;
+}
+/** Installs the framework-independent editing feature and bridges its state. */
+declare function useGridEditing<Row extends Record<string, unknown>>(core: GridCore<Row>, options: UseGridEditingOptions<Row>): UseGridEditingResult<Row>;
+
+interface UseGridRangeOptions {
+    onChange?: (change: GridRangeChange) => void;
+}
+interface UseGridRangeResult<Row extends Record<string, unknown>> {
+    core: GridCore<Row>;
+    model: GridRangeModel;
+    state: CellRangeState;
+    range: CellRange | null;
+}
+/** Installs the range feature and bridges its controller snapshot into React. */
+declare function useGridRange<Row extends Record<string, unknown> = Record<string, unknown>>(core: GridCore<Row>, options?: UseGridRangeOptions): UseGridRangeResult<Row>;
+
+interface UseGridVirtualOptions<Item> {
+    items: readonly Item[];
+    estimateSize: number | ((index: number) => number);
+    viewportSize?: number;
+    scrollOffset?: number;
+    buffer?: number;
+    getItemKey?: (item: Item, index: number) => string | number;
+    onRangeChange?: (change: GridVirtualRangeChange) => void;
+}
+interface UseGridVirtualResult {
+    model: GridVirtualModel;
+}
+/** Installs the virtual window controller; the viewport component remains the DOM bridge. */
+declare function useGridVirtual<Row extends Record<string, unknown> = Record<string, unknown>, Item = Row>(core: GridCore<Row>, options: UseGridVirtualOptions<Item>): UseGridVirtualResult;
+
+export { type GridFilterColumn, type GridFilterQuery, type GridSortColumn, type LegacyGridColumnsProps, type LegacyGridExpansionProps, type LegacyGridFilteringProps, type LegacyGridPaginationProps, type LegacyGridPaginationProxyConfig, type LegacyGridPaginationState, type LegacyGridRowsOptions, type LegacyGridRowsProps, type LegacyGridSelectionProps, type LegacyGridSortingProps, type UseGridClipboardOptions, type UseGridClipboardResult, type UseGridColumnsOptions, type UseGridColumnsResult, type UseGridCoreOptions, type UseGridEditingOptions, type UseGridEditingResult, type UseGridExpansionOptions, type UseGridExpansionResult, type UseGridFilteringOptions, type UseGridFilteringResult, type UseGridPaginationOptions, type UseGridPaginationResult, type UseGridRangeOptions, type UseGridRangeResult, type UseGridRowsOptions, type UseGridRowsResult, type UseGridSelectionOptions, type UseGridSelectionResult, type UseGridSortingOptions, type UseGridSortingResult, type UseGridVirtualOptions, type UseGridVirtualResult, toGridColumnsOptions, toGridExpansionOptions, toGridFilteringOptions, toGridPaginationOptions, toGridRowsOptions, toGridSelectionOptions, toGridSortingOptions, useGridClipboard, useGridColumns, useGridCore, useGridEditing, useGridExpansion, useGridFiltering, useGridPagination, useGridRange, useGridRows, useGridSelection, useGridSorting, useGridVirtual };

package/dist/grid.js

@@ -0,0 +1,5 @@
+'use client'
+export { toGridColumnsOptions, toGridExpansionOptions, toGridFilteringOptions, toGridPaginationOptions, toGridRowsOptions, toGridSelectionOptions, toGridSortingOptions, useGridClipboard, useGridColumns, useGridCore, useGridEditing, useGridExpansion, useGridFiltering, useGridPagination, useGridRange, useGridRows, useGridSelection, useGridSorting, useGridVirtual } from './chunk-3772LKJP.js';
+import './chunk-RZNYIFV2.js';
+//# sourceMappingURL=grid.js.map
+//# sourceMappingURL=grid.js.map

package/dist/grid.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":";","file":"grid.js"}