@bmsuisse/datagrid 0.30.0 → 0.31.1

package/dist/index.d.ts

@@ -668,7 +668,11 @@ declare function BooleanEditor<TRow>({ column, rowId, value, onChange, error, au
 declare function DateEditor<TRow>({ column, rowId, value, onChange, error, autoFocus, }: EditWidgetProps<DateColumn<TRow>>): ReactElement;
 
 /** Default inline editor for `type: "enum"` columns: a single-value select over `column.options`. */
-declare function EnumEditor<TRow>({ column, rowId, value, onChange, error, autoFocus, }: EditWidgetProps<EnumColumn<TRow>>): ReactElement;
+declare function EnumEditor<TRow>({ column, rowId, value, onChange, error, autoFocus, open, onOpenChange, }: EditWidgetProps<EnumColumn<TRow>> & {
+    /** Controls the dropdown's own open state — omit to let `<Select>` manage it itself (the default, used everywhere except `AlwaysEditCell`; see that file's own doc for why it needs control here). */
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}): ReactElement;
 
 /**
  * Default inline editor for a `type: "string"` column with `multiline: true`:
@@ -863,6 +867,18 @@ interface CellEditingOptions<TRow> {
     onCellsChange: (changes: CellChange<TRow>[]) => void | Promise<void>;
     /** Disables all cell-editing interaction — e.g. while a previous gesture's `onCellsChange` is still in flight. Defaults to false. */
     disabled?: boolean;
+    /**
+     * Renders every editable cell's editor directly, all the time — no click,
+     * double-click, F2, or typed character needed to open one first. Selection
+     * (drag/shift+click/shift+arrow), copy, paste, and the fill-handle all
+     * still work exactly as they do without this flag; only the single-cell
+     * "one cell editing at a time" gate is gone, since with this on every
+     * editable cell already IS its own editor. A buffered (string/number/
+     * currency) editor still only commits on blur/Enter/Tab, same as always —
+     * this flag just means it's already open, not that it types straight
+     * through to `onCellsChange` on every keystroke. Defaults to false.
+     */
+    alwaysEdit?: boolean;
 }
 
 /** Maps each id to its position in `ids` — built once per (rowIds|columnIds) identity change, then reused for every lookup during a drag, rather than an O(n) `indexOf` per cell per mousemove. */
@@ -972,7 +988,11 @@ declare function useCellSelection({ rowIds, columnIds, onNavigateToRow }: CellSe
  * table body.
  */
 interface CellEditingCellContext<TRow> {
-    /** The one cell currently showing its editor, or `undefined` — at most one at a time, the same convention `EditingCellContext.activeRowId` uses at row granularity. */
+    /** Mirrors `CellEditingOptions.alwaysEdit` — every editable cell renders `AlwaysEditCell` instead of going through `editingCell`/`onBeginEdit` at all when this is set. */
+    alwaysEdit: boolean;
+    /** Mirrors `CellEditingOptions.disabled`. Click-to-edit mode blocks interaction by simply never opening an editor while this is set (see `onBeginEdit`'s own gate) — `AlwaysEditCell`'s editors are always open regardless, so it reads this directly to disable its rendered form control instead. */
+    disabled: boolean;
+    /** The one cell currently showing its editor, or `undefined` — at most one at a time, the same convention `EditingCellContext.activeRowId` uses at row granularity. Meaningless (always `undefined`) under `alwaysEdit`, where every editable cell already has its own editor. */
     editingCell: CellAddress | undefined;
     /** Replaces (doesn't append to) the editor's starting value when editing began by typing a printable character directly (Excel's "just start typing" gesture) rather than double-click/Enter/F2, which start from the cell's current value. `undefined` means "start from the current value." */
     initialText: string | undefined;
@@ -1015,6 +1035,8 @@ interface CellEditingCellContext<TRow> {
      */
     onCommitValue: (row: TRow, previousValue: unknown, value: unknown) => void;
     onSetError: (rowId: string, columnId: string, message: string | undefined) => void;
+    /** Commits one independently-managed cell's change directly — for `AlwaysEditCell`, which owns its own draft state locally rather than through `editingCell`/`onChangeDraft`/`onCommitEdit`'s single shared slot (every editable cell needs its own simultaneous editor under `alwaysEdit`, not just one at a time). */
+    applyChange: (change: CellChange<TRow>) => void;
     /**
      * Reads (and clears) whether `onCommitEdit`/`onCommitValue` committed
      * synchronously during the current call stack. `<DataGrid>`'s own keydown
@@ -1112,6 +1134,8 @@ declare function SelectionOverlay({ containerRef, range, fillPreviewRange, onFil
  * `null` for `number`/`currency` (pasting a blank cell over a numeric one
  * clears it, matching `NumberEditor`'s own null-for-cleared convention) —
  * `string` columns instead treat an empty string as itself a valid value.
+ * An Excel/Sheets error string (`#N/A`, `#DIV/0!`, etc.) pasted into any
+ * column but `string` is likewise skipped rather than coerced.
  */
 declare function coerceValueForColumn<TRow>(column: ColumnDef<TRow>, raw: string): {
     value: unknown;
@@ -1400,9 +1424,18 @@ interface DataGridProps<TRow> {
     /**
      * Renders the built-in Previous/Next pagination footer. Defaults to true.
      * Set to false when a caller renders its own pagination UI instead (e.g.
-     * one with specific `data-testid`s an existing test suite depends on) —
-     * `<DataGrid>` itself never conditions any other behavior on this, it just
-     * stops rendering that one footer.
+     * one with specific `data-testid`s an existing test suite depends on), or
+     * to disable pagination altogether and render every row.
+     *
+     * When `false` and no explicit `pageSize` is given (via `initialState` or
+     * `gridState`), the effective page size becomes unbounded instead of
+     * defaulting to 20 — hiding the pagination UI with no page size in mind
+     * means "show every row," not "silently truncate to the first page." A
+     * caller who explicitly sets `pageSize` alongside `showPagination: false`
+     * still gets exactly that page size (deliberate fixed-size chunking with
+     * no UI). This only affects `"client"` mode's own row slicing; in
+     * `"server"` mode, whether every row actually comes back is up to your
+     * `dataSource`.
      */
     showPagination?: boolean;
     /**
@@ -1589,8 +1622,18 @@ interface GridStateController {
  * across the component's lifetime — start controlled and stay controlled,
  * or start uncontrolled and stay uncontrolled; toggling to `undefined`
  * later does not hand ownership back, it just stops resyncing.
+ *
+ * `showPagination`, when `false` and the caller did NOT explicitly provide
+ * `initialState.pageSize`, seeds `pageSize` as effectively unbounded instead
+ * of `DEFAULT_STATE`'s 20 — "hide the pagination controls" means "no
+ * pagination" by default, matching `<DataGrid>`'s `showPagination` doc. A
+ * caller who explicitly sets `initialState.pageSize` (deliberate fixed-size
+ * chunking with no UI, alongside `showPagination: false`) still gets exactly
+ * that value; this only changes what happens when they didn't ask for a
+ * particular page size at all. Has no effect once `externalState` is in
+ * play — a controlled `GridState` is always fully caller-specified.
  */
-declare function useGridState<TRow>(dataSource: DataSource<TRow>, initialState?: Partial<GridState>, externalState?: GridState): GridStateController;
+declare function useGridState<TRow>(dataSource: DataSource<TRow>, initialState?: Partial<GridState>, externalState?: GridState, showPagination?: boolean): GridStateController;
 
 interface ClientProcessingResult<TRow> {
     rows: TRow[];