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

package/esm2022/lib/core/services/og-column.service.mjs

@@ -1,15 +1,22 @@
 import { Injectable } from '@angular/core';
 import { BehaviorSubject } from 'rxjs';
 import lodash from 'lodash';
+import { resolveColumnWidth, resolveOneCellRendererParams } from '../../helpers/one-column-def.helper';
 import * as i0 from "@angular/core";
 export class OgColumnService {
     constructor() {
         this.defaultColumnDef = null;
+        /**
+         * The grid's `context`, so header callbacks receive the same one cell
+         * callbacks do. Set during init; null in a bare service.
+         */
+        this.context = null;
         this.columnDefs$ = new BehaviorSubject([]);
         this.groupColumnDefs$ = new BehaviorSubject([]);
     }
-    initColumnDefs(defaultColumnDef, columnDefs, groupColumnDefs) {
+    initColumnDefs(defaultColumnDef, columnDefs, groupColumnDefs, context = null) {
         this.defaultColumnDef = defaultColumnDef;
+        this.context = context;
         this.setGroupColumnDefs(groupColumnDefs);
         this.setColumnDefs(columnDefs);
     }
@@ -19,7 +26,7 @@ export class OgColumnService {
         return { columns, groups };
     }
     setGroupColumnDefs(groupColumnDefs) {
-        const groups = groupColumnDefs.map((group) => this.resolveGroupPresentation(group));
+        const groups = groupColumnDefs.map((group) => this.resolveGroupPresentation(group, { context: this.context }));
         this.groupColumnDefs$.next(groups);
     }
     setColumnDefs(columnDefs) {
@@ -29,24 +36,86 @@ export class OgColumnService {
                 ...col,
                 id: col?.field ? col.field : lodash.uniqueId('col_'),
             };
-            return this.resolveCellPresentation(column);
+            return this.resolveHeaderPresentation(column);
         });
-        this.recalculateGroups(columns);
-        this.columnDefs$.next(columns);
+        const ordered = this.applyPinning(columns);
+        this.recalculateGroups(ordered);
+        this.columnDefs$.next(ordered);
+    }
+    /**
+     * Move pinned columns to their edge and measure how far in each one sits.
+     *
+     * Display order becomes left-pinned, unpinned, right-pinned, with declared
+     * order preserved inside each band. `_pinnedOffset` is the distance from that
+     * column's own edge — the sum of the widths of the pinned columns outside it
+     * — which is what the sticky `left` / `right` binding needs.
+     *
+     * With nothing pinned this returns the same array, in the same order, so a
+     * grid that does not use the feature is unaffected.
+     */
+    applyPinning(columns) {
+        const left = columns.filter(column => column.pinned === 'left');
+        const right = columns.filter(column => column.pinned === 'right');
+        if (!left.length && !right.length) {
+            for (const column of columns) {
+                column._pinnedOffset = null;
+                column._pinnedEdge = false;
+            }
+            return columns;
+        }
+        const center = columns.filter(column => column.pinned !== 'left' && column.pinned !== 'right');
+        let offset = 0;
+        for (const column of left) {
+            column._pinnedOffset = offset;
+            column._pinnedEdge = false;
+            offset += resolveColumnWidth(column);
+        }
+        // Right-pinned columns are measured from the right edge inwards, so the
+        // last declared one sits flush and the earlier ones stack outside it.
+        offset = 0;
+        for (let index = right.length - 1; index >= 0; index--) {
+            right[index]._pinnedOffset = offset;
+            right[index]._pinnedEdge = false;
+            offset += resolveColumnWidth(right[index]);
+        }
+        for (const column of center) {
+            column._pinnedOffset = null;
+            column._pinnedEdge = false;
+        }
+        // Only the innermost column of each band carries the divider, so stacked
+        // pinned columns do not each cast a shadow onto the next.
+        if (left.length)
+            left[left.length - 1]._pinnedEdge = true;
+        if (right.length)
+            right[0]._pinnedEdge = true;
+        return [...left, ...center, ...right];
+    }
+    /** Total width of the columns frozen against the given edge. */
+    getPinnedWidth(side) {
+        return this.columnDefs$.getValue()
+            .filter(column => column.pinned === side)
+            .reduce((total, column) => total + resolveColumnWidth(column), 0);
     }
     // Update single column
     updateColumnDef(id, changes) {
         const columns = this.getColumnState().columns;
         const updatedColumns = columns.map(col => col.id === id ? { ...col, ...changes } : col);
-        this.recalculateGroups(updatedColumns);
-        this.columnDefs$.next(updatedColumns);
+        // Re-pinned, not just re-grouped: resizing a pinned column changes where
+        // the ones inside it have to sit, and this is the path a column resize
+        // takes.
+        const ordered = this.applyPinning(updatedColumns);
+        this.recalculateGroups(ordered);
+        this.columnDefs$.next(ordered);
     }
     // Reorder columns
     reorderColumnDefs(fromIndex, toIndex) {
         const columns = lodash.clone(this.getColumnState().columns);
         const [moved] = columns.splice(fromIndex, 1);
         columns.splice(toIndex, 0, moved);
-        this.columnDefs$.next(columns);
+        // Dragging can drop a column between two pinned ones; re-pinning puts the
+        // bands back in order rather than leaving them interleaved, which would
+        // make the computed offsets meaningless.
+        this.columnDefs$.next(this.applyPinning(columns));
     }
     /**
      * Group Header Columns
@@ -55,7 +124,7 @@ export class OgColumnService {
         if (this.groupColumnDefs$.getValue().length > 0) {
             const groups = this.groupColumnDefs$.value.map(group => ({
                 ...group,
-                width: columnDefs.filter(c => c.groupId === group.id).reduce((sum, col) => sum + (col.width ? col.width > col.maxWidth ? col.maxWidth : col.width < col.minWidth ? col.minWidth : col.width : col.minWidth), 0)
+                width: columnDefs.filter(c => c.groupId === group.id).reduce((sum, col) => sum + resolveColumnWidth(col), 0)
             }));
             this.groupColumnDefs$.next(groups);
         }
@@ -65,17 +134,55 @@ export class OgColumnService {
         col._resolvedGroupStyle = typeof col.groupStyle === 'function' ? col.groupStyle(params) : col.groupStyle;
         return col;
     }
-    resolveCellPresentation(col, params) {
+    /**
+     * Resolve a column's header presentation. Once per column, when the columns
+     * are set — a header is one cell for the whole column, so there is no row to
+     * resolve it against and nothing to redo per render.
+     *
+     * This used to resolve the cell hooks too, from the same call, with no params
+     * at all. Two bugs came out of that: any callback touching `params` threw a
+     * TypeError at init, and the header's resolved value was then overwritten by
+     * every cell that rendered, since the body re-ran the same method per cell
+     * with row params. In dev mode the disagreement surfaced as NG0100.
+     */
+    resolveHeaderPresentation(col) {
+        const params = {
+            columnDef: col,
+            field: col.field,
+            context: this.context,
+        };
         col._resolvedHeaderClass = typeof col.headerClass === 'function' ? col.headerClass(params) : col.headerClass;
         col._resolvedHeaderStyle = typeof col.headerStyle === 'function' ? col.headerStyle(params) : col.headerStyle;
-        col._resolvedCellClass = typeof col.cellClass === 'function' ? col.cellClass(params) : col.cellClass;
-        col._resolvedCellStyle = typeof col.cellStyle === 'function' ? col.cellStyle(params) : col.cellStyle;
+        // The header's own predicates. Declared as `boolean | ((params) => boolean)`
+        // and read straight off the column in the template, where a function is
+        // simply truthy — so `sortable: () => false` rendered a sort button that a
+        // consumer had explicitly asked not to have. Resolved here to a real
+        // boolean, once, because none of them depends on a row.
+        col._resolvedSortable = resolveOneCellRendererParams(col.sortable, params);
+        col._resolvedResizable = resolveOneCellRendererParams(col.resizable, params);
+        col._resolvedDragable = resolveOneCellRendererParams(col.dragable, params);
+        col._resolvedSuppressHeaderMenuButton = resolveOneCellRendererParams(col.suppressHeaderMenuButton, params);
         return col;
     }
+    /**
+     * Resolve one cell's class, for one row.
+     *
+     * Pure: the result is returned rather than written back onto the column def,
+     * which every row of that column shares. Writing to it worked only because
+     * the template resolved and read in the same expression — one render order
+     * away from every row showing the last row's class.
+     */
+    resolveCellClass(col, params) {
+        return typeof col?.cellClass === 'function' ? col.cellClass(params) : col?.cellClass;
+    }
+    /** Resolve one cell's inline style, for one row. Pure, as above. */
+    resolveCellStyle(col, params) {
+        return typeof col?.cellStyle === 'function' ? col.cellStyle(params) : col?.cellStyle;
+    }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: OgColumnService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: OgColumnService }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: OgColumnService, decorators: [{
             type: Injectable
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"og-column.service.js","sourceRoot":"","sources":["../../../../../../projects/one-grid/src/lib/core/services/og-column.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { BehaviorSubject } from 'rxjs';\nimport { OneCellRendererParams, OneColumnDef, OneGroupColumnDef } from '../models/one-column-def-types.model';\nimport lodash from 'lodash';\nimport { ColumnChangedEvent } from '../models/one-event-types.model';\n\n@Injectable()\nexport class OgColumnService {\n\n  private defaultColumnDef: OneColumnDef = null;\n  private columnDefs$ = new BehaviorSubject<OneColumnDef[]>([]);\n  private groupColumnDefs$ = new BehaviorSubject<OneGroupColumnDef[]>([]);\n\n  initColumnDefs(defaultColumnDef: OneColumnDef, columnDefs: OneColumnDef[], groupColumnDefs: OneGroupColumnDef[]): void {\n\n    this.defaultColumnDef = defaultColumnDef;\n\n    this.setGroupColumnDefs(groupColumnDefs);\n    \n    this.setColumnDefs(columnDefs);\n  }\n\n  getColumnState(): ColumnChangedEvent {\n\n    const columns = this.columnDefs$.getValue();\n\n    const groups = this.groupColumnDefs$.getValue();\n\n    return { columns, groups };\n  }\n\n  setGroupColumnDefs(groupColumnDefs: OneGroupColumnDef[]): void {\n\n    const groups = groupColumnDefs.map((group: OneGroupColumnDef) => this.resolveGroupPresentation(group));\n\n    this.groupColumnDefs$.next(groups);\n  }\n\n  setColumnDefs(columnDefs: OneColumnDef[]): void {\n\n    const columns = columnDefs.map((col: OneColumnDef) => {\n\n      const column = {\n        ...this.defaultColumnDef,\n        ...col,\n        id: col?.field ? col.field : lodash.uniqueId('col_'),\n      };\n\n      return this.resolveCellPresentation(column);\n    });\n\n    this.recalculateGroups(columns);\n\n    this.columnDefs$.next(columns);\n  }\n\n  // Update single column\n  updateColumnDef(id: string, changes: Partial<OneColumnDef>): void {\n\n    const columns = this.getColumnState().columns;\n\n    const updatedColumns = columns.map(col => col.id === id ? { ...col, ...changes } : col);\n\n    this.recalculateGroups(updatedColumns);\n    \n    this.columnDefs$.next(updatedColumns);\n  }\n\n  // Reorder columns\n  reorderColumnDefs(fromIndex: number, toIndex: number): void {\n\n    const columns = lodash.clone(this.getColumnState().columns);\n\n    const [moved] = columns.splice(fromIndex, 1);\n\n    columns.splice(toIndex, 0, moved);\n\n    this.columnDefs$.next(columns);\n  }\n\n  /**\n   * Group Header Columns\n   */\n  private recalculateGroups(columnDefs: OneColumnDef[]) {\n\n    if (this.groupColumnDefs$.getValue().length > 0) {\n\n      const groups = this.groupColumnDefs$.value.map(group => ({\n        ...group,\n        width: columnDefs.filter(c => c.groupId === group.id).reduce((sum, col) => sum + (col.width ? col.width > col.maxWidth ? col.maxWidth : col.width < col.minWidth ? col.minWidth : col.width : col.minWidth), 0)\n      }));\n\n      this.groupColumnDefs$.next(groups);\n    }\n  }\n\n  resolveGroupPresentation(col: OneGroupColumnDef, params?: OneCellRendererParams): OneGroupColumnDef {\n\n    col._resolvedGroupClass = typeof col.groupClass === 'function' ? col.groupClass(params) : col.groupClass;\n    col._resolvedGroupStyle = typeof col.groupStyle === 'function' ? col.groupStyle(params) : col.groupStyle;\n\n    return col;\n  }\n\n  resolveCellPresentation(col: OneColumnDef, params?: OneCellRendererParams): OneColumnDef {\n\n    col._resolvedHeaderClass = typeof col.headerClass === 'function' ? col.headerClass(params) : col.headerClass;\n    col._resolvedHeaderStyle = typeof col.headerStyle === 'function' ? col.headerStyle(params) : col.headerStyle;\n\n    col._resolvedCellClass = typeof col.cellClass === 'function' ? col.cellClass(params) : col.cellClass;\n    col._resolvedCellStyle = typeof col.cellStyle === 'function' ? col.cellStyle(params) : col.cellStyle;\n\n    return col;\n  }\n}"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"og-column.service.js","sourceRoot":"","sources":["../../../../../../projects/one-grid/src/lib/core/services/og-column.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { BehaviorSubject } from 'rxjs';\nimport { OneCellPresentationParams, OneCellRendererParams, OneColumnDef, OneGroupColumnDef, OneHeaderPresentationParams } from '../models/one-column-def-types.model';\nimport lodash from 'lodash';\nimport { ColumnChangedEvent } from '../models/one-event-types.model';\nimport { resolveColumnWidth, resolveOneCellRendererParams } from '../../helpers/one-column-def.helper';\n\n@Injectable()\nexport class OgColumnService {\n\n  private defaultColumnDef: OneColumnDef = null;\n\n  /**\n   * The grid's `context`, so header callbacks receive the same one cell\n   * callbacks do. Set during init; null in a bare service.\n   */\n  private context: unknown = null;\n  private columnDefs$ = new BehaviorSubject<OneColumnDef[]>([]);\n  private groupColumnDefs$ = new BehaviorSubject<OneGroupColumnDef[]>([]);\n\n  initColumnDefs(defaultColumnDef: OneColumnDef, columnDefs: OneColumnDef[], groupColumnDefs: OneGroupColumnDef[], context: unknown = null): void {\n\n    this.defaultColumnDef = defaultColumnDef;\n\n    this.context = context;\n\n    this.setGroupColumnDefs(groupColumnDefs);\n    \n    this.setColumnDefs(columnDefs);\n  }\n\n  getColumnState(): ColumnChangedEvent {\n\n    const columns = this.columnDefs$.getValue();\n\n    const groups = this.groupColumnDefs$.getValue();\n\n    return { columns, groups };\n  }\n\n  setGroupColumnDefs(groupColumnDefs: OneGroupColumnDef[]): void {\n\n    const groups = groupColumnDefs.map((group: OneGroupColumnDef) => this.resolveGroupPresentation(group, { context: this.context }));\n\n    this.groupColumnDefs$.next(groups);\n  }\n\n  setColumnDefs(columnDefs: OneColumnDef[]): void {\n\n    const columns = columnDefs.map((col: OneColumnDef) => {\n\n      const column = {\n        ...this.defaultColumnDef,\n        ...col,\n        id: col?.field ? col.field : lodash.uniqueId('col_'),\n      };\n\n      return this.resolveHeaderPresentation(column);\n    });\n\n    const ordered = this.applyPinning(columns);\n\n    this.recalculateGroups(ordered);\n\n    this.columnDefs$.next(ordered);\n  }\n\n  /**\n   * Move pinned columns to their edge and measure how far in each one sits.\n   *\n   * Display order becomes left-pinned, unpinned, right-pinned, with declared\n   * order preserved inside each band. `_pinnedOffset` is the distance from that\n   * column's own edge — the sum of the widths of the pinned columns outside it\n   * — which is what the sticky `left` / `right` binding needs.\n   *\n   * With nothing pinned this returns the same array, in the same order, so a\n   * grid that does not use the feature is unaffected.\n   */\n  private applyPinning(columns: OneColumnDef[]): OneColumnDef[] {\n\n    const left = columns.filter(column => column.pinned === 'left');\n    const right = columns.filter(column => column.pinned === 'right');\n\n    if (!left.length && !right.length) {\n\n      for (const column of columns) {\n\n        column._pinnedOffset = null;\n        column._pinnedEdge = false;\n      }\n\n      return columns;\n    }\n\n    const center = columns.filter(column => column.pinned !== 'left' && column.pinned !== 'right');\n\n    let offset = 0;\n\n    for (const column of left) {\n\n      column._pinnedOffset = offset;\n      column._pinnedEdge = false;\n\n      offset += resolveColumnWidth(column);\n    }\n\n    // Right-pinned columns are measured from the right edge inwards, so the\n    // last declared one sits flush and the earlier ones stack outside it.\n    offset = 0;\n\n    for (let index = right.length - 1; index >= 0; index--) {\n\n      right[index]._pinnedOffset = offset;\n      right[index]._pinnedEdge = false;\n\n      offset += resolveColumnWidth(right[index]);\n    }\n\n    for (const column of center) {\n\n      column._pinnedOffset = null;\n      column._pinnedEdge = false;\n    }\n\n    // Only the innermost column of each band carries the divider, so stacked\n    // pinned columns do not each cast a shadow onto the next.\n    if (left.length) left[left.length - 1]._pinnedEdge = true;\n    if (right.length) right[0]._pinnedEdge = true;\n\n    return [...left, ...center, ...right];\n  }\n\n  /** Total width of the columns frozen against the given edge. */\n  public getPinnedWidth(side: 'left' | 'right'): number {\n\n    return this.columnDefs$.getValue()\n      .filter(column => column.pinned === side)\n      .reduce((total, column) => total + resolveColumnWidth(column), 0);\n  }\n\n  // Update single column\n  updateColumnDef(id: string, changes: Partial<OneColumnDef>): void {\n\n    const columns = this.getColumnState().columns;\n\n    const updatedColumns = columns.map(col => col.id === id ? { ...col, ...changes } : col);\n\n    // Re-pinned, not just re-grouped: resizing a pinned column changes where\n    // the ones inside it have to sit, and this is the path a column resize\n    // takes.\n    const ordered = this.applyPinning(updatedColumns);\n\n    this.recalculateGroups(ordered);\n\n    this.columnDefs$.next(ordered);\n  }\n\n  // Reorder columns\n  reorderColumnDefs(fromIndex: number, toIndex: number): void {\n\n    const columns = lodash.clone(this.getColumnState().columns);\n\n    const [moved] = columns.splice(fromIndex, 1);\n\n    columns.splice(toIndex, 0, moved);\n\n    // Dragging can drop a column between two pinned ones; re-pinning puts the\n    // bands back in order rather than leaving them interleaved, which would\n    // make the computed offsets meaningless.\n    this.columnDefs$.next(this.applyPinning(columns));\n  }\n\n  /**\n   * Group Header Columns\n   */\n  private recalculateGroups(columnDefs: OneColumnDef[]) {\n\n    if (this.groupColumnDefs$.getValue().length > 0) {\n\n      const groups = this.groupColumnDefs$.value.map(group => ({\n        ...group,\n        width: columnDefs.filter(c => c.groupId === group.id).reduce((sum, col) => sum + resolveColumnWidth(col), 0)\n      }));\n\n      this.groupColumnDefs$.next(groups);\n    }\n  }\n\n  resolveGroupPresentation(col: OneGroupColumnDef, params?: OneCellRendererParams): OneGroupColumnDef {\n\n    col._resolvedGroupClass = typeof col.groupClass === 'function' ? col.groupClass(params) : col.groupClass;\n    col._resolvedGroupStyle = typeof col.groupStyle === 'function' ? col.groupStyle(params) : col.groupStyle;\n\n    return col;\n  }\n\n  /**\n   * Resolve a column's header presentation. Once per column, when the columns\n   * are set — a header is one cell for the whole column, so there is no row to\n   * resolve it against and nothing to redo per render.\n   *\n   * This used to resolve the cell hooks too, from the same call, with no params\n   * at all. Two bugs came out of that: any callback touching `params` threw a\n   * TypeError at init, and the header's resolved value was then overwritten by\n   * every cell that rendered, since the body re-ran the same method per cell\n   * with row params. In dev mode the disagreement surfaced as NG0100.\n   */\n  resolveHeaderPresentation(col: OneColumnDef): OneColumnDef {\n\n    const params: OneHeaderPresentationParams = {\n      columnDef: col,\n      field: col.field as string,\n      context: this.context,\n    };\n\n    col._resolvedHeaderClass = typeof col.headerClass === 'function' ? col.headerClass(params) : col.headerClass;\n    col._resolvedHeaderStyle = typeof col.headerStyle === 'function' ? col.headerStyle(params) : col.headerStyle;\n\n    // The header's own predicates. Declared as `boolean | ((params) => boolean)`\n    // and read straight off the column in the template, where a function is\n    // simply truthy — so `sortable: () => false` rendered a sort button that a\n    // consumer had explicitly asked not to have. Resolved here to a real\n    // boolean, once, because none of them depends on a row.\n    col._resolvedSortable = resolveOneCellRendererParams(col.sortable, params);\n    col._resolvedResizable = resolveOneCellRendererParams(col.resizable, params);\n    col._resolvedDragable = resolveOneCellRendererParams(col.dragable, params);\n    col._resolvedSuppressHeaderMenuButton = resolveOneCellRendererParams(col.suppressHeaderMenuButton, params);\n\n    return col;\n  }\n\n  /**\n   * Resolve one cell's class, for one row.\n   *\n   * Pure: the result is returned rather than written back onto the column def,\n   * which every row of that column shares. Writing to it worked only because\n   * the template resolved and read in the same expression — one render order\n   * away from every row showing the last row's class.\n   */\n  resolveCellClass(col: OneColumnDef, params: OneCellPresentationParams): string | string[] | undefined {\n\n    return typeof col?.cellClass === 'function' ? col.cellClass(params) : col?.cellClass;\n  }\n\n  /** Resolve one cell's inline style, for one row. Pure, as above. */\n  resolveCellStyle(col: OneColumnDef, params: OneCellPresentationParams): Record<string, string> | undefined {\n\n    return typeof col?.cellStyle === 'function' ? col.cellStyle(params) : col?.cellStyle;\n  }\n}"]}

package/esm2022/lib/core/services/one-grid-cell.service.mjs

@@ -10,19 +10,69 @@ export class OneGridCellService {
         this._cellValueGetter = new CellValueGetterPipe();
         this._cellFieldValue = new CellFieldValuePipe();
         this._columnDefs = [];
+        this._api = null;
+        // ---------------------------------------------------------------------------
+        // Row-scoped column predicates
+        //
+        // Every one of these resolves the same way and receives the same params, via
+        // `cellParams`. They used to each build their own subset inline, which is how
+        // `value`, `field` and `api` came to be missing from all of them.
+        // ---------------------------------------------------------------------------
+        /** Whether this cell may be edited at all. A capability: unset means no. */
+        this.editableFn = (column, node) => resolveOneCellRendererParams(column?.editable, this.cellParams(column, node));
         /**
-         * One Column Def Params Resolver
+         * The second edit gate, ANDed with `editable`.
+         *
+         * A restriction, so unset means "no restriction". It used to resolve through
+         * `!!undefined` to `false`, closing the gate on every column that did not name
+         * it — so `editable: true` on its own made nothing editable.
          */
-        this.editableFn = (column, node) => resolveOneCellRendererParams(column.editable, { node, data: node.data, columnDef: column, rowIndex: node.rowIndex, context: this._context });
-        this.updatableFn = (column, node) => resolveOneCellRendererParams(column.updatable, { node, data: node.data, columnDef: column, rowIndex: node.rowIndex, context: this._context });
-        this.disableFn = (column, node) => resolveOneCellRendererParams(column.disable, { node, data: node.data, columnDef: column, rowIndex: node.rowIndex, context: this._context });
-        this.dragableFn = (column, node) => resolveOneCellRendererParams(column.dragable, { node, data: node.data, columnDef: column, rowIndex: node.rowIndex, context: this._context });
-        this.valueGetterFn = (column, node) => resolveOneValueGetterParams(column.valueGetter, { data: node.data, rowIndex: node.rowIndex, node: node, context: this._context });
+        this.updatableFn = (column, node) => resolveOneCellRendererParams(column?.updatable, this.cellParams(column, node), true);
+        /** Disables this column's row action buttons. Not an edit gate. */
+        this.disableFn = (column, node) => resolveOneCellRendererParams(column?.disable, this.cellParams(column, node));
+        /** Hides this column's row action buttons entirely. */
+        this.hideActionButtonFn = (column, node) => resolveOneCellRendererParams(column?.hideActionButton, this.cellParams(column, node));
+        /** Whether this cell carries a row drag handle. */
+        this.rowDragFn = (column, node) => resolveOneCellRendererParams(column?.rowDrag, this.cellParams(column, node));
+        this.valueGetterFn = (column, node) => resolveOneValueGetterParams(column?.valueGetter, { data: node.data, rowIndex: node.rowIndex, node, context: this._context });
     }
     applyColumnDefs(columnDefs, context) {
         this._columnDefs = columnDefs;
         this._context = context;
     }
+    /**
+     * Back-reference to the grid api, so predicate params can carry it.
+     *
+     * Pushed in rather than injected: `OneGridApi` already depends on this
+     * service, and injecting it back would close a DI cycle.
+     */
+    setGridApi(api) {
+        this._api = api;
+    }
+    /**
+     * The params every row-scoped column callback receives.
+     *
+     * One builder, deliberately: `editable`, `updatable`, `disable`, `rowDrag`,
+     * `hideActionButton`, `cellClass`, `cellStyle`, `cellRenderer` and
+     * `valueFormatter` are all "decide something about this cell", and a consumer
+     * should not have to remember which of them happens to be handed `value` or
+     * `field`. Each used to be called with a slightly different subset.
+     */
+    cellParams(column, node) {
+        return {
+            // Column config first, so the grid's own fields win a name collision: a
+            // stale `value` left in `cellRendererParams` must not shadow this cell's.
+            ...(column?.cellRendererParams ?? {}),
+            value: this.resolveValue(node, column),
+            data: node.data,
+            node,
+            rowIndex: node.rowIndex,
+            field: column?.field,
+            columnDef: column,
+            api: this._api ?? undefined,
+            context: this._context,
+        };
+    }
     /**
      * Generate New Node States
      */
@@ -32,48 +82,123 @@ export class OneGridCellService {
         const newStates = {};
         for (const column of this._columnDefs) {
             const field = column.field;
+            // Cell state is keyed by field, so a column without one contributes
+            // nothing. Skipping it keeps `undefined` out of the state object; such a
+            // column still renders its action buttons, which do not read cell state.
+            if (!field)
+                continue;
             if (field !== '_oneRowNumber') {
                 newStates[field] = this.generateCellState(node, column) ?? node.cellStates[field] ?? { type: 'none', value: '' };
             }
             else {
-                newStates[field] = node.cellStates[column.field];
+                newStates[field] = node.cellStates[field];
             }
         }
         return newStates;
     }
+    /**
+     * The cell's value: the `valueGetter`'s output where the column declares one,
+     * the raw field otherwise. This is the value, not the display text — see
+     * {@link formatValue}.
+     */
+    resolveValue(node, column) {
+        return column?.valueGetter
+            ? this._cellValueGetter.transform(node.data, node, column, this._context)
+            : this._cellFieldValue.transform(node.data, column.field);
+    }
+    /**
+     * Apply the column's `valueFormatter`.
+     *
+     * `valueFormatter` was declared on the column definition and called from
+     * nowhere — a consumer could write one, get no error, and see nothing happen.
+     * It runs on displayed text only, after the `valueGetter`, and is deliberately
+     * skipped for placeholders: an empty cell already has its own mechanism in
+     * `cellRendererParams.placeholder`, and two features competing to fill the
+     * same gap is worse than one.
+     *
+     * Note that sorting and filtering read the underlying row data, not this —
+     * which is exactly why formatting belongs here rather than in the getter.
+     */
+    formatValue(node, column, value) {
+        if (typeof column?.valueFormatter !== 'function')
+            return value;
+        // `value` is passed explicitly rather than left to `cellParams`: the empty
+        // -cell branch resolves it through the getter before deciding whether there
+        // is anything to format, and the formatter must see that same value.
+        return column.valueFormatter({ ...this.cellParams(column, node), value });
+    }
+    /**
+     * The placeholder for an empty cell, or `undefined` when this row's tree
+     * depth may not be edited.
+     *
+     * `cellRendererParams.placeholder` is a prompt, not data: it renders at half
+     * opacity where the value would go, which reads as "click here and fill this
+     * in". On the auto group column `editableLevels` decides which depths accept
+     * an edit at all, so a depth outside that list was advertising an edit the
+     * grid then refuses — the cell offers no input and the prompt never clears.
+     *
+     * The suppression is scoped to columns that actually declare `editableLevels`.
+     * The list is opt-in, and a column without one has no per-level rules rather
+     * than no editable levels, so plain grids and untouched tree columns keep
+     * showing their placeholder exactly as before.
+     */
+    resolvePlaceholder(node, column) {
+        const placeholder = column?.cellRendererParams?.placeholder;
+        const editableLevels = column?.editableLevels;
+        if (!column?.autoGroupField || !Array.isArray(editableLevels))
+            return placeholder;
+        return editableLevels.includes(node?.level) ? placeholder : undefined;
+    }
     /**
      * Generate New Node State Based on Column Field
      */
     generateCellState(node, column) {
-        const isField = column.field !== undefined || column.field !== '' || column.field !== null;
-        const isEmpty = this._cellFieldValueEmpty.transform(node.data, column.field);
+        // This was `field !== undefined || field !== '' || field !== null`, which is
+        // true for every possible value including all three it meant to exclude —
+        // `||` where `&&` was intended. It gated the four branches below, so none
+        // of them could ever fall through to the default. Reduced to the check it
+        // was reaching for: a column with no field has no value to render.
+        const field = column?.field;
+        if (!field) {
+            return { type: 'none', value: '' };
+        }
+        const isEmpty = this._cellFieldValueEmpty.transform(node.data, field);
         const isGroup = node.group || node.leafGroup;
         const isAutoGroup = column?.autoGroupField;
         if (column && column.cellRenderer && !isGroup) {
-            const value = column.cellRenderer({ node, columnDef: column });
-            return { type: 'html', value: value };
+            // The renderer used to be handed `{ node, columnDef }` and nothing else,
+            // so the obvious way to write one — `params.value` — produced the string
+            // "undefined", and `params.data.x` threw. It now gets exactly what every
+            // other row-scoped hook gets.
+            return { type: 'html', value: column.cellRenderer(this.cellParams(column, node)) };
         }
         // 1. Cell Group Placeholder
-        if (isField && isEmpty && isGroup && isAutoGroup) {
-            return { type: 'placeholder', value: column?.cellRendererParams?.placeholder ?? this._cellValueGetter.transform(node.data, node, column, this._context) ?? '' };
+        if (isEmpty && isGroup && isAutoGroup) {
+            return { type: 'placeholder', value: this.resolvePlaceholder(node, column) ?? this._cellValueGetter.transform(node.data, node, column, this._context) ?? '' };
         }
         // 2. Cell Group Text Value
-        if (isField && isGroup && isAutoGroup) {
-            const value = column?.valueGetter ? this._cellValueGetter.transform(node.data, node, column, this._context) : this._cellFieldValue.transform(node.data, column.field);
+        if (isGroup && isAutoGroup) {
+            const value = this.formatValue(node, column, this.resolveValue(node, column));
             return { type: 'text', value: value ?? '' };
         }
         // 3. Cell Placeholder
-        if (isField && isEmpty && !isGroup && !isAutoGroup) {
+        //
+        // The auto group column is deliberately NOT excluded here. Cases 1 and 2
+        // above already claimed the group rows, so what reaches this point is a
+        // leaf — and a leaf on the auto group column has to render its label too,
+        // indented by level. Excluding it dropped every leaf through to case 5 and
+        // rendered the group column blank for the whole bottom row of a tree.
+        if (isEmpty && !isGroup) {
             const valueGetter = this._cellValueGetter.transform(node.data, node, column, this._context);
             if (valueGetter) {
-                return { type: 'text', value: valueGetter };
+                return { type: 'text', value: this.formatValue(node, column, valueGetter) };
             }
-            const placeholder = column?.cellRendererParams?.placeholder ?? '';
+            const placeholder = this.resolvePlaceholder(node, column) ?? '';
             return { type: 'placeholder', value: placeholder };
         }
-        // 4. Cell Text Value
-        if (isField && !(isGroup || isAutoGroup)) {
-            const value = column?.valueGetter ? this._cellValueGetter.transform(node.data, node, column, this._context) : this._cellFieldValue.transform(node.data, column.field);
+        // 4. Cell Text Value (leaves, including the auto group column — see above)
+        if (!isGroup) {
+            const value = this.formatValue(node, column, this.resolveValue(node, column));
             return { type: 'text', value: value ?? '' };
         }
         // 5. Default
@@ -85,4 +210,4 @@ export class OneGridCellService {
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: OneGridCellService, decorators: [{
             type: Injectable
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"one-grid-cell.service.js","sourceRoot":"","sources":["../../../../../../projects/one-grid/src/lib/core/services/one-grid-cell.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { OneCellState, OneCellStates, OneColumnDef } from '../models/one-column-def-types.model';\nimport { CellFieldValueEmptyPipe } from '../pipes/cell-field-value-empty.pipe';\nimport { OneRowNode } from '../instants/one-row-node.class';\nimport { resolveOneCellRendererParams, resolveOneValueGetterParams } from '../../helpers/one-column-def.helper';\nimport { CellValueGetterPipe } from '../pipes/cell-value-getter.pipe';\nimport { CellFieldValuePipe } from '../pipes/cell-field-value.pipe';\n\n@Injectable()\nexport class OneGridCellService {\n\n  private _cellFieldValueEmpty = new CellFieldValueEmptyPipe();\n  private _cellValueGetter = new CellValueGetterPipe();\n  private _cellFieldValue = new CellFieldValuePipe();\n  private _columnDefs: OneColumnDef[] = [];\n  private _context: any;\n\n  public applyColumnDefs(columnDefs: OneColumnDef[], context: any) {\n\n    this._columnDefs = columnDefs;\n    this._context = context;\n  }\n\n  /**\n   * Generate New Node States\n   */\n  public generateCellStates(node: OneRowNode): OneCellStates | null {\n\n    if (!node) return null;\n\n    const newStates: OneCellStates = {};\n\n    for (const column of this._columnDefs) {\n\n      const field = column.field;\n\n      if (field !== '_oneRowNumber') {\n\n        newStates[field] = this.generateCellState(node, column) ?? node.cellStates[field] ?? { type: 'none', value: '' };\n\n      } else {\n\n        newStates[field] = node.cellStates[column.field];\n      }\n    }\n\n    return newStates;\n  }\n\n  /**\n   * Generate New Node State Based on Column Field\n   */\n  public generateCellState(node: OneRowNode, column: OneColumnDef): OneCellState {\n\n    const isField = column.field !== undefined || column.field !== '' || column.field !== null;\n    const isEmpty = this._cellFieldValueEmpty.transform(node.data, column.field);\n    const isGroup = node.group || node.leafGroup;\n    const isAutoGroup = column?.autoGroupField;\n\n    if (column && column.cellRenderer && !isGroup) {\n\n      const value = column.cellRenderer({ node, columnDef: column });\n\n      return { type: 'html', value: value }\n    }\n\n    // 1. Cell Group Placeholder\n    if (isField && isEmpty && isGroup && isAutoGroup) {\n\n      return { type: 'placeholder', value: column?.cellRendererParams?.placeholder ?? this._cellValueGetter.transform(node.data, node, column, this._context) ?? '' };\n    }\n\n    // 2. Cell Group Text Value\n    if (isField && isGroup && isAutoGroup) {\n\n      const value = column?.valueGetter ? this._cellValueGetter.transform(node.data, node, column, this._context) : this._cellFieldValue.transform(node.data, column.field);\n\n      return { type: 'text', value: value ?? '' };\n    }\n\n    // 3. Cell Placeholder\n    if (isField && isEmpty && !isGroup && !isAutoGroup) {\n\n      const valueGetter = this._cellValueGetter.transform(node.data, node, column, this._context);\n\n      if (valueGetter) {\n\n        return { type: 'text', value: valueGetter };\n      }\n\n      const placeholder = column?.cellRendererParams?.placeholder ?? '';\n\n      return { type: 'placeholder', value: placeholder };\n    }\n\n    // 4. Cell Text Value\n    if (isField && !(isGroup || isAutoGroup)) {\n\n      const value = column?.valueGetter ? this._cellValueGetter.transform(node.data, node, column, this._context) : this._cellFieldValue.transform(node.data, column.field);\n\n      return { type: 'text', value: value ?? '' };\n    }\n\n    // 5. Default\n    return { type: 'none', value: '' };\n  }\n\n  /**\n   * One Column Def Params Resolver\n   */\n  public editableFn = (column: OneColumnDef, node: OneRowNode) => resolveOneCellRendererParams(column.editable, { node, data: node.data, columnDef: column, rowIndex: node.rowIndex, context: this._context });\n\n  public updatableFn = (column: OneColumnDef, node: OneRowNode) => resolveOneCellRendererParams(column.updatable, { node, data: node.data, columnDef: column, rowIndex: node.rowIndex, context: this._context });\n\n  public disableFn = (column: OneColumnDef, node: OneRowNode) => resolveOneCellRendererParams(column.disable, { node, data: node.data, columnDef: column, rowIndex: node.rowIndex, context: this._context });\n\n  public dragableFn = (column: OneColumnDef, node: OneRowNode) => resolveOneCellRendererParams(column.dragable, { node, data: node.data, columnDef: column, rowIndex: node.rowIndex, context: this._context });\n\n  public valueGetterFn = (column: OneColumnDef, node: OneRowNode) => resolveOneValueGetterParams(column.valueGetter, { data: node.data, rowIndex: node.rowIndex, node: node, context: this._context });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"one-grid-cell.service.js","sourceRoot":"","sources":["../../../../../../projects/one-grid/src/lib/core/services/one-grid-cell.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { OneCellPresentationParams, OneCellState, OneCellStates, OneColumnDef } from '../models/one-column-def-types.model';\nimport { CellFieldValueEmptyPipe } from '../pipes/cell-field-value-empty.pipe';\nimport { OneRowNode } from '../instants/one-row-node.class';\nimport { resolveOneCellRendererParams, resolveOneValueGetterParams } from '../../helpers/one-column-def.helper';\nimport { CellValueGetterPipe } from '../pipes/cell-value-getter.pipe';\nimport { CellFieldValuePipe } from '../pipes/cell-field-value.pipe';\nimport type { OneGridApi } from '../instants/one-grid-api.class';\n\n@Injectable()\nexport class OneGridCellService {\n\n  private _cellFieldValueEmpty = new CellFieldValueEmptyPipe();\n  private _cellValueGetter = new CellValueGetterPipe();\n  private _cellFieldValue = new CellFieldValuePipe();\n  private _columnDefs: OneColumnDef[] = [];\n  private _context: any;\n  private _api: OneGridApi | null = null;\n\n  public applyColumnDefs(columnDefs: OneColumnDef[], context: any) {\n\n    this._columnDefs = columnDefs;\n    this._context = context;\n  }\n\n  /**\n   * Back-reference to the grid api, so predicate params can carry it.\n   *\n   * Pushed in rather than injected: `OneGridApi` already depends on this\n   * service, and injecting it back would close a DI cycle.\n   */\n  public setGridApi(api: OneGridApi | null): void {\n\n    this._api = api;\n  }\n\n  /**\n   * The params every row-scoped column callback receives.\n   *\n   * One builder, deliberately: `editable`, `updatable`, `disable`, `rowDrag`,\n   * `hideActionButton`, `cellClass`, `cellStyle`, `cellRenderer` and\n   * `valueFormatter` are all \"decide something about this cell\", and a consumer\n   * should not have to remember which of them happens to be handed `value` or\n   * `field`. Each used to be called with a slightly different subset.\n   */\n  public cellParams(column: OneColumnDef, node: OneRowNode): OneCellPresentationParams {\n\n    return {\n      // Column config first, so the grid's own fields win a name collision: a\n      // stale `value` left in `cellRendererParams` must not shadow this cell's.\n      ...(column?.cellRendererParams ?? {}),\n      value: this.resolveValue(node, column),\n      data: node.data,\n      node,\n      rowIndex: node.rowIndex,\n      field: column?.field as string,\n      columnDef: column,\n      api: this._api ?? undefined,\n      context: this._context,\n    };\n  }\n\n  /**\n   * Generate New Node States\n   */\n  public generateCellStates(node: OneRowNode): OneCellStates | null {\n\n    if (!node) return null;\n\n    const newStates: OneCellStates = {};\n\n    for (const column of this._columnDefs) {\n\n      const field = column.field;\n\n      // Cell state is keyed by field, so a column without one contributes\n      // nothing. Skipping it keeps `undefined` out of the state object; such a\n      // column still renders its action buttons, which do not read cell state.\n      if (!field) continue;\n\n      if (field !== '_oneRowNumber') {\n\n        newStates[field] = this.generateCellState(node, column) ?? node.cellStates[field] ?? { type: 'none', value: '' };\n\n      } else {\n\n        newStates[field] = node.cellStates[field];\n      }\n    }\n\n    return newStates;\n  }\n\n  /**\n   * The cell's value: the `valueGetter`'s output where the column declares one,\n   * the raw field otherwise. This is the value, not the display text — see\n   * {@link formatValue}.\n   */\n  private resolveValue(node: OneRowNode, column: OneColumnDef): any {\n\n    return column?.valueGetter\n      ? this._cellValueGetter.transform(node.data, node, column, this._context)\n      : this._cellFieldValue.transform(node.data, column.field);\n  }\n\n  /**\n   * Apply the column's `valueFormatter`.\n   *\n   * `valueFormatter` was declared on the column definition and called from\n   * nowhere — a consumer could write one, get no error, and see nothing happen.\n   * It runs on displayed text only, after the `valueGetter`, and is deliberately\n   * skipped for placeholders: an empty cell already has its own mechanism in\n   * `cellRendererParams.placeholder`, and two features competing to fill the\n   * same gap is worse than one.\n   *\n   * Note that sorting and filtering read the underlying row data, not this —\n   * which is exactly why formatting belongs here rather than in the getter.\n   */\n  private formatValue(node: OneRowNode, column: OneColumnDef, value: any): any {\n\n    if (typeof column?.valueFormatter !== 'function') return value;\n\n    // `value` is passed explicitly rather than left to `cellParams`: the empty\n    // -cell branch resolves it through the getter before deciding whether there\n    // is anything to format, and the formatter must see that same value.\n    return column.valueFormatter({ ...this.cellParams(column, node), value });\n  }\n\n  /**\n   * The placeholder for an empty cell, or `undefined` when this row's tree\n   * depth may not be edited.\n   *\n   * `cellRendererParams.placeholder` is a prompt, not data: it renders at half\n   * opacity where the value would go, which reads as \"click here and fill this\n   * in\". On the auto group column `editableLevels` decides which depths accept\n   * an edit at all, so a depth outside that list was advertising an edit the\n   * grid then refuses — the cell offers no input and the prompt never clears.\n   *\n   * The suppression is scoped to columns that actually declare `editableLevels`.\n   * The list is opt-in, and a column without one has no per-level rules rather\n   * than no editable levels, so plain grids and untouched tree columns keep\n   * showing their placeholder exactly as before.\n   */\n  private resolvePlaceholder(node: OneRowNode, column: OneColumnDef): string | undefined {\n\n    const placeholder = column?.cellRendererParams?.placeholder;\n    const editableLevels = column?.editableLevels;\n\n    if (!column?.autoGroupField || !Array.isArray(editableLevels)) return placeholder;\n\n    return editableLevels.includes(node?.level) ? placeholder : undefined;\n  }\n\n  /**\n   * Generate New Node State Based on Column Field\n   */\n  public generateCellState(node: OneRowNode, column: OneColumnDef): OneCellState {\n\n    // This was `field !== undefined || field !== '' || field !== null`, which is\n    // true for every possible value including all three it meant to exclude —\n    // `||` where `&&` was intended. It gated the four branches below, so none\n    // of them could ever fall through to the default. Reduced to the check it\n    // was reaching for: a column with no field has no value to render.\n    const field = column?.field;\n\n    if (!field) {\n\n      return { type: 'none', value: '' };\n    }\n\n    const isEmpty = this._cellFieldValueEmpty.transform(node.data, field);\n    const isGroup = node.group || node.leafGroup;\n    const isAutoGroup = column?.autoGroupField;\n\n    if (column && column.cellRenderer && !isGroup) {\n\n      // The renderer used to be handed `{ node, columnDef }` and nothing else,\n      // so the obvious way to write one — `params.value` — produced the string\n      // \"undefined\", and `params.data.x` threw. It now gets exactly what every\n      // other row-scoped hook gets.\n      return { type: 'html', value: column.cellRenderer(this.cellParams(column, node)) }\n    }\n\n    // 1. Cell Group Placeholder\n    if (isEmpty && isGroup && isAutoGroup) {\n\n      return { type: 'placeholder', value: this.resolvePlaceholder(node, column) ?? this._cellValueGetter.transform(node.data, node, column, this._context) ?? '' };\n    }\n\n    // 2. Cell Group Text Value\n    if (isGroup && isAutoGroup) {\n\n      const value = this.formatValue(node, column, this.resolveValue(node, column));\n\n      return { type: 'text', value: value ?? '' };\n    }\n\n    // 3. Cell Placeholder\n    //\n    // The auto group column is deliberately NOT excluded here. Cases 1 and 2\n    // above already claimed the group rows, so what reaches this point is a\n    // leaf — and a leaf on the auto group column has to render its label too,\n    // indented by level. Excluding it dropped every leaf through to case 5 and\n    // rendered the group column blank for the whole bottom row of a tree.\n    if (isEmpty && !isGroup) {\n\n      const valueGetter = this._cellValueGetter.transform(node.data, node, column, this._context);\n\n      if (valueGetter) {\n\n        return { type: 'text', value: this.formatValue(node, column, valueGetter) };\n      }\n\n      const placeholder = this.resolvePlaceholder(node, column) ?? '';\n\n      return { type: 'placeholder', value: placeholder };\n    }\n\n    // 4. Cell Text Value (leaves, including the auto group column — see above)\n    if (!isGroup) {\n\n      const value = this.formatValue(node, column, this.resolveValue(node, column));\n\n      return { type: 'text', value: value ?? '' };\n    }\n\n    // 5. Default\n    return { type: 'none', value: '' };\n  }\n\n  // ---------------------------------------------------------------------------\n  // Row-scoped column predicates\n  //\n  // Every one of these resolves the same way and receives the same params, via\n  // `cellParams`. They used to each build their own subset inline, which is how\n  // `value`, `field` and `api` came to be missing from all of them.\n  // ---------------------------------------------------------------------------\n\n  /** Whether this cell may be edited at all. A capability: unset means no. */\n  public editableFn = (column: OneColumnDef, node: OneRowNode): boolean =>\n    resolveOneCellRendererParams(column?.editable, this.cellParams(column, node));\n\n  /**\n   * The second edit gate, ANDed with `editable`.\n   *\n   * A restriction, so unset means \"no restriction\". It used to resolve through\n   * `!!undefined` to `false`, closing the gate on every column that did not name\n   * it — so `editable: true` on its own made nothing editable.\n   */\n  public updatableFn = (column: OneColumnDef, node: OneRowNode): boolean =>\n    resolveOneCellRendererParams(column?.updatable, this.cellParams(column, node), true);\n\n  /** Disables this column's row action buttons. Not an edit gate. */\n  public disableFn = (column: OneColumnDef, node: OneRowNode): boolean =>\n    resolveOneCellRendererParams(column?.disable, this.cellParams(column, node));\n\n  /** Hides this column's row action buttons entirely. */\n  public hideActionButtonFn = (column: OneColumnDef, node: OneRowNode): boolean =>\n    resolveOneCellRendererParams(column?.hideActionButton, this.cellParams(column, node));\n\n  /** Whether this cell carries a row drag handle. */\n  public rowDragFn = (column: OneColumnDef, node: OneRowNode): boolean =>\n    resolveOneCellRendererParams(column?.rowDrag, this.cellParams(column, node));\n\n  public valueGetterFn = (column: OneColumnDef, node: OneRowNode) =>\n    resolveOneValueGetterParams(column?.valueGetter, { data: node.data, rowIndex: node.rowIndex, node, context: this._context });\n}\n"]}