@one-grid-core/angular 0.1.0-beta.6 → 0.2.0

package/lib/core/instants/one-grid-api.class.d.ts

@@ -1,18 +1,16 @@
-import { OneCellRendererComponent } from '../models/one-tree-data.model';
 import { OneColumnDef } from '../models/one-column-def-types.model';
 import { OneRowNode } from "./one-row-node.class";
-import { OneGridType, OneSortModel } from '../models/one-grid-types.model';
+import { OneGridInitOptions, OneGridType, OneSortModel } from '../models/one-grid-types.model';
 import { OneGridEventService } from '../services/one-grid-event.service';
 import { OneGridSelectionService } from '../services/one-grid-selection.service';
-import { OneValidationResult } from '../models/one-validation.model';
+import { OneRowValidationErrors, OneValidationResult } from '../models/one-validation.model';
 import { OneFilterModel } from "../models/one-filter.model";
 import { OneGridExpansionService } from '../services/one-grid-expansion.service';
-import { OneDetailCellRendererParams, OneGetDetailRowDataParams } from "../models/one-master-detail.model";
+import { OneGetDetailRowDataParams } from "../models/one-master-detail.model";
 import { OneGridRowService } from "../services/one-grid-row.service";
+import { OneRowDragSuppressedReason } from "../models/one-row-drag.model";
 import { OneGridCellService } from '../services/one-grid-cell.service';
-import { Type } from "@angular/core";
-import { ColumnChangedEvent, RowSelectionMode } from "../models/one-event-types.model";
-import { OneGroupColumnDef } from "../models/one-column-def-types.model";
+import { ColumnChangedEvent, OnePinnedRowSide, RowSelectionMode } from "../models/one-event-types.model";
 import { OgColumnService } from "../services/og-column.service";
 import * as i0 from "@angular/core";
 export declare class OneGridApi<T = any> {
@@ -22,18 +20,31 @@ export declare class OneGridApi<T = any> {
     private eventService;
     private selectionService;
     private expansionService;
-    id: string;
-    context: any;
-    rowSelection: RowSelectionMode;
-    apiType: OneGridType;
-    rowNodes: OneRowNode<T>[];
-    sortModel: OneSortModel<T>[];
+    private _id;
+    private _context;
+    private _rowSelection;
+    private _apiType;
+    private _rowNodes;
+    private _sortModel;
+    /** Unique per grid instance, assigned during `init`. */
+    get id(): string;
+    /** The `[context]` the grid was given. */
+    get context(): any;
+    /** Selection mode, captured during `init`. Changing the input later has no effect. */
+    get rowSelection(): RowSelectionMode;
+    /** Which role this instance plays: simple, master, detail or tree. */
+    get apiType(): OneGridType;
+    /** Every node the grid holds, in flattened order. */
+    get rowNodes(): readonly OneRowNode<T>[];
+    /** The sort model currently applied. Change it with `onSortChanged`. */
+    get sortModel(): readonly OneSortModel<T>[];
     private rowHeight;
     private headerRowHeight;
     private _currentIndex;
     private _quickFilterValue;
     private _activeFilters;
     private _visibleRowNodes;
+    private readonly _pinnedRowNodes;
     private _originalRowNodes;
     private _nodeCleanupMap;
     private _destroyed;
@@ -43,17 +54,45 @@ export declare class OneGridApi<T = any> {
     private masterDetail;
     private detailCellRendererParams;
     private detailRendererComponent?;
-    getDetailRowData: (params: OneGetDetailRowDataParams) => void;
+    /**
+     * Supplies a master row's detail rows. Set through `setGetDetailRowData`;
+     * previously a writable public field with a setter beside it, which left two
+     * ways to do the same thing and one of them unchecked.
+     */
+    private _getDetailRowData;
     constructor(columnService: OgColumnService, rowService: OneGridRowService, cellService: OneGridCellService, eventService: OneGridEventService, selectionService: OneGridSelectionService, expansionService: OneGridExpansionService);
-    init(gridApiType: OneGridType, rowSelection: RowSelectionMode, columnDefs: OneColumnDef<T>[], defaultColumnDef: OneColumnDef<T>, context: any, masterDetail: boolean, detailCellRendererParams: OneDetailCellRendererParams, detailRendererComponent: Type<OneCellRendererComponent>, treeData: boolean, groupColumnDefs: OneGroupColumnDef[]): void;
     /**
-     * Create Row Node & Clear All State IDS
+     * Stand the grid up. Called by `OneGridComponent` from `ngOnInit`.
+     *
+     * Takes a single `OneGridInitOptions` rather than the ten positional
+     * arguments it used to, so a call site reads as the configuration it is and
+     * a new option no longer means editing every caller.
+     *
+     * @internal Applications obtain a ready-made API from `(onGridReady)`; they
+     * should never call this themselves.
+     */
+    init(options: OneGridInitOptions<T>): void;
+    /**
+     * Replace every row, discarding selection and expansion.
+     *
+     * Use this when the rows represent something new. To swap the data while
+     * keeping what the user has selected and opened, use `updateRowData`.
      */
     setRowData(rowData: T[]): void;
     /**
-     * Create Row Nodes & Not Clear State IDS
+     * Replace every row, keeping selection and expansion.
+     *
+     * State is keyed by row id, so this only preserves anything if the grid has a
+     * `context.componentParent.getRowId` — otherwise each rebuild mints new ids
+     * and there is nothing left to match against.
      */
     updateRowData(rowData: T[]): void;
+    /**
+     * The one row-loading path. `setRowData` and `updateRowData` differed only in
+     * whether they cleared the state services first, so everything else — build,
+     * filter, prune — lives here once.
+     */
+    private rebuildRows;
     /**
      * Recursive Build Row Nodes (Optimized)
      */
@@ -62,10 +101,77 @@ export declare class OneGridApi<T = any> {
      * Filter Feature
      */
     private applyFilters;
+    /**
+     * Which fields the quick filter searches: every column that has one.
+     *
+     * Empty while the columns are still being registered, in which case the
+     * helper falls back to searching the row — the same behaviour as before, and
+     * the only sensible answer when the grid does not yet know its columns.
+     */
+    private quickFilterFields;
     /**
      * Update Row Nodes Display
      */
     private refreshVisibleNodes;
+    /**
+     * Replace the rows anchored to one edge of the grid.
+     *
+     * Pinned rows are deliberately kept out of `rowNodes` and
+     * `_originalRowNodes`: they are not data. Sorting, filtering, selection,
+     * expansion, pagination and the visible row count all ignore them, which is
+     * the whole point of a summary row. They render with the same column
+     * definitions, so renderers and value getters work as they do everywhere
+     * else.
+     */
+    setPinnedRowData(side: OnePinnedRowSide, rowData: T[]): void;
+    /** The rows anchored to one edge. Read-only; change them with `setPinnedRowData`. */
+    getPinnedRowNodes(side: OnePinnedRowSide): readonly OneRowNode<T>[];
+    /**
+     * Row reordering
+     * --------------------------------------------------------------------------
+     *
+     * `_originalRowNodes` is the source of truth for row order: its insertion
+     * order is what `applySorting` falls back to when the sort model empties, and
+     * what a rebuild walks. `_rowNodes` is only the current display order. A move
+     * that touched one and not the other would either be undone by the next sort
+     * change or invisible until one happened, so both are rewritten together.
+     */
+    /**
+     * Whether the displayed order is the data order, and so whether a manual move
+     * would survive.
+     *
+     * @returns the reason reordering is unavailable, or `null` when it is fine.
+     */
+    getRowDragSuppressedReason(): OneRowDragSuppressedReason | null;
+    /** Convenience inverse of {@link getRowDragSuppressedReason}. */
+    canReorderRows(): boolean;
+    /**
+     * Move a row from one position to another.
+     *
+     * Indices are positions in the grid's row order, the same order
+     * `getAllRowNodes()` returns. `targetIndex` is where the row ends up *after*
+     * it has been lifted out of `sourceIndex` — dragging row 0 to the bottom of a
+     * 5-row grid is `moveRow(0, 4)`, not `moveRow(0, 5)`.
+     *
+     * @returns `true` if the rows moved. `false` when the move was rejected —
+     *          out-of-range indices, a no-op, or an order the grid does not own
+     *          (see {@link getRowDragSuppressedReason}) — so a caller can tell a
+     *          refused move from an applied one.
+     */
+    moveRow(sourceIndex: number, targetIndex: number): boolean;
+    /**
+     * Move a row identified by id. Convenient when the caller holds a node rather
+     * than a position — the index it was built with goes stale after any move.
+     */
+    moveRowById(rowId: string, targetIndex: number): boolean;
+    /**
+     * Re-stamp `rowIndex` from the current order.
+     *
+     * Row index is denormalised onto every node, and half the grid reads it —
+     * cell params, the range selection, the detail lookup. Leaving it stale after
+     * a move puts every row below the drop point one out.
+     */
+    private reindexRows;
     getVisibleRowNodes(): OneRowNode<T>[];
     /**
      * Sorting Model Feature
@@ -101,16 +207,35 @@ export declare class OneGridApi<T = any> {
      */
     setQuickFilter(value: string): void;
     /**
-     * Validation Feature
+     * Run the column validators over one row.
+     *
+     * Rules run in order and stop at the first failure, so a field appears at
+     * most once. Fields that passed are absent rather than mapped to `null`.
+     *
+     * The row type comes from the grid's own `T` — this used to declare its own
+     * `<T>`, which shadowed the class parameter and let an `OneGridApi<Employee>`
+     * happily validate an unrelated shape against employee columns.
+     */
+    validateRow(row: T, columns: OneColumnDef<T>[]): OneRowValidationErrors<T>;
+    /**
+     * Run the column validators over a whole dataset.
+     *
+     * Delegates to `validateRow` so the two can never disagree about what counts
+     * as invalid — they previously carried separate copies of the same loop.
      */
-    validateRow<T>(row: T, columns: OneColumnDef<T>[]): Record<string, string>;
+    validateAllRows(rowData: T[], columns: OneColumnDef<T>[]): OneValidationResult<T>;
     /**
-     * Validate all rows and return both errors and a flag indicating if there are any errors
+     * Traverse every node, depth-first, once each.
+     *
+     * `rowNodes` is already the flattened tree — `buildRowNodes` pushes every
+     * node into it as it descends — so walking it is the whole traversal. The
+     * previous implementation walked that flat list *and* recursed into
+     * `children`, visiting every nested node twice and every depth-3 node three
+     * times. `index` is the node's position in the flattened order, matching
+     * `node.rowIndex`, rather than its position among its siblings.
      */
-    validateAllRows<T>(rowData: T[], columns: OneColumnDef<T>[]): OneValidationResult<T>;
-    /** Traverse all nodes */
     forEachNode(callback: (node: OneRowNode<T>, index: number) => void): void;
-    /** Traverse only leaf nodes */
+    /** Traverse only leaf nodes, once each, in flattened order. */
     forEachLeafNode(callback: (node: OneRowNode<T>, index: number) => void): void;
     getRowNodeById(rowId: string): OneRowNode<T>;
     /**
@@ -118,9 +243,32 @@ export declare class OneGridApi<T = any> {
      */
     setTreeDataChildrenField(field: string): void;
     setGroupDefaultExpanded(defaultExpanded: number): void;
+    /**
+     * Expansion state lives in two places, and they answer different questions.
+     *
+     * `OneGridExpansionService` records only *deliberate* changes — a click, or
+     * one of the methods below. It is an override layer: `buildRowNodes` consults
+     * it first and falls back to `groupDefaultExpanded` for every row the user
+     * has not touched. That is what lets a later `groupDefaultExpanded` change
+     * take effect, and what lets a collapse survive a rebuild.
+     *
+     * `node.expanded` is the resolved truth for a row, defaults included. Public
+     * reads report that; the override sets stay internal.
+     *
+     * The invariant the setters below maintain: `expanded` is only ever true for
+     * a node that can expand.
+     */
     toggleExpandAll(expanded: boolean): void;
     setExpandedById(rowId: string, expanded: boolean): void;
     setExpandedByIds(rowIds: string[], expanded: boolean): void;
+    /**
+     * Every currently expanded row, in tree order.
+     *
+     * Derived from the nodes rather than read off the override record, so rows
+     * opened by `groupDefaultExpanded` are included — previously this returned
+     * only rows someone had explicitly toggled, and came back empty on first load
+     * while the first level was visibly open.
+     */
     getExpandedByIds(): string[];
     /**
      * Master Detail Feature
@@ -138,24 +286,62 @@ export declare class OneGridApi<T = any> {
      * Update checkbox selection features
      */
     setNodeAndChildrenSelected(node: OneRowNode, selected: boolean): void;
+    /**
+     * @deprecated Identical to `updateCellStates`. Kept as an alias so existing
+     * callers keep working; prefer `updateCellStates`, which says what it does.
+     */
     updateNodeStates(node: OneRowNode): void;
     updateCellState(node: OneRowNode, column: OneColumnDef): void;
+    /**
+     * Recompute every cell of one row and repaint it.
+     *
+     * The repaint is the point: this is what a caller reaches for after mutating
+     * a row in place, and it used to regenerate the state and stop there. The
+     * body renders with OnPush, so nothing marked it dirty and the new state sat
+     * unread until some unrelated event happened to trigger change detection —
+     * which is why callers ended up nudging the grid with a synthetic DOM event.
+     */
     updateCellStates(node: OneRowNode): void;
     /**
      * Handler that Reacts to Detail Changes
      */
+    /**
+     * Keep a master row's reserved height in step with its detail rows.
+     *
+     * Two listeners used to be registered here and thrown away: an empty
+     * `rowDataChanged` handler whose unsubscribe was never kept, and an
+     * `expandedChanged` handler whose body was entirely commented out. Both are
+     * gone — a listener with no behaviour is a leak with no upside.
+     */
     private subscribeToDetailChanges;
     private registerNodeCleanup;
     private cleanupNode;
+    /**
+     * Drop nodes that are no longer in the data, releasing what they hold.
+     *
+     * This existed but was never called: `setRowData` and `updateRowData` each
+     * deleted straight out of `_originalRowNodes`, so a removed node kept its
+     * listeners and its entry in `_nodeCleanupMap` for the lifetime of the grid.
+     * Both now come through here, which unsubscribes and clears the node first.
+     */
     private pruneRemovedNodes;
     /**
-     * Resolve Detail Row Height
+     * Height a master row must reserve for its detail grid:
+     * rowHeight x clamp(rows, minRows, maxRows) + headerHeight.
      */
-    private _resolvedDetailRowHeight;
+    private resolveDetailRowHeight;
     /**
-     * On Destroy
+     * Release everything the grid holds. Called by `OneGridComponent.ngOnDestroy`.
+     *
+     * The services are deliberately *not* nulled out any more. They are injected,
+     * Angular owns their lifetime, and nulling them only guaranteed a
+     * `TypeError` for any callback that arrived after teardown — a detail-row
+     * fetch resolving late, or the body's deferred update. `_destroyed` makes
+     * those calls no-ops instead, which is what a torn-down object should do.
      */
     destroy(): void;
+    /** Whether `destroy` has run. Late callbacks check this before doing work. */
+    get destroyed(): boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<OneGridApi<any>, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<OneGridApi<any>>;
 }

package/lib/core/instants/one-row-node.class.d.ts

@@ -2,48 +2,101 @@ import { Type } from "@angular/core";
 import { OneCellOptions, OneCellStates } from "../models/one-column-def-types.model";
 import { OneRowNodeEventMap, OneRowNodeListener } from "../models/one-row.model";
 import { OneCellRendererComponent } from "../models/one-tree-data.model";
+/**
+ * The grid's wrapper around one row of your data.
+ *
+ * A node owns three kinds of state: its identity and position, the structural
+ * facts the grid derived while building the tree, and the per-cell UI state.
+ * `data` is your object, held by reference and mutated in place when a cell is
+ * committed — the node never copies it.
+ *
+ * @typeParam T - the row type
+ * @typeParam D - the detail row type, for master/detail grids
+ */
 export declare class OneRowNode<T = any, D = any> {
-    rowId: string;
+    /**
+     * Stable key for this row, from `context.componentParent.getRowId` or a
+     * generated uuid. Selection, expansion and cell state are all keyed by it,
+     * which is why it never changes for the life of the node.
+     */
+    readonly rowId: string;
+    /** Position in the flattened row list. Reassigned whenever rows are rebuilt. */
     rowIndex: number;
+    /** Your row object, by reference. */
     data: T;
+    /** Depth in the tree. 0 at the root; always 0 outside tree data. */
     level: number;
+    /** Has no children of its own. */
     leaf: boolean;
+    /** Is a group, but an empty one. */
     leafGroup: boolean;
+    /** Has children. */
+    group: boolean;
+    /** Can be opened — a non-empty group, or any row in a master/detail grid. */
+    expandable: boolean;
+    /** Survives the active filters. Recomputed on every filter pass. */
     visible: boolean;
     selected: boolean;
-    expandable: boolean;
     expanded: boolean;
-    group: boolean;
-    submitted: boolean;
     parent: OneRowNode<T> | null;
     children: OneRowNode<T>[] | null;
+    /** Which cells currently have an open editor. */
     editing: {
         [field: string]: boolean;
     };
+    /** Rendered value and kind for each cell, computed when the row is built. */
     cellStates: OneCellStates;
     cellOptions: OneCellOptions;
-    detailRowData: D[];
+    /** Detail rows for this master row. `null` until they have been supplied. */
+    detailRowData: D[] | null;
+    /** Whether the custom detail renderer is showing. Toggled by the row action. */
     detailActive: boolean;
-    detailRowHeight: number;
+    /** Height reserved for the detail area, computed from the detail row count. */
+    detailRowHeight: number | null;
     detailRendererComponent?: Type<OneCellRendererComponent>;
-    private listeners;
+    /**
+     * Listeners per event. Typed as a payload-agnostic callback because the map
+     * is heterogeneous; `on` and `emit` restore the per-event type at the edges.
+     */
+    private readonly listeners;
     constructor(rowId: string, data: T, rowIndex: number);
-    setDataValue(field: string, value: any): void;
+    /**
+     * Write one field of the row and announce it.
+     *
+     * `null` is allowed because that is what the grid itself stores for a cleared
+     * cell; anything else must match the field's declared type.
+     */
+    setDataValue<K extends keyof T & string>(field: K, value: T[K] | null): void;
     setSelected(selected: boolean): void;
     setRowIndex(index: number): void;
     setCellStates(cellStates: OneCellStates): void;
+    /** @deprecated Read `node.selected`. */
     isSelected(): boolean;
+    /** @deprecated Read `node.expanded`. */
     isExpanded(): boolean;
+    /** Supply or replace this master row's detail rows. */
+    setDetailRowData(detailRowData: D[]): void;
+    setExpanded(expanded: boolean): void;
     /**
-     * Event System
+     * Subscribe to one of this node's events.
+     *
+     * @returns an unsubscribe function. Call it, or `destroy()`, to release the
+     *          listener — a node outlives any single render.
      */
     on<K extends keyof OneRowNodeEventMap<T>>(event: K, listener: OneRowNodeListener<T, K>): () => void;
     off<K extends keyof OneRowNodeEventMap<T>>(event: K, listener: OneRowNodeListener<T, K>): void;
-    emit<K extends keyof OneRowNodeEventMap<T>>(event: K, payload: OneRowNodeEventMap<T>[K]): void;
     /**
-      * Mutators that fire events
-      */
-    setDetailRowData(detailRowData: D[]): void;
-    setExpanded(expanded: boolean): void;
+     * Notify listeners. Private on purpose: every event this class publishes is
+     * raised by the mutator that caused it, and a forged `expandedChanged` would
+     * leave the node's flag and the grid's view of it disagreeing.
+     */
+    private emit;
+    /**
+     * Release everything this node holds. Called by the grid when the row leaves
+     * the data or the grid is torn down.
+     *
+     * The tree links matter as much as the listeners: a parent holding children
+     * that hold the parent keeps the whole subtree — and its data — reachable.
+     */
     destroy(): void;
 }

package/lib/core/models/one-column-def-types.model.d.ts

@@ -7,8 +7,10 @@ import type { OneCellRendererComponent } from "./one-tree-data.model";
 export interface OneValueGetterParams<T = any> {
     data: T;
     rowIndex?: number;
+    /** @deprecated Never populated. Use {@link node}. */
     rowNode?: OneRowNode;
     node?: OneRowNode;
+    /** @deprecated Never populated — the cell service has no api reference. */
     api?: OneGridApi;
     context?: any;
 }
@@ -25,6 +27,35 @@ export interface OneCellOptions {
 export type OneCellStatus = 0 | 1;
 export type OneCellButtonIconType = 'add' | 'option' | 'language';
 export type OneCellInputType = 'text' | 'number' | 'email' | 'date' | 'time' | 'datetime' | 'datetime-local';
+/**
+ * What a per-cell presentation callback is handed.
+ *
+ * `OneCellRendererParams` has every field optional, because one type serves
+ * renderers, action buttons and headers alike. For `cellClass` and `cellStyle`
+ * the grid guarantees all of these, so they are required here — otherwise a
+ * consumer under `strict` has to write `params?.data?.x` for a value that is
+ * always present.
+ */
+export interface OneCellPresentationParams<T = any> extends OneCellRendererParams<T> {
+    value: any;
+    data: T;
+    node: OneRowNode<T>;
+    rowIndex: number;
+    field: string;
+    columnDef: OneColumnDef<T>;
+}
+/**
+ * What a header presentation callback is handed.
+ *
+ * Deliberately not the cell params: a header is one cell for the whole column,
+ * resolved once when the columns are registered. There is no row, so offering
+ * `data` or `node` here would be offering something that is always undefined.
+ */
+export interface OneHeaderPresentationParams<T = any> {
+    field: string;
+    columnDef: OneColumnDef<T>;
+    context?: any;
+}
 export interface OneCellRendererParams<T = any> {
     value?: any;
     rowIndex?: number;
@@ -91,6 +122,14 @@ export interface OneColumnDef<T = any> {
     rowActionLevels?: number[];
     headerName?: string;
     checkboxSelection?: boolean;
+    /**
+     * Put a row drag handle in this column's cells. One column carries it.
+     *
+     * A handle rather than the whole row: the body already claims `mousedown`
+     * on a cell to start a range selection, so a row-wide drag would have to
+     * fight it for every press.
+     */
+    rowDrag?: boolean | ((params: OneCellPresentationParams<T>) => boolean);
     headerCheckboxSelection?: boolean;
     flex?: number;
     width?: number;
@@ -99,16 +138,20 @@ export interface OneColumnDef<T = any> {
     validationRules?: OneValidatorFn[];
     headerStyle?: {
         [key: string]: string;
-    } | ((params: OneCellRendererParams<T>) => {
+    } | ((params: OneHeaderPresentationParams<T>) => {
         [key: string]: string;
     });
     cellStyle?: {
         [key: string]: string;
-    } | ((params: OneCellRendererParams<T>) => {
+    } | ((params: OneCellPresentationParams<T>) => {
         [key: string]: string;
     });
-    headerClass?: string | string[] | ((params: OneCellRendererParams<T>) => string | string[]);
-    cellClass?: string | string[] | ((params: OneCellRendererParams<T>) => string | string[]);
+    headerClass?: string | string[] | ((params: OneHeaderPresentationParams<T>) => string | string[]);
+    cellClass?: string | string[] | ((params: OneCellPresentationParams<T>) => string | string[]);
+    _resolvedSortable?: boolean;
+    _resolvedResizable?: boolean;
+    _resolvedDragable?: boolean;
+    _resolvedSuppressHeaderMenuButton?: boolean;
     _resolvedHeaderClass?: string | string[];
     _resolvedCellClass?: string | string[];
     _resolvedHeaderStyle?: Record<string, string>;
@@ -116,21 +159,52 @@ export interface OneColumnDef<T = any> {
     cellRendererParams?: OneCellRendererParams<T>;
     cellOptionMenu?: OneCellOptionMenu[];
     alignContent?: 'left' | 'center' | 'right';
+    /**
+     * Freeze this column against the left or right edge while the rest scroll.
+     *
+     * Pinned columns are moved to their edge in display order — left-pinned to
+     * the front, right-pinned to the back — each keeping its declared order
+     * within its own group. Unpinned columns are untouched, so a grid with
+     * nothing pinned renders exactly as before.
+     */
     pinned?: 'left' | 'right';
-    sortable?: boolean | ((params: OneCellRendererParams<T>) => boolean);
-    resizable?: boolean | ((params: OneCellRendererParams<T>) => boolean);
-    filterable?: boolean | ((params: OneCellRendererParams<T>) => boolean);
-    editable?: boolean | ((params: OneCellRendererParams<T>) => boolean);
-    updatable?: boolean | ((params: OneCellRendererParams<T>) => boolean);
-    disable?: boolean | ((params: OneCellRendererParams<T>) => boolean);
-    dragable?: boolean | ((params: OneCellRendererParams<T>) => boolean);
-    hideActionButton?: boolean | ((params: OneCellRendererParams<T>) => boolean);
-    suppressHeaderMenuButton?: boolean | ((params: OneCellRendererParams<T>) => boolean);
+    /** Distance in px from the pinned edge. Computed by the grid; do not set. */
+    _pinnedOffset?: number | null;
+    /** True on the innermost pinned column of each side, which carries the divider. */
+    _pinnedEdge?: boolean;
+    sortable?: boolean | ((params: OneHeaderPresentationParams<T>) => boolean);
+    resizable?: boolean | ((params: OneHeaderPresentationParams<T>) => boolean);
+    dragable?: boolean | ((params: OneHeaderPresentationParams<T>) => boolean);
+    suppressHeaderMenuButton?: boolean | ((params: OneHeaderPresentationParams<T>) => boolean);
+    editable?: boolean | ((params: OneCellPresentationParams<T>) => boolean);
+    updatable?: boolean | ((params: OneCellPresentationParams<T>) => boolean);
+    disable?: boolean | ((params: OneCellPresentationParams<T>) => boolean);
+    hideActionButton?: boolean | ((params: OneCellPresentationParams<T>) => boolean);
+    /** @deprecated Not implemented — nothing in the grid reads this. */
+    filterable?: boolean | ((params: OneCellPresentationParams<T>) => boolean);
     cellRendererComponent?: Type<OneCellRendererComponent>;
-    cellRenderer?: (params: OneCellRendererParams<T>) => string;
+    cellRenderer?: (params: OneCellPresentationParams<T>) => string;
+    /**
+     * Derive this cell's value from the whole row.
+     *
+     * The value, not the display text — sorting and filtering read the raw row
+     * data, so formatting done here is invisible to both. Put presentation in
+     * `valueFormatter` instead and this stays sortable.
+     */
     valueGetter?: (params: OneValueGetterParams<T>) => any;
+    /**
+     * Format the value for display. Runs after `valueGetter`, on text cells
+     * only — an empty cell falls to `cellRendererParams.placeholder` instead.
+     */
+    valueFormatter?: (params: OneCellPresentationParams<T>) => string;
+    /**
+     * @deprecated Not implemented — nothing in the grid calls this, and the
+     * signature could not work if it did: it receives neither the node nor the
+     * field, so it cannot tell which cell it is meant to write. Commit an edit
+     * through `node.setDataValue(field, value)` and refresh with
+     * `api.updateCellStates(node)`.
+     */
     valueSetter?: (value: any, rowIndex: number) => void;
-    valueFormatter?: (params: OneCellRendererParams<T>) => string;
 }
 export type OneCellValidationType = 'disabled' | 'integer' | 'number' | 'code' | 'title' | 'phone' | 'email' | 'description' | 'regex' | 'none';
 export interface CellSelection {

package/lib/core/models/one-event-types.model.d.ts

@@ -17,6 +17,12 @@ export interface ColumnMovedEvent {
 export interface RowDataChangedEvent<T> {
     nodes: OneRowNode<T>[];
 }
+/** Which edge a set of pinned rows is anchored to. */
+export type OnePinnedRowSide = 'top' | 'bottom';
+export interface PinnedRowDataChangedEvent<T = any> {
+    side: OnePinnedRowSide;
+    nodes: OneRowNode<T>[];
+}
 export interface OneCellOptionMenu {
     text: string;
     value: any;
@@ -60,7 +66,22 @@ export interface ColumnChangedEvent {
 export interface CellStateChangedEvent<T> {
     data: T;
     node: OneRowNode<T>;
-    column: OneColumnDef<T>;
+    /**
+     * The column whose cell changed. Absent when the whole row was refreshed
+     * through `api.updateCellStates(node)`, which regenerates every cell and so
+     * has no single column to name.
+     */
+    column?: OneColumnDef<T>;
+}
+/**
+ * Rows were reordered. Carries the whole new order, because the display order
+ * is what the body renders, plus which row moved for anyone tracking the edit.
+ */
+export interface RowOrderChangedEvent<T = any> {
+    nodes: OneRowNode<T>[];
+    node: OneRowNode<T>;
+    fromIndex: number;
+    toIndex: number;
 }
 export interface EventPayloadMap<T = any> {
     rowSelected: RowSelectedEvent;
@@ -69,8 +90,10 @@ export interface EventPayloadMap<T = any> {
     columnResized: ColumnResizedEvent;
     columnChanged: ColumnChangedEvent;
     rowDataChanged: RowDataChangedEvent<T>;
+    pinnedRowDataChanged: PinnedRowDataChangedEvent<T>;
     selectionChanged: SelectionChangedEvent<T>;
     sortChanged: SortChangedEvent<T>;
+    rowOrderChanged: RowOrderChangedEvent<T>;
     cellStateChanged: CellStateChangedEvent<T>;
 }
 export type OneCheckboxState = 'checked' | 'unchecked' | 'indeterminate';