ag-grid-community 32.3.2 → 33.0.0

package/dist/types/src/csvExport/csvSerializingSession.d.ts

@@ -0,0 +1,26 @@
+import { BaseGridSerializingSession } from '../export/baseGridSerializingSession';
+import type { GridSerializingParams, RowAccumulator, RowSpanningAccumulator } from '../export/iGridSerializer';
+import type { CsvCustomContent } from '../interfaces/exportParams';
+interface CsvSerializingParams extends GridSerializingParams {
+    suppressQuotes: boolean;
+    columnSeparator: string;
+}
+export declare class CsvSerializingSession extends BaseGridSerializingSession<CsvCustomContent> {
+    private isFirstLine;
+    private result;
+    private suppressQuotes;
+    private columnSeparator;
+    constructor(config: CsvSerializingParams);
+    addCustomContent(content: CsvCustomContent): void;
+    onNewHeaderGroupingRow(): RowSpanningAccumulator;
+    private onNewHeaderGroupingRowColumn;
+    private appendEmptyCells;
+    onNewHeaderRow(): RowAccumulator;
+    private onNewHeaderRowColumn;
+    onNewBodyRow(): RowAccumulator;
+    private onNewBodyRowColumn;
+    private putInQuotes;
+    parse(): string;
+    private beginNewLine;
+}
+export {};

package/dist/types/src/ctrlsService.d.ts

@@ -0,0 +1,55 @@
+import type { NamedBean } from './context/bean';
+import { BeanStub } from './context/beanStub';
+import type { FakeHScrollComp } from './gridBodyComp/fakeHScrollComp';
+import type { FakeVScrollComp } from './gridBodyComp/fakeVScrollComp';
+import type { GridBodyCtrl } from './gridBodyComp/gridBodyCtrl';
+import type { GridBodyScrollFeature } from './gridBodyComp/gridBodyScrollFeature';
+import type { RowContainerCtrl } from './gridBodyComp/rowContainer/rowContainerCtrl';
+import type { GridCtrl } from './gridComp/gridCtrl';
+import type { GridHeaderCtrl } from './headerRendering/gridHeaderCtrl';
+import type { HeaderRowContainerCtrl } from './headerRendering/rowContainer/headerRowContainerCtrl';
+import type { ColumnPinnedType } from './interfaces/iColumn';
+/** If adding or removing a control, update `NUM_CTRLS` below. */
+interface ReadyParams {
+    gridCtrl: GridCtrl;
+    gridBodyCtrl: GridBodyCtrl;
+    center: RowContainerCtrl;
+    left: RowContainerCtrl;
+    right: RowContainerCtrl;
+    bottomCenter: RowContainerCtrl;
+    bottomLeft: RowContainerCtrl;
+    bottomRight: RowContainerCtrl;
+    topCenter: RowContainerCtrl;
+    topLeft: RowContainerCtrl;
+    topRight: RowContainerCtrl;
+    stickyTopCenter: RowContainerCtrl;
+    stickyTopLeft: RowContainerCtrl;
+    stickyTopRight: RowContainerCtrl;
+    stickyBottomCenter: RowContainerCtrl;
+    stickyBottomLeft: RowContainerCtrl;
+    stickyBottomRight: RowContainerCtrl;
+    fakeHScrollComp: FakeHScrollComp;
+    fakeVScrollComp: FakeVScrollComp;
+    gridHeaderCtrl: GridHeaderCtrl;
+    centerHeader: HeaderRowContainerCtrl;
+    leftHeader: HeaderRowContainerCtrl;
+    rightHeader: HeaderRowContainerCtrl;
+}
+type CtrlType = keyof ReadyParams;
+type BeanDestroyFunc = Pick<BeanStub<any>, 'addDestroyFunc'>;
+export declare class CtrlsService extends BeanStub<'ready'> implements NamedBean {
+    beanName: "ctrlsSvc";
+    private params;
+    private ready;
+    private readyCallbacks;
+    postConstruct(): void;
+    private updateReady;
+    whenReady(caller: BeanDestroyFunc, callback: (p: ReadyParams) => void): void;
+    register<K extends CtrlType, T extends ReadyParams[K]>(ctrlType: K, ctrl: T): void;
+    get<K extends CtrlType>(ctrlType: K): ReadyParams[K];
+    getGridBodyCtrl(): GridBodyCtrl;
+    getHeaderRowContainerCtrls(): HeaderRowContainerCtrl[];
+    getHeaderRowContainerCtrl(pinned?: ColumnPinnedType): HeaderRowContainerCtrl | undefined;
+    getScrollFeature(): GridBodyScrollFeature;
+}
+export {};

package/dist/types/src/dragAndDrop/dragAndDropImageComponent.css-GENERATED.d.ts

@@ -0,0 +1 @@
+export declare const dragAndDropImageComponentCSS = ".ag-dnd-ghost{align-items:center;background-color:var(--ag-drag-and-drop-image-background-color);border:var(--ag-drag-and-drop-image-border);border-radius:var(--ag-border-radius);box-shadow:var(--ag-drag-and-drop-image-shadow);color:var(--ag-text-color);cursor:move;display:flex;font-weight:500;gap:var(--ag-cell-widget-spacing);height:var(--ag-header-height);overflow:hidden;padding-left:var(--ag-cell-horizontal-padding);padding-right:var(--ag-cell-horizontal-padding);text-overflow:ellipsis;transform:translateY(calc(var(--ag-spacing)*2));white-space:nowrap}";

package/dist/types/src/dragAndDrop/dragAndDropImageComponent.d.ts

@@ -0,0 +1,25 @@
+import type { AgGridCommon } from '../interfaces/iCommon';
+import type { IComponent } from '../interfaces/iComponent';
+import { Component } from '../widgets/component';
+import type { DragAndDropIcon, DragSource } from './dragAndDropService';
+export interface IDragAndDropImageParams<TData = any, TContext = any> extends AgGridCommon<TData, TContext> {
+    dragSource: DragSource;
+}
+export interface IDragAndDropImage {
+    setIcon(iconName: string | null, shake: boolean): void;
+    setLabel(label: string): void;
+}
+export interface IDragAndDropImageComponent<TData = any, TContext = any, TParams extends Readonly<IDragAndDropImageParams<TData, TContext>> = IDragAndDropImageParams<TData, TContext>> extends IComponent<TParams>, IDragAndDropImage {
+}
+export declare class DragAndDropImageComponent extends Component implements IDragAndDropImageComponent<any, any> {
+    private dragSource;
+    private readonly eIcon;
+    private readonly eLabel;
+    private dropIconMap;
+    constructor();
+    postConstruct(): void;
+    init(params: IDragAndDropImageParams): void;
+    destroy(): void;
+    setIcon(iconName: DragAndDropIcon | null, shake: boolean): void;
+    setLabel(label: string): void;
+}

package/dist/types/src/dragAndDrop/dragAndDropService.d.ts

@@ -0,0 +1,153 @@
+import type { HorizontalDirection, VerticalDirection } from '../constants/direction';
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+import type { BeanCollection } from '../context/context';
+import type { AgGridCommon } from '../interfaces/iCommon';
+import type { DragItem } from '../interfaces/iDragItem';
+import type { IDragAndDropImageComponent } from './dragAndDropImageComponent';
+import type { RowDropZoneParams } from './rowDragFeature';
+export declare enum DragSourceType {
+    ToolPanel = 0,
+    HeaderCell = 1,
+    RowDrag = 2,
+    ChartPanel = 3,
+    AdvancedFilterBuilder = 4
+}
+export interface DragSource {
+    /**
+     * The type of the drag source, used by the drop target to know where the
+     * drag originated from.
+     */
+    type: DragSourceType;
+    /** Can be used to identify a specific component as the source */
+    sourceId?: string;
+    /**
+     * Element which, when dragged, will kick off the DnD process
+     */
+    eElement: Element;
+    /**
+     * If eElement is dragged, then the dragItem is the object that gets passed around.
+     */
+    getDragItem: () => DragItem;
+    /**
+     * This name appears in the drag and drop image component when dragging.
+     */
+    dragItemName: string | (() => string) | null;
+    /**
+     * Icon to show when not over a drop zone
+     */
+    getDefaultIconName?: () => DragAndDropIcon;
+    /**
+     * The drag source DOM Data Key, this is useful to detect if the origin grid is the same
+     * as the target grid.
+     */
+    dragSourceDomDataKey?: string;
+    /**
+     * After how many pixels of dragging should the drag operation start. Default is 4.
+     */
+    dragStartPixels?: number;
+    /**
+     * Callback for drag started
+     */
+    onDragStarted?: () => void;
+    /**
+     * Callback for drag stopped
+     */
+    onDragStopped?: () => void;
+    /**
+     * Callback for drag cancelled
+     */
+    onDragCancelled?: () => void;
+    /**
+     * Callback for entering the grid
+     */
+    onGridEnter?: (dragItem: DragItem | null) => void;
+    /**
+     * Callback for exiting the grid
+     */
+    onGridExit?: (dragItem: DragItem | null) => void;
+}
+export interface DropTarget {
+    /** The main container that will get the drop. */
+    getContainer(): HTMLElement;
+    /** If any secondary containers. For example when moving columns in AG Grid, we listen for drops
+     * in the header as well as the body (main rows and pinned rows) of the grid. */
+    getSecondaryContainers?(): HTMLElement[][];
+    /** Icon to show when drag is over */
+    getIconName?(): DragAndDropIcon | null;
+    isInterestedIn(type: DragSourceType, el: Element): boolean;
+    /**
+     * If `true`, the DragSources will only be allowed to be dragged within the DragTarget that contains them.
+     * This is useful for changing order of items within a container, and not moving items across containers.
+     * @default false
+     */
+    targetContainsSource?: boolean;
+    /** Callback for when drag enters */
+    onDragEnter?(params: DraggingEvent): void;
+    /** Callback for when drag leaves */
+    onDragLeave?(params: DraggingEvent): void;
+    /** Callback for when dragging */
+    onDragging?(params: DraggingEvent): void;
+    /** Callback for when drag stops */
+    onDragStop?(params: DraggingEvent): void;
+    /** Callback for when the drag is cancelled */
+    onDragCancel?(params: DraggingEvent): void;
+    external?: boolean;
+}
+export interface DraggingEvent<TData = any, TContext = any> extends AgGridCommon<TData, TContext> {
+    event: MouseEvent;
+    x: number;
+    y: number;
+    vDirection: VerticalDirection | null;
+    hDirection: HorizontalDirection | null;
+    dragSource: DragSource;
+    dragItem: DragItem;
+    fromNudge: boolean;
+    dropZoneTarget: HTMLElement;
+}
+export type DragAndDropIcon = 'pinned' | 'move' | 'left' | 'right' | 'group' | 'aggregate' | 'pivot' | 'notAllowed' | 'hide';
+export declare class DragAndDropService extends BeanStub implements NamedBean {
+    beanName: "dragAndDrop";
+    private ctrlsSvc;
+    private dragSvc;
+    private environment;
+    private userCompFactory;
+    wireBeans(beans: BeanCollection): void;
+    private dragSourceAndParamsList;
+    private dragItem;
+    private eventLastTime;
+    private dragSource;
+    private dragging;
+    private dragAndDropImageComp;
+    private dragAndDropImageParent;
+    private dropTargets;
+    private lastDropTarget;
+    addDragSource(dragSource: DragSource, allowTouch?: boolean): void;
+    getDragAndDropImageComponent(): IDragAndDropImageComponent | null;
+    removeDragSource(dragSource: DragSource): void;
+    destroy(): void;
+    nudge(): void;
+    private onDragStart;
+    private onDragStop;
+    private onDragCancel;
+    private clearDragAndDropProperties;
+    private onDragging;
+    private getAllContainersFromDropTarget;
+    private isMouseOnDropTarget;
+    private findCurrentDropTarget;
+    private enterDragTargetIfExists;
+    private leaveLastTargetIfExists;
+    addDropTarget(dropTarget: DropTarget): void;
+    removeDropTarget(dropTarget: DropTarget): void;
+    hasExternalDropZones(): boolean;
+    findExternalZone(params: RowDropZoneParams): DropTarget | null;
+    isDropZoneWithinThisGrid(draggingEvent: DraggingEvent): boolean;
+    getHorizontalDirection(event: MouseEvent): HorizontalDirection | null;
+    getVerticalDirection(event: MouseEvent): VerticalDirection | null;
+    createDropTargetEvent(dropTarget: DropTarget, event: MouseEvent, hDirection: HorizontalDirection | null, vDirection: VerticalDirection | null, fromNudge: boolean): DraggingEvent;
+    private positionDragAndDropImageComp;
+    private removeDragAndDropImageComponent;
+    private createDragAndDropImageComponent;
+    private processDragAndDropImageComponent;
+    registerGridDropTarget(elementFn: () => HTMLElement, ctrl: BeanStub): void;
+}

package/dist/types/src/dragAndDrop/dragApi.d.ts

@@ -0,0 +1,5 @@
+import type { BeanCollection } from '../context/context';
+import type { RowDropZoneEvents, RowDropZoneParams } from './rowDragFeature';
+export declare function addRowDropZone(beans: BeanCollection, params: RowDropZoneParams): void;
+export declare function removeRowDropZone(beans: BeanCollection, params: RowDropZoneParams): void;
+export declare function getRowDropZoneParams(beans: BeanCollection, events?: RowDropZoneEvents): RowDropZoneParams | undefined;

package/dist/types/src/dragAndDrop/dragModule.d.ts

@@ -0,0 +1,24 @@
+import type { _DragGridApi } from '../api/gridApi';
+import type { _ModuleWithApi, _ModuleWithoutApi } from '../interfaces/iModule';
+/**
+ * @internal
+ */
+export declare const DragModule: _ModuleWithoutApi;
+/**
+ * @feature Import & Export -> Drag & Drop
+ * @colDef dndSource, dndSourceOnRowDrag
+ */
+export declare const DragAndDropModule: _ModuleWithoutApi;
+/**
+ * @internal
+ */
+export declare const SharedDragAndDropModule: _ModuleWithoutApi;
+/**
+ * @feature Rows -> Row Dragging
+ * @colDef rowDrag
+ */
+export declare const RowDragModule: _ModuleWithApi<_DragGridApi>;
+/**
+ * @internal
+ */
+export declare const HorizontalResizeModule: _ModuleWithoutApi;

package/dist/types/src/dragAndDrop/dragService.d.ts

@@ -0,0 +1,53 @@
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+/** Adds drag listening onto an element. In AG Grid this is used twice, first is resizing columns,
+ * second is moving the columns and column groups around (ie the 'drag' part of Drag and Drop. */
+export declare class DragService extends BeanStub implements NamedBean {
+    beanName: "dragSvc";
+    private currentDragParams;
+    dragging: boolean;
+    startTarget: EventTarget | null;
+    private mouseStartEvent;
+    private touchLastTime;
+    private touchStart;
+    private dragEndFunctions;
+    private readonly dragSources;
+    destroy(): void;
+    private removeListener;
+    removeDragSource(params: DragListenerParams): void;
+    addDragSource(params: DragListenerParams): void;
+    private onTouchStart;
+    private onMouseDown;
+    private addTemporaryEvents;
+    private isEventNearStartEvent;
+    private getFirstActiveTouch;
+    private onCommonMove;
+    private onTouchMove;
+    private onMouseMove;
+    private shouldPreventMouseEvent;
+    onTouchUp(touchEvent: TouchEvent, el: Element): void;
+    onMouseUp(mouseEvent: MouseEvent, el: Element): void;
+    onUpCommon(eventOrTouch: MouseEvent | Touch, el: Element): void;
+    cancelDrag(el: Element): void;
+    private resetDragProperties;
+}
+export interface DragListenerParams {
+    /** After how many pixels of dragging should the drag operation start. Default is 4px. */
+    dragStartPixels?: number;
+    /** Dom element to add the drag handling to */
+    eElement: Element;
+    /** Some places may wish to ignore certain events, eg range selection ignores shift clicks */
+    skipMouseEvent?: (mouseEvent: MouseEvent) => boolean;
+    /** Callback for drag starting */
+    onDragStart: (mouseEvent: MouseEvent | Touch) => void;
+    /** Callback for drag stopping */
+    onDragStop: (mouseEvent: MouseEvent | Touch) => void;
+    /** Callback for drag cancel */
+    onDragCancel?: () => void;
+    /** Callback for mouse move while dragging */
+    onDragging: (mouseEvent: MouseEvent | Touch) => void;
+    /** Include touch events for this Drag Listener */
+    includeTouch?: boolean;
+    /** If `true`, it will stop the propagation of Touch Events */
+    stopPropagationForTouch?: boolean;
+}

package/dist/types/src/dragAndDrop/horizontalResizeService.d.ts

@@ -0,0 +1,20 @@
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+export interface HorizontalResizeParams {
+    eResizeBar: HTMLElement;
+    dragStartPixels?: number;
+    onResizeStart: (shiftKey: boolean) => void;
+    onResizing: (delta: number) => void;
+    onResizeEnd: (delta: number) => void;
+}
+export declare class HorizontalResizeService extends BeanStub implements NamedBean {
+    beanName: "horizontalResizeSvc";
+    private dragStartX;
+    private resizeAmount;
+    addResizeBar(params: HorizontalResizeParams): () => void;
+    private onDragStart;
+    private setResizeIcons;
+    private onDragStop;
+    private resetIcons;
+    private onDragging;
+}

package/dist/types/src/dragAndDrop/rowDragComp.d.ts

@@ -0,0 +1,24 @@
+import type { AgColumn } from '../entities/agColumn';
+import type { RowNode } from '../entities/rowNode';
+import { Component } from '../widgets/component';
+export declare class RowDragComp extends Component {
+    private readonly cellValueFn;
+    private readonly rowNode;
+    private readonly column?;
+    private readonly customGui?;
+    private readonly dragStartPixels?;
+    private readonly suppressVisibilityChange?;
+    private dragSource;
+    private mouseDownListener;
+    constructor(cellValueFn: () => string, rowNode: RowNode, column?: AgColumn<any> | undefined, customGui?: HTMLElement | undefined, dragStartPixels?: number | undefined, suppressVisibilityChange?: boolean | undefined);
+    isCustomGui(): boolean;
+    postConstruct(): void;
+    setDragElement(dragElement: HTMLElement, dragStartPixels?: number): void;
+    private getSelectedNodes;
+    private getDragItem;
+    private getRowDragText;
+    private addDragSource;
+    destroy(): void;
+    private removeDragSource;
+    private removeMouseDownListener;
+}

package/dist/types/src/dragAndDrop/rowDragFeature.d.ts

@@ -0,0 +1,55 @@
+import { BeanStub } from '../context/beanStub';
+import type { RowDragCancelEvent, RowDragEndEvent, RowDragEnterEvent, RowDragLeaveEvent, RowDragMoveEvent } from '../events';
+import type { DragAndDropIcon, DraggingEvent, DropTarget } from './dragAndDropService';
+import { DragSourceType } from './dragAndDropService';
+export interface RowDropZoneEvents {
+    /** Callback function that will be executed when the rowDrag enters the target. */
+    onDragEnter?: (params: RowDragEnterEvent) => void;
+    /** Callback function that will be executed when the rowDrag leaves the target */
+    onDragLeave?: (params: RowDragLeaveEvent) => void;
+    /**
+     * Callback function that will be executed when the rowDrag is dragged inside the target.
+     * Note: this gets called multiple times.
+     */
+    onDragging?: (params: RowDragMoveEvent) => void;
+    /** Callback function that will be executed when the rowDrag drops rows within the target. */
+    onDragStop?: (params: RowDragEndEvent) => void;
+    onDragCancel?: (params: RowDragCancelEvent) => void;
+}
+export interface RowDropZoneParams extends RowDropZoneEvents {
+    /** A callback method that returns the DropZone HTMLElement. */
+    getContainer: () => HTMLElement;
+}
+export declare class RowDragFeature extends BeanStub implements DropTarget {
+    private clientSideRowModel;
+    private eContainer;
+    private lastDraggingEvent;
+    private autoScrollService;
+    constructor(eContainer: HTMLElement);
+    postConstruct(): void;
+    getContainer(): HTMLElement;
+    isInterestedIn(type: DragSourceType): boolean;
+    getIconName(): DragAndDropIcon;
+    shouldPreventRowMove(): boolean;
+    private getRowNodes;
+    onDragEnter(draggingEvent: DraggingEvent): void;
+    onDragging(draggingEvent: DraggingEvent): void;
+    private isFromThisGrid;
+    private onEnterOrDragging;
+    private doManagedDrag;
+    private getRowIndexNumber;
+    private moveRowAndClearHighlight;
+    private clearRowHighlight;
+    private moveRows;
+    addRowDropZone(params: RowDropZoneParams & {
+        fromGrid?: boolean;
+    }): void;
+    getRowDropZone(events?: RowDropZoneEvents): RowDropZoneParams;
+    private draggingToRowDragEvent;
+    private dispatchGridEvent;
+    onDragLeave(draggingEvent: DraggingEvent): void;
+    onDragStop(draggingEvent: DraggingEvent): void;
+    onDragCancel(draggingEvent: DraggingEvent): void;
+    private stopDragging;
+    private setRowNodeDragging;
+}

package/dist/types/src/dragAndDrop/rowDragService.d.ts

@@ -0,0 +1,14 @@
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+import type { AgColumn } from '../entities/agColumn';
+import type { RowNode } from '../entities/rowNode';
+import { RowDragComp } from './rowDragComp';
+import { RowDragFeature } from './rowDragFeature';
+export declare class RowDragService extends BeanStub implements NamedBean {
+    beanName: "rowDragSvc";
+    rowDragFeature?: RowDragFeature;
+    setupRowDrag(element: HTMLElement, ctrl: BeanStub): void;
+    createRowDragComp(cellValueFn: () => string, rowNode: RowNode, column?: AgColumn, customGui?: HTMLElement, dragStartPixels?: number, suppressVisibilityChange?: boolean): RowDragComp;
+    createRowDragCompForRow(rowNode: RowNode, element: HTMLElement): RowDragComp | undefined;
+    createRowDragCompForCell(rowNode: RowNode, column: AgColumn, cellValueFn: () => string, element?: HTMLElement, dragStartPixels?: number, suppressVisibilityChange?: boolean): RowDragComp | undefined;
+}

package/dist/types/src/edit/cell-editing.css-GENERATED.d.ts

@@ -0,0 +1 @@
+export declare const cellEditingCSS = ".ag-cell-inline-editing{border:var(--ag-cell-editing-border)!important;border-radius:var(--ag-border-radius);box-shadow:var(--ag-cell-editing-shadow);padding:0;z-index:1;.ag-cell-edit-wrapper,.ag-cell-editor,.ag-cell-wrapper,:where(.ag-cell-editor) .ag-input-field-input,:where(.ag-cell-editor) .ag-wrapper{height:100%;line-height:normal;width:100%}}:where(.ag-popup-editor) .ag-large-text{background-color:var(--ag-background-color);border-radius:var(--ag-border-radius);box-shadow:var(--ag-dropdown-shadow);padding:0}.ag-large-text-input{height:auto;padding:var(--ag-cell-horizontal-padding)}:where(.ag-rtl .ag-large-text-input) textarea{resize:none}:where(.ag-ltr) .ag-checkbox-edit{padding-left:var(--ag-cell-horizontal-padding)}:where(.ag-rtl) .ag-checkbox-edit{padding-right:var(--ag-cell-horizontal-padding)}";

package/dist/types/src/edit/cellEditors/dateStringCellEditor.d.ts

@@ -0,0 +1,6 @@
+import type { AgInputDateField } from '../../widgets/agInputDateField';
+import type { IDateStringCellEditorParams } from './iDateStringCellEditor';
+import { SimpleCellEditor } from './simpleCellEditor';
+export declare class DateStringCellEditor extends SimpleCellEditor<string, IDateStringCellEditorParams, AgInputDateField> {
+    constructor();
+}

package/dist/types/src/edit/cellEditors/selectCellEditor.d.ts

@@ -0,0 +1,20 @@
+import type { BeanCollection } from '../../context/context';
+import type { ICellEditorComp, ICellEditorParams } from '../../interfaces/iCellEditor';
+import { PopupComponent } from '../../widgets/popupComponent';
+import type { ISelectCellEditorParams } from './iSelectCellEditor';
+interface SelectCellEditorParams<TData = any, TValue = any, TContext = any> extends ISelectCellEditorParams<TValue>, ICellEditorParams<TData, TValue, TContext> {
+}
+export declare class SelectCellEditor extends PopupComponent implements ICellEditorComp {
+    private focusAfterAttached;
+    private valueSvc;
+    wireBeans(beans: BeanCollection): void;
+    private readonly eSelect;
+    private startedByEnter;
+    constructor();
+    init(params: SelectCellEditorParams): void;
+    afterGuiAttached(): void;
+    focusIn(): void;
+    getValue(): any;
+    isPopup(): boolean;
+}
+export {};

package/dist/types/src/edit/editApi.d.ts

@@ -0,0 +1,12 @@
+import type { StartEditingCellParams } from '../api/gridApi';
+import type { BeanCollection } from '../context/context';
+import type { GetCellEditorInstancesParams, ICellEditor } from '../interfaces/iCellEditor';
+import type { CellPosition } from '../interfaces/iCellPosition';
+export declare function undoCellEditing(beans: BeanCollection): void;
+export declare function redoCellEditing(beans: BeanCollection): void;
+export declare function getCellEditorInstances<TData = any>(beans: BeanCollection, params?: GetCellEditorInstancesParams<TData>): ICellEditor[];
+export declare function getEditingCells(beans: BeanCollection): CellPosition[];
+export declare function stopEditing(beans: BeanCollection, cancel?: boolean): void;
+export declare function startEditingCell(beans: BeanCollection, params: StartEditingCellParams): void;
+export declare function getCurrentUndoSize(beans: BeanCollection): number;
+export declare function getCurrentRedoSize(beans: BeanCollection): number;

package/dist/types/src/edit/editModule.d.ts

@@ -0,0 +1,38 @@
+import type { _EditGridApi, _UndoRedoGridApi } from '../api/gridApi';
+import type { _ModuleWithApi, _ModuleWithoutApi } from '../interfaces/iModule';
+/**
+ * @internal
+ */
+export declare const EditCoreModule: _ModuleWithApi<_EditGridApi<any>>;
+/**
+ * @feature Editing -> Undo / Redo Edits
+ */
+export declare const UndoRedoEditModule: _ModuleWithApi<_UndoRedoGridApi>;
+/**
+ * @feature Editing -> Text Editor
+ */
+export declare const TextEditorModule: _ModuleWithoutApi;
+/**
+ * @feature Editing -> Number Editor
+ */
+export declare const NumberEditorModule: _ModuleWithoutApi;
+/**
+ * @feature Editing -> Date Editor
+ */
+export declare const DateEditorModule: _ModuleWithoutApi;
+/**
+ * @feature Editing -> Checkbox Editor
+ */
+export declare const CheckboxEditorModule: _ModuleWithoutApi;
+/**
+ * @feature Editing -> Select Editor
+ */
+export declare const SelectEditorModule: _ModuleWithoutApi;
+/**
+ * @feature Editing -> Large Text Editor
+ */
+export declare const LargeTextEditorModule: _ModuleWithoutApi;
+/**
+ * @feature Editing
+ */
+export declare const CustomEditorModule: _ModuleWithoutApi;

package/dist/types/src/edit/editService.d.ts

@@ -0,0 +1,32 @@
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+import type { AgColumn } from '../entities/agColumn';
+import type { ICellEditorParams } from '../interfaces/iCellEditor';
+import type { IRowNode } from '../interfaces/iRowNode';
+import type { CellCtrl } from '../rendering/cell/cellCtrl';
+import type { RowCtrl } from '../rendering/row/rowCtrl';
+import { PopupEditorWrapper } from './cellEditors/popupEditorWrapper';
+export declare class EditService extends BeanStub implements NamedBean {
+    beanName: "editSvc";
+    startEditing(cellCtrl: CellCtrl, key?: string | null, cellStartedEdit?: boolean, event?: KeyboardEvent | MouseEvent | null): boolean;
+    /**
+     * Ends the Cell Editing
+     * @param cancel `True` if the edit process is being canceled.
+     * @returns `True` if the value of the `GridCell` has been updated, otherwise `False`.
+     */
+    stopEditing(cellCtrl: CellCtrl, cancel?: boolean): boolean;
+    handleColDefChanged(cellCtrl: CellCtrl): void;
+    setFocusOutOnEditor(cellCtrl: CellCtrl): void;
+    setFocusInOnEditor(cellCtrl: CellCtrl): void;
+    stopEditingAndFocus(cellCtrl: CellCtrl, suppressNavigateAfterEdit?: boolean, shiftKey?: boolean): void;
+    createPopupEditorWrapper(params: ICellEditorParams): PopupEditorWrapper;
+    stopAllEditing(cancel?: boolean): void;
+    stopRowEditing(rowCtrl: RowCtrl, cancel?: boolean): void;
+    addStopEditingWhenGridLosesFocus(viewports: HTMLElement[]): void;
+    setInlineEditingCss(rowCtrl: RowCtrl): void;
+    isCellEditable(column: AgColumn, rowNode: IRowNode): boolean;
+    startRowOrCellEdit(cellCtrl: CellCtrl, key?: string | null, event?: KeyboardEvent | MouseEvent | null): boolean;
+    stopRowOrCellEdit(cellCtrl: CellCtrl, cancel?: boolean): void;
+    private createCellEditorParams;
+    private navigateAfterEdit;
+}

package/dist/types/src/edit/rowEditService.d.ts

@@ -0,0 +1,9 @@
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+import type { CellCtrl } from '../rendering/cell/cellCtrl';
+import type { RowCtrl } from '../rendering/row/rowCtrl';
+export declare class RowEditService extends BeanStub implements NamedBean {
+    beanName: "rowEditSvc";
+    startEditing(rowCtrl: RowCtrl, key?: string | null, sourceRenderedCell?: CellCtrl | null, event?: KeyboardEvent | null): boolean;
+    setEditing(rowCtrl: RowCtrl, value: boolean): void;
+}