ag-grid-community 32.3.2 → 33.0.0

package/dist/types/src/rendering/cell/cellFlashService.d.ts

@@ -0,0 +1,11 @@
+import type { NamedBean } from '../../context/bean';
+import { BeanStub } from '../../context/beanStub';
+import type { FlashCellsEvent } from '../../events';
+import type { FlashCellsParams } from '../../interfaces/iCellsParams';
+import type { CellCtrl } from './cellCtrl';
+export declare class CellFlashService extends BeanStub implements NamedBean {
+    beanName: "cellFlashSvc";
+    onFlashCells(cellCtrl: CellCtrl, event: FlashCellsEvent): void;
+    flashCell(cellCtrl: CellCtrl, delays?: Pick<FlashCellsParams, 'fadeDuration' | 'flashDuration'>): void;
+    private animateCell;
+}

package/dist/types/src/rendering/cell/cellKeyboardListenerFeature.d.ts

@@ -0,0 +1,24 @@
+import { BeanStub } from '../../context/beanStub';
+import type { BeanCollection } from '../../context/context';
+import type { RowNode } from '../../entities/rowNode';
+import type { RowCtrl } from '../row/rowCtrl';
+import type { CellCtrl } from './cellCtrl';
+export declare class CellKeyboardListenerFeature extends BeanStub {
+    private readonly cellCtrl;
+    private readonly rowNode;
+    private readonly rowCtrl;
+    private eGui;
+    constructor(cellCtrl: CellCtrl, beans: BeanCollection, rowNode: RowNode, rowCtrl: RowCtrl);
+    setComp(eGui: HTMLElement): void;
+    onKeyDown(event: KeyboardEvent): void;
+    private onNavigationKeyDown;
+    private onShiftRangeSelect;
+    private onTabKeyDown;
+    private onBackspaceOrDeleteKeyDown;
+    private onEnterKeyDown;
+    private onF2KeyDown;
+    private onEscapeKeyDown;
+    processCharacter(event: KeyboardEvent): void;
+    private onSpaceKeyDown;
+    destroy(): void;
+}

package/dist/types/src/rendering/cell/cellMouseListenerFeature.d.ts

@@ -0,0 +1,20 @@
+import { BeanStub } from '../../context/beanStub';
+import type { BeanCollection } from '../../context/context';
+import type { AgColumn } from '../../entities/agColumn';
+import type { CellCtrl } from './cellCtrl';
+export declare class CellMouseListenerFeature extends BeanStub {
+    private readonly cellCtrl;
+    private readonly column;
+    lastIPadMouseClickEvent: number;
+    constructor(cellCtrl: CellCtrl, beans: BeanCollection, column: AgColumn);
+    onMouseEvent(eventName: string, mouseEvent: MouseEvent): void;
+    private onCellClicked;
+    onCellDoubleClicked(mouseEvent: MouseEvent): void;
+    private onMouseDown;
+    private isRightClickInExistingRange;
+    private containsWidget;
+    private onMouseOut;
+    private onMouseOver;
+    private mouseStayingInsideCell;
+    destroy(): void;
+}

package/dist/types/src/rendering/cell/cellPositionFeature.d.ts

@@ -0,0 +1,32 @@
+import { BeanStub } from '../../context/beanStub';
+import type { BeanCollection } from '../../context/context';
+import type { AgColumn } from '../../entities/agColumn';
+import type { CellCtrl } from './cellCtrl';
+/**
+ * Takes care of:
+ *  #) Cell Width (including when doing cell spanning, which makes width cover many columns)
+ *  #) Cell Height (when doing row span, otherwise we don't touch the height as it's just row height)
+ *  #) Cell Left (the horizontal positioning of the cell, the vertical positioning is on the row)
+ */
+export declare class CellPositionFeature extends BeanStub {
+    private readonly cellCtrl;
+    private eGui;
+    private readonly column;
+    private readonly rowNode;
+    private colsSpanning;
+    private rowSpan;
+    constructor(cellCtrl: CellCtrl, beans: BeanCollection);
+    private setupRowSpan;
+    setComp(eGui: HTMLElement): void;
+    private onNewColumnsLoaded;
+    private onDisplayColumnsChanged;
+    private setupColSpan;
+    onWidthChanged(): void;
+    private getCellWidth;
+    getColSpanningList(): AgColumn[];
+    onLeftChanged(): void;
+    private getCellLeft;
+    private modifyLeftForPrintLayout;
+    private applyRowSpan;
+    destroy(): void;
+}

package/dist/types/src/rendering/cell/highlightChangesApi.d.ts

@@ -0,0 +1,3 @@
+import type { BeanCollection } from '../../context/context';
+import type { FlashCellsParams } from '../../interfaces/iCellsParams';
+export declare function flashCells<TData = any>(beans: BeanCollection, params?: FlashCellsParams<TData>): void;

package/dist/types/src/rendering/cell/highlightChangesModule.d.ts

@@ -0,0 +1,7 @@
+import type { _HighlightChangesGridApi } from '../../api/gridApi';
+import type { _ModuleWithApi } from '../../interfaces/iModule';
+/**
+ * @feature Cells -> Highlighting Changes
+ * @colDef enableCellChangeFlash
+ */
+export declare const HighlightChangesModule: _ModuleWithApi<_HighlightChangesGridApi<any>>;

package/dist/types/src/rendering/cellRenderers/animateShowChangeCellRenderer.d.ts

@@ -0,0 +1,14 @@
+import { Component } from '../../widgets/component';
+import type { ICellRenderer } from './iCellRenderer';
+export declare class AnimateShowChangeCellRenderer extends Component implements ICellRenderer {
+    private lastValue;
+    private eValue;
+    private eDelta;
+    private refreshCount;
+    constructor();
+    init(params: any): void;
+    private showDelta;
+    private setTimerToRemoveDelta;
+    private hideDeltaValue;
+    refresh(params: any, isInitialRender?: boolean): boolean;
+}

package/dist/types/src/rendering/cellRenderers/animateSlideCellRenderer.css-GENERATED.d.ts

@@ -0,0 +1 @@
+export declare const animateSlideCellRendererCSS = ".ag-value-slide-out{opacity:1}:where(.ag-ltr) .ag-value-slide-out{margin-right:5px;transition:opacity 3s,margin-right 3s}:where(.ag-rtl) .ag-value-slide-out{margin-left:5px;transition:opacity 3s,margin-left 3s}:where(.ag-ltr,.ag-rtl) .ag-value-slide-out{transition-timing-function:linear}.ag-value-slide-out-end{opacity:0}:where(.ag-ltr) .ag-value-slide-out-end{margin-right:10px}:where(.ag-rtl) .ag-value-slide-out-end{margin-left:10px}";

package/dist/types/src/rendering/cellRenderers/animateSlideCellRenderer.d.ts

@@ -0,0 +1,12 @@
+import { Component } from '../../widgets/component';
+import type { ICellRenderer } from './iCellRenderer';
+export declare class AnimateSlideCellRenderer extends Component implements ICellRenderer {
+    private eCurrent;
+    private ePrevious;
+    private lastValue;
+    private refreshCount;
+    constructor();
+    init(params: any): void;
+    addSlideAnimation(): void;
+    refresh(params: any, isInitialRender?: boolean): boolean;
+}

package/dist/types/src/rendering/cellRenderers/cellRendererModule.d.ts

@@ -0,0 +1,6 @@
+import type { _ModuleWithoutApi } from '../../interfaces/iModule';
+/**
+ * @feature Cells -> Cell Data Types
+ * @colDef cellDataType
+ */
+export declare const CheckboxCellRendererModule: _ModuleWithoutApi;

package/dist/types/src/rendering/cellRenderers/checkboxCellRenderer.css-GENERATED.d.ts

@@ -0,0 +1 @@
+export declare const checkboxCellRendererCSS = ".ag-checkbox-cell{height:100%}";

package/dist/types/src/rendering/cellRenderers/iCellRenderer.d.ts

@@ -0,0 +1,78 @@
+import type { ColDef } from '../../entities/colDef';
+import type { GetCellsParams } from '../../interfaces/iCellsParams';
+import type { Column } from '../../interfaces/iColumn';
+import type { AgGridCommon } from '../../interfaces/iCommon';
+import type { IComponent } from '../../interfaces/iComponent';
+import type { IRowNode } from '../../interfaces/iRowNode';
+export interface ICellRendererParams<TData = any, TValue = any, TContext = any> extends AgGridCommon<TData, TContext> {
+    /** Value to be rendered. */
+    value: TValue | null | undefined;
+    /** Formatted value to be rendered. */
+    valueFormatted: string | null | undefined;
+    /** True if this is a full width row. */
+    fullWidth?: boolean;
+    /** Pinned state of the cell. */
+    pinned?: 'left' | 'right' | null;
+    /** The row's data. Data property can be `undefined` when row grouping or loading infinite row models. */
+    data: TData | undefined;
+    /** The row node. */
+    node: IRowNode<TData>;
+    /** The cell's column definition. */
+    colDef?: ColDef<TData, TValue>;
+    /** The cell's column. */
+    column?: Column<TValue>;
+    /** The grid's cell, a DOM div element. */
+    eGridCell: HTMLElement;
+    /** The parent DOM item for the cell renderer, same as eGridCell unless using checkbox selection. */
+    eParentOfValue: HTMLElement;
+    /** Convenience function to get most recent up to data value. */
+    getValue?: () => TValue | null | undefined;
+    /** Convenience function to set the value. */
+    setValue?: (value: TValue | null | undefined) => void;
+    /** Convenience function to format a value using the column's formatter. */
+    formatValue?: (value: TValue | null | undefined) => string;
+    /** Convenience function to refresh the cell. */
+    refreshCell?: () => void;
+    /**
+     * registerRowDragger:
+     * @param rowDraggerElement The HTMLElement to be used as Row Dragger
+     * @param dragStartPixels The amount of pixels required to start the drag (Default: 4)
+     * @param value The value to be displayed while dragging. Note: Only relevant with Full Width Rows.
+     * @param suppressVisibilityChange Set to `true` to prevent the Grid from hiding the Row Dragger when it is disabled.
+     */
+    registerRowDragger: (rowDraggerElement: HTMLElement, dragStartPixels?: number, value?: string, suppressVisibilityChange?: boolean) => void;
+    /**
+     * Sets a tooltip to the main element of this component.
+     * @param value The value to be displayed by the tooltip
+     * @param shouldDisplayTooltip A function returning a boolean that allows the tooltip to be displayed conditionally. This option does not work when `enableBrowserTooltips={true}`.
+     */
+    setTooltip: (value: string, shouldDisplayTooltip?: () => boolean) => void;
+}
+export interface ISetFilterCellRendererParams<TData = any, TContext = any> extends AgGridCommon<TData, TContext> {
+    value: any;
+    valueFormatted: string | null | undefined;
+    /** The cell's column definition. */
+    colDef?: ColDef;
+    /** The cell's column. */
+    column?: Column;
+    /**
+     * Sets a tooltip to the main element of this component.
+     * @param value The value to be displayed by the tooltip
+     * @param shouldDisplayTooltip A function returning a boolean that allows the tooltip to be displayed conditionally. This option does not work when `enableBrowserTooltips={true}`.
+     */
+    setTooltip: (value: string, shouldDisplayTooltip?: () => boolean) => void;
+}
+export interface ICellRenderer<TData = any> {
+    /**
+     * Get the cell to refresh. Return true if successful. Return false if not (or you don't have refresh logic),
+     * then the grid will refresh the cell for you.
+     */
+    refresh(params: ICellRendererParams<TData>): boolean;
+}
+export interface ICellRendererComp<TData = any> extends IComponent<ICellRendererParams<TData>>, ICellRenderer<TData> {
+}
+export interface ICellRendererFunc<TData = any> {
+    (params: ICellRendererParams<TData>): HTMLElement | string;
+}
+export interface GetCellRendererInstancesParams<TData = any> extends GetCellsParams<TData> {
+}

package/dist/types/src/rendering/features/positionableFeature.d.ts

@@ -0,0 +1,93 @@
+import { BeanStub } from '../../context/beanStub';
+import type { BeanCollection } from '../../context/context';
+import type { PopupService } from '../../widgets/popupService';
+export interface PositionableOptions {
+    popup?: boolean;
+    minWidth?: number | null;
+    width?: number | string | null;
+    minHeight?: number | null;
+    height?: number | string | null;
+    centered?: boolean | null;
+    calculateTopBuffer?: () => number;
+    /**
+     * Used for when a popup needs to be resized by an element within itself
+     * In that case, the feature will configured as `popup=false` but the offsetParent
+     * needs to be the popupParent.
+     */
+    forcePopupParentAsOffsetParent?: boolean;
+    x?: number | null;
+    y?: number | null;
+}
+export type ResizableSides = 'topLeft' | 'top' | 'topRight' | 'right' | 'bottomRight' | 'bottom' | 'bottomLeft' | 'left';
+export type ResizableStructure = {
+    [key in ResizableSides]?: boolean;
+};
+export type PositionableFeatureEvent = 'resize';
+export declare class PositionableFeature extends BeanStub<PositionableFeatureEvent> {
+    private readonly element;
+    protected popupSvc?: PopupService;
+    private dragSvc?;
+    wireBeans(beans: BeanCollection): void;
+    private dragStartPosition;
+    private position;
+    private lastSize;
+    private resizerMap;
+    private minWidth;
+    private minHeight?;
+    private positioned;
+    private resizersAdded;
+    private config;
+    private resizeListeners;
+    private moveElementDragListener;
+    private offsetParent;
+    private boundaryEl;
+    private isResizing;
+    private isMoving;
+    private resizable;
+    private movable;
+    private currentResizer;
+    private resizeObserverSubscriber;
+    constructor(element: HTMLElement, config?: PositionableOptions);
+    center(): void;
+    initialisePosition(): void;
+    isPositioned(): boolean;
+    getPosition(): {
+        x: number;
+        y: number;
+    };
+    setMovable(movable: boolean, moveElement: HTMLElement): void;
+    setResizable(resizable: boolean | ResizableStructure): void;
+    removeSizeFromEl(): void;
+    restoreLastSize(): void;
+    getHeight(): number | undefined;
+    setHeight(height: number | string): void;
+    private getAvailableHeight;
+    getWidth(): number | undefined;
+    setWidth(width: number | string): void;
+    offsetElement(x?: number, y?: number): void;
+    constrainSizeToAvailableHeight(constrain: boolean): void;
+    private setPosition;
+    private updateDragStartPosition;
+    private calculateMouseMovement;
+    private shouldSkipX;
+    private shouldSkipY;
+    private createResizeMap;
+    private addResizers;
+    private removeResizers;
+    private getResizerElement;
+    private onResizeStart;
+    private getSiblings;
+    private getMinSizeOfSiblings;
+    private applySizeToSiblings;
+    isResizable(): boolean;
+    private onResize;
+    private onResizeEnd;
+    private refreshSize;
+    private onMoveStart;
+    private onMove;
+    private onMoveEnd;
+    private setOffsetParent;
+    private findBoundaryElement;
+    private clearResizeListeners;
+    destroy(): void;
+}

package/dist/types/src/rendering/features/setLeftFeature.d.ts

@@ -0,0 +1,20 @@
+import { BeanStub } from '../../context/beanStub';
+import type { BeanCollection } from '../../context/context';
+import type { AgColumn } from '../../entities/agColumn';
+import type { AgColumnGroup } from '../../entities/agColumnGroup';
+export declare class SetLeftFeature extends BeanStub {
+    private readonly columnOrGroup;
+    private eCell;
+    private colsSpanning?;
+    private ariaEl;
+    private actualLeft;
+    constructor(columnOrGroup: AgColumn | AgColumnGroup, eCell: HTMLElement, beans: BeanCollection, colsSpanning?: AgColumn<any>[] | undefined);
+    setColsSpanning(colsSpanning: AgColumn[]): void;
+    getColumnOrGroup(): AgColumn | AgColumnGroup;
+    postConstruct(): void;
+    private setLeftFirstTime;
+    private animateInLeft;
+    private onLeftChanged;
+    private modifyLeftForPrintLayout;
+    private setLeft;
+}

package/dist/types/src/rendering/overlays/overlayComponent.d.ts

@@ -0,0 +1,14 @@
+import type { AgGridCommon } from '../../interfaces/iCommon';
+import type { IComponent } from '../../interfaces/iComponent';
+import { Component } from '../../widgets/component';
+export interface IOverlayParams<TData = any, TContext = any> extends AgGridCommon<TData, TContext> {
+}
+export interface IOverlay<TData = any, TContext = any, TParams extends Readonly<IOverlayParams<TData, TContext>> = IOverlayParams<TData, TContext>> {
+    refresh?(params: TParams): void;
+}
+export interface IOverlayComp<TData = any, TContext = any, TParams extends Readonly<IOverlayParams<TData, TContext>> = IOverlayParams<TData, TContext>> extends IComponent<TParams>, IOverlay<TData, TContext, TParams> {
+}
+export declare abstract class OverlayComponent<TData = any, TContext = any, TParams extends Readonly<IOverlayParams<TData, TContext>> = IOverlayParams<TData, TContext>> extends Component implements IOverlayComp<TData, TContext, TParams> {
+    constructor();
+    abstract init(): void;
+}

package/dist/types/src/rendering/overlays/overlayModule.d.ts

@@ -0,0 +1,7 @@
+import type { _OverlayGridApi } from '../../api/gridApi';
+import type { _ModuleWithApi } from '../../interfaces/iModule';
+/**
+ * @feature Accessories -> Overlays
+ * @gridOption loading, overlayLoadingTemplate, loadingOverlayComponent, overlayNoRowsTemplate, noRowsOverlayComponent
+ */
+export declare const OverlayModule: _ModuleWithApi<_OverlayGridApi>;

package/dist/types/src/rendering/overlays/overlayService.d.ts

@@ -0,0 +1,31 @@
+import type { NamedBean } from '../../context/bean';
+import { BeanStub } from '../../context/beanStub';
+import type { ComponentSelector } from '../../widgets/component';
+import { OverlayWrapperComponent } from './overlayWrapperComponent';
+export declare class OverlayService extends BeanStub implements NamedBean {
+    beanName: "overlays";
+    private isClientSide;
+    private state;
+    private showInitialOverlay;
+    private exclusive?;
+    private wrapperPadding;
+    eWrapper: OverlayWrapperComponent | undefined;
+    postConstruct(): void;
+    setOverlayWrapperComp(overlayWrapperComp: OverlayWrapperComponent | undefined): void;
+    /** Returns true if the overlay is visible. */
+    isVisible(): boolean;
+    /** Returns true if the overlay is visible and is exclusive (popup over the grid) */
+    isExclusive(): boolean;
+    showLoadingOverlay(): void;
+    showNoRowsOverlay(): void;
+    hideOverlay(): void;
+    getOverlayWrapperSelector(): ComponentSelector;
+    getOverlayWrapperCompClass(): typeof OverlayWrapperComponent;
+    private updateOverlayVisibility;
+    private doShowLoadingOverlay;
+    private doShowNoRowsOverlay;
+    private doHideOverlay;
+    private showOverlay;
+    private updateExclusive;
+    private refreshWrapperPadding;
+}

package/dist/types/src/rendering/overlays/overlayWrapperComponent.css-GENERATED.d.ts

@@ -0,0 +1 @@
+export declare const overlayWrapperComponentCSS = ".ag-overlay{inset:0;pointer-events:none;position:absolute;z-index:2}.ag-overlay-panel,.ag-overlay-wrapper{display:flex;height:100%;width:100%}.ag-overlay-wrapper{align-items:center;flex:none;justify-content:center;text-align:center}.ag-overlay-loading-wrapper{pointer-events:all}.ag-overlay-loading-center{background:var(--ag-background-color);border:1px solid var(--ag-border-color);border-radius:var(--ag-border-radius);box-shadow:var(--ag-popup-shadow);padding:var(--ag-spacing)}";

package/dist/types/src/rendering/overlays/overlayWrapperComponent.d.ts

@@ -0,0 +1,26 @@
+import type { GridOptions } from '../../entities/gridOptions';
+import type { LayoutView, UpdateLayoutClassesParams } from '../../styling/layoutFeature';
+import type { AgPromise } from '../../utils/promise';
+import type { ComponentSelector } from '../../widgets/component';
+import { Component } from '../../widgets/component';
+import type { IOverlayComp } from './overlayComponent';
+export declare class OverlayWrapperComponent extends Component implements LayoutView {
+    private readonly eOverlayWrapper;
+    private activePromise;
+    private activeOverlay;
+    private updateListenerDestroyFunc;
+    private activeCssClass;
+    private elToFocusAfter;
+    constructor();
+    private handleKeyDown;
+    updateLayoutClasses(cssClass: string, params: UpdateLayoutClassesParams): void;
+    postConstruct(): void;
+    private setWrapperTypeClass;
+    showOverlay(overlayComponentPromise: AgPromise<IOverlayComp> | null, overlayWrapperCssClass: string, exclusive: boolean, gridOption?: keyof GridOptions): void;
+    updateOverlayWrapperPaddingTop(padding: number): void;
+    private destroyActiveOverlay;
+    hideOverlay(): void;
+    private isGridFocused;
+    destroy(): void;
+}
+export declare const OverlayWrapperSelector: ComponentSelector;

package/dist/types/src/rendering/renderApi.d.ts

@@ -0,0 +1,13 @@
+import type { BeanCollection } from '../context/context';
+import type { RefreshCellsParams } from '../interfaces/iCellsParams';
+import type { GetCellRendererInstancesParams, ICellRenderer } from './cellRenderers/iCellRenderer';
+export declare function setGridAriaProperty(beans: BeanCollection, property: string, value: string | null): void;
+export declare function refreshCells<TData = any>(beans: BeanCollection, params?: RefreshCellsParams<TData>): void;
+export declare function refreshHeader(beans: BeanCollection): void;
+export declare function isAnimationFrameQueueEmpty(beans: BeanCollection): boolean;
+export declare function flushAllAnimationFrames(beans: BeanCollection): void;
+export declare function getSizesForCurrentTheme(beans: BeanCollection): {
+    rowHeight: number;
+    headerHeight: number;
+};
+export declare function getCellRendererInstances<TData = any>(beans: BeanCollection, params?: GetCellRendererInstancesParams<TData>): ICellRenderer[];

package/dist/types/src/rendering/renderModule.d.ts

@@ -0,0 +1,6 @@
+import type { _RenderGridApi } from '../api/gridApi';
+import type { _ModuleWithApi } from '../interfaces/iModule';
+/**
+ * @feature Rendering
+ */
+export declare const RenderApiModule: _ModuleWithApi<_RenderGridApi<any>>;

package/dist/types/src/rendering/row/rowAutoHeightModule.d.ts

@@ -0,0 +1,6 @@
+import type { _ModuleWithoutApi } from '../../interfaces/iModule';
+/**
+ * @feature Rows -> Row Height
+ * @colDef autoHeight
+ */
+export declare const RowAutoHeightModule: _ModuleWithoutApi;

package/dist/types/src/rendering/row/rowAutoHeightService.d.ts

@@ -0,0 +1,17 @@
+import type { ColumnCollections } from '../../columns/columnModel';
+import type { NamedBean } from '../../context/bean';
+import { BeanStub } from '../../context/beanStub';
+import type { AgColumn } from '../../entities/agColumn';
+import type { RowNode } from '../../entities/rowNode';
+import type { CellCtrl } from '../cell/cellCtrl';
+export declare class RowAutoHeightService extends BeanStub implements NamedBean {
+    beanName: "rowAutoHeight";
+    /** grid columns have colDef.autoHeight set */
+    active: boolean;
+    private wasEverActive;
+    setRowAutoHeight(rowNode: RowNode, cellHeight: number | undefined, column: AgColumn): void;
+    checkAutoHeights(rowNode: RowNode): void;
+    private doCheckAutoHeights;
+    setupCellAutoHeight(cellCtrl: CellCtrl, eCellWrapper: HTMLElement, compBean: BeanStub): void;
+    setAutoHeightActive(cols: ColumnCollections): void;
+}

package/dist/types/src/rendering/row/rowComp.d.ts

@@ -0,0 +1,20 @@
+import type { BeanCollection } from '../../context/context';
+import type { RowContainerType } from '../../gridBodyComp/rowContainer/rowContainerCtrl';
+import { Component } from '../../widgets/component';
+import type { RowCtrl } from './rowCtrl';
+export declare class RowComp extends Component {
+    private fullWidthCellRenderer;
+    private rowCtrl;
+    private domOrder;
+    private cellComps;
+    constructor(ctrl: RowCtrl, beans: BeanCollection, containerType: RowContainerType);
+    private getInitialStyle;
+    private showFullWidth;
+    private setCellCtrls;
+    private ensureDomOrder;
+    private newCellComp;
+    destroy(): void;
+    private destroyAllCells;
+    private setFullWidthRowComp;
+    private destroyCells;
+}