ag-grid-community/dist/types/src/valueService/valueService.d.ts

Advanced Data Grid / Data Table supporting Javascript / Typescript / React / Angular / Vue

import type { NamedBean } from '../context/bean';
import { BeanStub } from '../context/beanStub';
import type { BeanCollection } from '../context/context';
import type { AgColumn } from '../entities/agColumn';
import type { CellValueResolveFrom } from '../interfaces/iEditService';
import type { IRowNode } from '../interfaces/iRowNode';
/** @internal AG_GRID_INTERNAL - Not for public use. Can change / be removed at any time. */
export declare class ValueService extends BeanStub implements NamedBean {
    beanName: "valueSvc";
    private isTreeData;
    private isSsrm;
    private cellExpressions;
    private groupSuppressBlankHeader;
    private editSvc;
    private valueCache;
    private colModel;
    private expressionSvc;
    private dataTypeSvc;
    private formula;
    private showValuesAsSvc;
    private formulaDataSvc;
    private changeDetectionSvc;
    private showRowGroupColValueSvc;
    private rowGroupingEditValueSvc;
    private frameworkOverrides;
    private gridApi;
    private gridOptions;
    wireBeans(beans: BeanCollection): void;
    /** Called by both wireBeans and postConstruct */
    private init;
    postConstruct(): void;
    /**
     * Use this function to get a displayable cell value.
     * The values from this function are not used for sorting, filtering, or aggregation purposes.
     * Handles: groupHideOpenParents, showOpenedGroup and groupSuppressBlankHeader behaviours
     */
    getValueForDisplay(params: {
        column?: AgColumn;
        node: IRowNode;
        includeValueFormatted?: boolean;
        useRawFormula?: boolean;
        exporting?: boolean;
        from: CellValueResolveFrom;
        transformValues?: boolean;
    }): {
        value: any;
        valueFormatted: string | null;
    };
    /**
     * The cell's displayed value with the Show Values As transform applied, or the raw value when no mode is
     * active or applying. Reads pending edits like the display path, then resolves formulas / calculated columns.
     * Leaner than {@link getValueForDisplay} — no group-cell, full-width, or formatting work.
     */
    getTransformedValue(column: AgColumn, node: IRowNode): any;
    /** Resolves a formula/calculated value then applies the Show Values As transform when a mode is applying;
     *  otherwise returns the (formula-resolved) value. Shared by the display + transformed read paths. */
    private resolveTransformed;
    /**
     * Display value only — same resolution as {@link getValueForDisplay} but returns the bare value,
     * skipping formatting and the result-object allocation. For callers that never read `valueFormatted`.
     */
    getDisplayValue(column: AgColumn | undefined, node: IRowNode, from: CellValueResolveFrom, transformValues: boolean): any;
    getValueFromData(column: AgColumn, rowNode: IRowNode, ignoreAggData?: boolean): any;
    /**
     * Reads a cell value honouring pending edits for non-`'data'` sources. Does NOT redirect pivot result
     * columns — display/selection callers only ever pair them with group rows (no redirect needed). The
     * value APIs that accept an arbitrary node ({@link getCellValue}, {@link getDataValue}) pre-resolve via
     * `_resolvePivotColumnForRow` since they can be handed a leaf. Hot committed-data reads of a known column
     * should call {@link getValueFromData} directly to skip the edit-state lookup too.
     */
    getValue(column: AgColumn, rowNode: IRowNode | null | undefined, from: CellValueResolveFrom, ignoreAggData?: boolean): any;
    /** Whether to ignore aggregation data for display. Callers must pass a group node (guard on `node.group`). */
    displayIgnoresAggData(node: IRowNode): boolean;
    /** The Show Values As service iff `column`'s active mode is currently transforming (not dormant) for display.
     *  `column.showValuesAs` is null for every ordinary column, so this is a no-op outside the feature. */
    private transformingSvc;
    private resolveCoreValue;
    parseValue<TValueNew = any, TValueOld = any, TValue = any>(column: AgColumn, rowNode: IRowNode | null, newValue: TValueNew, oldValue: TValueOld): TValue;
    getDeleteValue(column: AgColumn, rowNode: IRowNode): any;
    formatValue(column: AgColumn, node: IRowNode | null, value: any, suppliedFormatter?: (value: any) => string, useFormatterFromColumn?: boolean): string | null;
    /**
     * Formats a Show Values As value with the selected mode's formatter, mirroring {@link getValueForDisplay}: a
     * dormant mode (selected but not applicable) passes `notApplicable` so the built-in formatters show `#N/A`.
     * Returns `undefined` when the column has no selected mode — the caller then falls back to {@link formatValue}.
     * Kept off {@link formatValue} so the hot per-cell format path is not burdened with the feature check.
     */
    formatTransformedValue(column: AgColumn, node: IRowNode | null, value: any): string | null | undefined;
    /**
     * Sets the value of a GridCell
     * @param rowNode The `RowNode` to be updated
     * @param column The `Column` to be updated
     * @param newValue The new value to be set
     * @param eventSource The event source
     * @returns `true` if the value has been updated, otherwise `false`.
     */
    setValue(rowNode: IRowNode, column: AgColumn, newValue: any, eventSource?: string): boolean;
    private finishValueChange;
    private isSetValueSupported;
    private handleExternalFormulaChange;
    private computeValueChange;
    private dispatchCellValueChangedEvent;
    private callColumnCellValueChangedHandler;
    private executeValueGetter;
    private getValueCallback;
    getKeyForNode(col: AgColumn, rowNode: IRowNode): any;
}