ag-grid-community 32.3.2 → 33.0.0

package/dist/types/src/columns/selectionColService.d.ts

@@ -0,0 +1,21 @@
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+import { AgColumn } from '../entities/agColumn';
+import type { ColumnEventType } from '../events';
+import type { ColKey, ColumnCollections } from './columnModel';
+export declare const CONTROLS_COLUMN_ID_PREFIX: "ag-Grid-SelectionColumn";
+export declare class SelectionColService extends BeanStub implements NamedBean {
+    beanName: "selectionColSvc";
+    selectionCols: ColumnCollections | null;
+    postConstruct(): void;
+    addSelectionCols(cols: ColumnCollections): void;
+    createSelectionCols(cols: ColumnCollections, updateOrders: (callback: (cols: AgColumn[] | null) => AgColumn[] | null) => void): void;
+    isSelectionColumnEnabled(): boolean;
+    private generateSelectionCols;
+    putSelectionColsFirstInList(list: AgColumn[], cols?: AgColumn[] | null): AgColumn[] | null;
+    getSelectionCol(key: ColKey): AgColumn | null;
+    getSelectionCols(): AgColumn[] | null;
+    private onSelectionOptionsChanged;
+    destroy(): void;
+    refreshVisibility(source: ColumnEventType): void;
+}

package/dist/types/src/columns/visibleColsService.d.ts

@@ -0,0 +1,52 @@
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+import type { AgColumn } from '../entities/agColumn';
+import type { AgColumnGroup } from '../entities/agColumnGroup';
+import type { RowNode } from '../entities/rowNode';
+import type { ColumnEventType } from '../events';
+import type { ColumnPinnedType } from '../interfaces/iColumn';
+export declare class VisibleColsService extends BeanStub implements NamedBean {
+    beanName: "visibleCols";
+    treeLeft: (AgColumn | AgColumnGroup)[];
+    treeRight: (AgColumn | AgColumnGroup)[];
+    treeCenter: (AgColumn | AgColumnGroup)[];
+    private colsAndGroupsMap;
+    leftCols: AgColumn[];
+    rightCols: AgColumn[];
+    centerCols: AgColumn[];
+    allCols: AgColumn[];
+    autoHeightCols: AgColumn[];
+    bodyWidth: number;
+    private leftWidth;
+    private rightWidth;
+    isBodyWidthDirty: boolean;
+    private ariaOrderColumns;
+    refresh(source: ColumnEventType, skipTreeBuild?: boolean): void;
+    updateBodyWidths(): void;
+    setLeftValues(source: ColumnEventType): void;
+    private setFirstRightAndLastLeftPinned;
+    private buildTrees;
+    clear(): void;
+    private joinColsAriaOrder;
+    getAriaColIndex(colOrGroup: AgColumn | AgColumnGroup): number;
+    private setLeftValuesOfGroups;
+    private setLeftValuesOfCols;
+    private joinCols;
+    getAllTrees(): (AgColumn | AgColumnGroup)[] | null;
+    isColDisplayed(column: AgColumn): boolean;
+    getLeftColsForRow(rowNode: RowNode): AgColumn[];
+    getRightColsForRow(rowNode: RowNode): AgColumn[];
+    getColsForRow(rowNode: RowNode, displayedColumns: AgColumn[], filterCallback?: (column: AgColumn) => boolean, emptySpaceBeforeColumn?: (column: AgColumn) => boolean): AgColumn[];
+    getContainerWidth(pinned: ColumnPinnedType): number;
+    getColBefore(col: AgColumn): AgColumn | null;
+    isPinningLeft(): boolean;
+    isPinningRight(): boolean;
+    private updateColsAndGroupsMap;
+    isVisible(item: AgColumn | AgColumnGroup): boolean;
+    getFirstColumn(): AgColumn | null;
+    getColAfter(col: AgColumn): AgColumn | null;
+    getColsLeftWidth(): number;
+    getDisplayedColumnsRightWidth(): number;
+    isColAtEdge(col: AgColumn | AgColumnGroup, edge: 'first' | 'last'): boolean;
+}
+export declare function depthFirstAllColumnTreeSearch(tree: (AgColumn | AgColumnGroup)[] | null, useDisplayedChildren: boolean, callback: (treeNode: AgColumn | AgColumnGroup) => void): void;

package/dist/types/src/components/framework/agComponentUtils.d.ts

@@ -0,0 +1,7 @@
+import type { NamedBean } from '../../context/bean';
+import { BeanStub } from '../../context/beanStub';
+import type { ComponentType } from '../../interfaces/iUserCompDetails';
+export declare class AgComponentUtils extends BeanStub implements NamedBean {
+    beanName: "agCompUtils";
+    adaptFunction(type: ComponentType, jsCompFunc: any): any;
+}

package/dist/types/src/components/framework/cellRendererFunctionModule.d.ts

@@ -0,0 +1,5 @@
+import type { _ModuleWithoutApi } from '../../interfaces/iModule';
+/**
+ * @internal
+ */
+export declare const CellRendererFunctionModule: _ModuleWithoutApi;

package/dist/types/src/components/framework/frameworkComponentWrapper.d.ts

@@ -0,0 +1,26 @@
+import type { IComponent } from '../../interfaces/iComponent';
+import type { ComponentType } from '../../interfaces/iUserCompDetails';
+/**
+ * B the business interface (ie IHeader)
+ * A the agGridComponent interface (ie IHeaderComp). The final object acceptable by ag-grid
+ */
+export interface FrameworkComponentWrapper {
+    wrap<A extends IComponent<any>>(frameworkComponent: {
+        new (): any;
+    } | null, mandatoryMethods: string[] | undefined, optionalMethods: string[] | undefined, componentType: ComponentType): A;
+}
+export interface WrappableInterface {
+    hasMethod(name: string): boolean;
+    callMethod(name: string, args: IArguments): void;
+    addMethod(name: string, callback: (...args: any[]) => any): void;
+}
+export declare abstract class BaseComponentWrapper<F extends WrappableInterface> implements FrameworkComponentWrapper {
+    wrap<A extends IComponent<any>>(OriginalConstructor: {
+        new (): any;
+    }, mandatoryMethods: string[] | undefined, optionalMethods: string[] | undefined, componentType: ComponentType): A;
+    protected abstract createWrapper(OriginalConstructor: {
+        new (): any;
+    }, componentType: ComponentType): F;
+    private createMethod;
+    protected createMethodProxy(wrapper: F, methodName: string, mandatory: boolean): (...args: any[]) => any;
+}

package/dist/types/src/components/framework/registry.d.ts

@@ -0,0 +1,25 @@
+import type { NamedBean } from '../../context/bean';
+import { BeanStub } from '../../context/beanStub';
+import type { DynamicBeanName } from '../../context/context';
+import type { Module } from '../../interfaces/iModule';
+import type { IconName, IconValue } from '../../utils/icon';
+import type { AgComponentSelector, ComponentSelector } from '../../widgets/component';
+export declare class Registry extends BeanStub implements NamedBean {
+    beanName: "registry";
+    private agGridDefaults;
+    private agGridDefaultParams;
+    private jsComps;
+    private dynamicBeans;
+    private selectors;
+    private icons;
+    postConstruct(): void;
+    registerModule(module: Module): void;
+    getUserComponent(propertyName: string, name: string): {
+        componentFromFramework: boolean;
+        component: any;
+        params?: any;
+    } | null;
+    createDynamicBean<T>(name: DynamicBeanName, mandatory: boolean, ...args: any[]): T | undefined;
+    getSelector(name: AgComponentSelector): ComponentSelector | undefined;
+    getIcon(name: IconName): IconValue | undefined;
+}

package/dist/types/src/components/framework/userCompUtils.d.ts

@@ -0,0 +1,52 @@
+import type { IDragAndDropImageComponent, IDragAndDropImageParams } from '../../dragAndDrop/dragAndDropImageComponent';
+import type { ColDef } from '../../entities/colDef';
+import type { IFloatingFilterComp, IFloatingFilterParams } from '../../filter/floating/floatingFilter';
+import type { IHeaderComp, IHeaderParams, IInnerHeaderComponent } from '../../headerRendering/cells/column/headerComp';
+import type { IHeaderGroupComp, IHeaderGroupParams, IInnerHeaderGroupComponent } from '../../headerRendering/cells/columnGroup/headerGroupComp';
+import type { IDateComp, IDateParams } from '../../interfaces/dateComponent';
+import type { ICellEditorComp, ICellEditorParams } from '../../interfaces/iCellEditor';
+import type { AgGridCommon, WithoutGridCommon } from '../../interfaces/iCommon';
+import type { IFilterComp, IFilterDef, IFilterParams } from '../../interfaces/iFilter';
+import type { IFrameworkOverrides } from '../../interfaces/iFrameworkOverrides';
+import type { ILoadingCellRendererComp } from '../../interfaces/iLoadingCellRenderer';
+import type { UserCompDetails } from '../../interfaces/iUserCompDetails';
+import type { ICellRendererComp, ICellRendererParams } from '../../rendering/cellRenderers/iCellRenderer';
+import type { ILoadingOverlayComp, ILoadingOverlayParams } from '../../rendering/overlays/loadingOverlayComponent';
+import type { INoRowsOverlayComp, INoRowsOverlayParams } from '../../rendering/overlays/noRowsOverlayComponent';
+import type { ITooltipComp, ITooltipParams } from '../../tooltip/tooltipComponent';
+import type { UserComponentFactory } from './userComponentFactory';
+export declare function _getDragAndDropImageCompDetails(userCompFactory: UserComponentFactory, params: WithoutGridCommon<IDragAndDropImageParams>): UserCompDetails<IDragAndDropImageComponent> | undefined;
+export declare function _getInnerCellRendererDetails<TDefinition = any>(userCompFactory: UserComponentFactory, def: TDefinition, params: WithoutGridCommon<ICellRendererParams>): UserCompDetails<ICellRendererComp> | undefined;
+export declare function _getHeaderCompDetails(userCompFactory: UserComponentFactory, colDef: ColDef, params: WithoutGridCommon<IHeaderParams>): UserCompDetails<IHeaderComp> | undefined;
+export declare function _getInnerHeaderCompDetails(userCompFactory: UserComponentFactory, headerCompParams: IHeaderParams, params: WithoutGridCommon<IHeaderParams>): UserCompDetails<IInnerHeaderComponent> | undefined;
+export declare function _getHeaderGroupCompDetails(userCompFactory: UserComponentFactory, params: WithoutGridCommon<IHeaderGroupParams>): UserCompDetails<IHeaderGroupComp> | undefined;
+export declare function _getInnerHeaderGroupCompDetails(userCompFactory: UserComponentFactory, headerGroupCompParams: IHeaderGroupParams, params: WithoutGridCommon<IHeaderGroupParams>): UserCompDetails<IInnerHeaderGroupComponent> | undefined;
+export declare function _getFullWidthCellRendererDetails(userCompFactory: UserComponentFactory, params: WithoutGridCommon<ICellRendererParams>): UserCompDetails<ICellRendererComp> | undefined;
+export declare function _getFullWidthLoadingCellRendererDetails(userCompFactory: UserComponentFactory, params: WithoutGridCommon<ICellRendererParams>): UserCompDetails<ILoadingCellRendererComp> | undefined;
+export declare function _getFullWidthGroupCellRendererDetails(userCompFactory: UserComponentFactory, params: WithoutGridCommon<ICellRendererParams>): UserCompDetails<ICellRendererComp> | undefined;
+export declare function _getFullWidthDetailCellRendererDetails(userCompFactory: UserComponentFactory, params: WithoutGridCommon<ICellRendererParams>): UserCompDetails<ICellRendererComp> | undefined;
+export declare function _getCellRendererDetails<TDefinition = ColDef, TParams = ICellRendererParams>(userCompFactory: UserComponentFactory, def: TDefinition, params: WithoutGridCommon<TParams>): UserCompDetails<ICellRendererComp> | undefined;
+export declare function _getEditorRendererDetails<TDefinition, TEditorParams extends AgGridCommon<any, any>>(userCompFactory: UserComponentFactory, def: TDefinition, params: WithoutGridCommon<TEditorParams>): UserCompDetails | undefined;
+export declare function _getLoadingCellRendererDetails(userCompFactory: UserComponentFactory, def: ColDef, params: WithoutGridCommon<ICellRendererParams>): UserCompDetails<ILoadingCellRendererComp> | undefined;
+export declare function _getCellEditorDetails(userCompFactory: UserComponentFactory, def: ColDef, params: WithoutGridCommon<ICellEditorParams>): UserCompDetails<ICellEditorComp> | undefined;
+/**
+ * @param defaultFilter provided filters only
+ */
+export declare function _getFilterDetails(userCompFactory: UserComponentFactory, def: IFilterDef, params: WithoutGridCommon<IFilterParams>, defaultFilter: string): UserCompDetails<IFilterComp> | undefined;
+export declare function _getDateCompDetails(userCompFactory: UserComponentFactory, params: WithoutGridCommon<IDateParams>): UserCompDetails<IDateComp> | undefined;
+export declare function _getLoadingOverlayCompDetails(userCompFactory: UserComponentFactory, params: WithoutGridCommon<ILoadingOverlayParams>): UserCompDetails<ILoadingOverlayComp> | undefined;
+export declare function _getNoRowsOverlayCompDetails(userCompFactory: UserComponentFactory, params: WithoutGridCommon<INoRowsOverlayParams>): UserCompDetails<INoRowsOverlayComp> | undefined;
+export declare function _getTooltipCompDetails(userCompFactory: UserComponentFactory, params: WithoutGridCommon<ITooltipParams>): UserCompDetails<ITooltipComp> | undefined;
+/**
+ * @param defaultFloatingFilter provided floating filters only
+ */
+export declare function _getFloatingFilterCompDetails(userCompFactory: UserComponentFactory, def: IFilterDef, params: WithoutGridCommon<IFloatingFilterParams<any>>, defaultFloatingFilter: string): UserCompDetails<IFloatingFilterComp> | undefined;
+export declare function _getFilterCompKeys(frameworkOverrides: IFrameworkOverrides, def: IFilterDef): {
+    compName?: string | undefined;
+    jsComp: any;
+    fwComp: any;
+    paramsFromSelector: any;
+    popupFromSelector?: boolean | undefined;
+    popupPositionFromSelector?: "over" | "under" | undefined;
+};
+export declare function _mergeFilterParamsWithApplicationProvidedParams(userCompFactory: UserComponentFactory, defObject: ColDef, paramsFromGrid: IFilterParams): IFilterParams;

package/dist/types/src/components/framework/userComponentFactory.d.ts

@@ -0,0 +1,30 @@
+import type { NamedBean } from '../../context/bean';
+import { BeanStub } from '../../context/beanStub';
+import type { BeanCollection } from '../../context/context';
+import type { IComponent } from '../../interfaces/iComponent';
+import type { IFrameworkOverrides } from '../../interfaces/iFrameworkOverrides';
+import type { ComponentType, UserCompDetails } from '../../interfaces/iUserCompDetails';
+export declare function _getUserCompKeys<TDefinition>(frameworkOverrides: IFrameworkOverrides, defObject: TDefinition, type: ComponentType, params?: any): {
+    compName?: string;
+    jsComp: any;
+    fwComp: any;
+    paramsFromSelector: any;
+    popupFromSelector?: boolean;
+    popupPositionFromSelector?: 'over' | 'under';
+};
+export declare class UserComponentFactory extends BeanStub implements NamedBean {
+    beanName: "userCompFactory";
+    private gridOptions;
+    private agCompUtils?;
+    private registry;
+    private frameworkCompWrapper?;
+    wireBeans(beans: BeanCollection): void;
+    getCompDetailsFromGridOptions(type: ComponentType, defaultName: string | undefined, params: any, mandatory?: boolean): UserCompDetails | undefined;
+    getCompDetails<TDefinition, TComp extends IComponent<any>>(defObject: TDefinition, type: ComponentType, defaultName: string | undefined, params: any, mandatory?: boolean): UserCompDetails<TComp> | undefined;
+    private newAgStackInstance;
+    /**
+     * merges params with application provided params
+     * used by Floating Filter
+     */
+    mergeParams<TDefinition>(defObject: TDefinition, type: ComponentType, paramsFromGrid: any, paramsFromSelector?: any, defaultCompParams?: any): any;
+}

package/dist/types/src/constants/direction.d.ts

@@ -0,0 +1,2 @@
+export type VerticalDirection = 'up' | 'down';
+export type HorizontalDirection = 'left' | 'right';

package/dist/types/src/constants/keyCode.d.ts

@@ -0,0 +1,24 @@
+export declare const KeyCode: {
+    readonly BACKSPACE: "Backspace";
+    readonly TAB: "Tab";
+    readonly ENTER: "Enter";
+    readonly ESCAPE: "Escape";
+    readonly SPACE: " ";
+    readonly LEFT: "ArrowLeft";
+    readonly UP: "ArrowUp";
+    readonly RIGHT: "ArrowRight";
+    readonly DOWN: "ArrowDown";
+    readonly DELETE: "Delete";
+    readonly F2: "F2";
+    readonly PAGE_UP: "PageUp";
+    readonly PAGE_DOWN: "PageDown";
+    readonly PAGE_HOME: "Home";
+    readonly PAGE_END: "End";
+    readonly A: "KeyA";
+    readonly C: "KeyC";
+    readonly D: "KeyD";
+    readonly V: "KeyV";
+    readonly X: "KeyX";
+    readonly Y: "KeyY";
+    readonly Z: "KeyZ";
+};

package/dist/types/src/context/beanStub.d.ts

@@ -0,0 +1,83 @@
+import type { GridOptions } from '../entities/gridOptions';
+import type { EventService } from '../eventService';
+import type { AgEventType } from '../eventTypes';
+import type { AgEvent, AgEventListener, AgEventTypeParams } from '../events';
+import type { GridOptionsService, PropertyChangedListener, PropertyValueChangedListener } from '../gridOptionsService';
+import type { IEventEmitter } from '../interfaces/iEventEmitter';
+import { LocalEventService } from '../localEventService';
+import type { LocaleTextFunc } from '../misc/locale/localeUtils';
+import type { Bean } from './bean';
+import type { BeanCollection, Context } from './context';
+import type { BaseBean } from './genericContext';
+export type BeanStubEvent = 'destroyed';
+export type EventOrDestroyed<TEventType extends string> = TEventType | BeanStubEvent;
+type EventHandlers<TEventKey extends string, TEvent = any> = {
+    [K in TEventKey]?: (event?: TEvent) => void;
+};
+type AgEventHandlers = {
+    [K in AgEventType]?: (event: AgEventTypeParams[K]) => void;
+};
+export declare abstract class BeanStub<TEventType extends string = BeanStubEvent> implements BaseBean<BeanCollection>, Bean, IEventEmitter<EventOrDestroyed<TEventType>> {
+    protected localEventService?: LocalEventService<EventOrDestroyed<TEventType>>;
+    private stubContext;
+    private destroyFunctions;
+    private destroyed;
+    __v_skip: boolean;
+    protected beans: BeanCollection;
+    protected eventSvc: EventService;
+    protected gos: GridOptionsService;
+    preWireBeans(beans: BeanCollection): void;
+    destroy(): void;
+    /** Add a local event listener against this BeanStub */
+    addEventListener<T extends TEventType>(eventType: T, listener: AgEventListener<any, any, any>, async?: boolean): void;
+    /** Remove a local event listener from this BeanStub */
+    removeEventListener<T extends TEventType>(eventType: T, listener: AgEventListener<any, any, any>, async?: boolean): void;
+    dispatchLocalEvent<TEvent extends AgEvent<TEventType>>(event: TEvent): void;
+    addManagedElementListeners<TEvent extends keyof HTMLElementEventMap>(object: Element | Document | ShadowRoot, handlers: EventHandlers<TEvent, HTMLElementEventMap[TEvent]>): (() => null)[];
+    addManagedEventListeners(handlers: AgEventHandlers): (() => null)[];
+    addManagedListeners<TEvent extends string>(object: IEventEmitter<TEvent>, handlers: EventHandlers<TEvent>): (() => null)[];
+    private _setupListeners;
+    private _setupListener;
+    /**
+     * Setup a managed property listener for the given GridOption property.
+     * However, stores the destroy function in the beanStub so that if this bean
+     * is a component the destroy function will be called when the component is destroyed
+     * as opposed to being cleaned up only when the GridOptionsService is destroyed.
+     */
+    private setupGridOptionListener;
+    /**
+     * Setup a managed property listener for the given GridOption property.
+     * @param event GridOption property to listen to changes for.
+     * @param listener Listener to run when property value changes
+     */
+    addManagedPropertyListener<K extends keyof GridOptions>(event: K, listener: PropertyValueChangedListener<K>): () => null;
+    private propertyListenerId;
+    private lastChangeSetIdLookup;
+    /**
+     * Setup managed property listeners for the given set of GridOption properties.
+     * The listener will be run if any of the property changes but will only run once if
+     * multiple of the properties change within the same framework lifecycle event.
+     * Works on the basis that GridOptionsService updates all properties *before* any property change events are fired.
+     * @param events Array of GridOption properties to listen for changes too.
+     * @param listener Shared listener to run if any of the properties change
+     */
+    addManagedPropertyListeners(events: (keyof GridOptions)[], listener: PropertyChangedListener): void;
+    isAlive: () => boolean;
+    getLocaleTextFunc(): LocaleTextFunc;
+    addDestroyFunc(func: () => void): void;
+    /** doesn't throw an error if `bean` is undefined */
+    createOptionalManagedBean<T extends Bean | null | undefined>(bean: T, context?: Context): T | undefined;
+    createManagedBean<T extends Bean | null | undefined>(bean: T, context?: Context): T;
+    createBean<T extends Bean | null | undefined>(bean: T, context?: Context | null, afterPreCreateCallback?: (bean: Bean) => void): T;
+    /**
+     * Destroys a bean and returns undefined to support destruction and clean up in a single line.
+     * this.dateComp = this.context.destroyBean(this.dateComp);
+     */
+    destroyBean<T extends Bean | null | undefined>(bean: T, context?: Context): undefined;
+    /**
+     * Destroys an array of beans and returns an empty array to support destruction and clean up in a single line.
+     * this.dateComps = this.context.destroyBeans(this.dateComps);
+     */
+    protected destroyBeans<T extends Bean | null | undefined>(beans: T[], context?: Context): T[];
+}
+export {};

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

@@ -0,0 +1,251 @@
+import type { AlignedGridsService } from '../alignedGrids/alignedGridsService';
+import type { ApiFunctionService } from '../api/apiFunctionService';
+import type { GridApi } from '../api/gridApi';
+import type { ColumnAutosizeService } from '../columnAutosize/columnAutosizeService';
+import type { ColumnAnimationService } from '../columnMove/columnAnimationService';
+import type { ColumnMoveService } from '../columnMove/columnMoveService';
+import type { ColumnResizeService } from '../columnResize/columnResizeService';
+import type { ColumnDefFactory } from '../columns/columnDefFactory';
+import type { ColumnFlexService } from '../columns/columnFlexService';
+import type { ColumnGroupService } from '../columns/columnGroups/columnGroupService';
+import type { ColumnHoverService } from '../columns/columnHover/columnHoverService';
+import type { ColumnModel } from '../columns/columnModel';
+import type { ColumnNameService } from '../columns/columnNameService';
+import type { ColumnViewportService } from '../columns/columnViewportService';
+import type { DataTypeService } from '../columns/dataTypeService';
+import type { SelectionColService } from '../columns/selectionColService';
+import type { VisibleColsService } from '../columns/visibleColsService';
+import type { AgComponentUtils } from '../components/framework/agComponentUtils';
+import type { FrameworkComponentWrapper } from '../components/framework/frameworkComponentWrapper';
+import type { Registry } from '../components/framework/registry';
+import type { UserComponentFactory } from '../components/framework/userComponentFactory';
+import type { CtrlsService } from '../ctrlsService';
+import type { DragAndDropService } from '../dragAndDrop/dragAndDropService';
+import type { DragService } from '../dragAndDrop/dragService';
+import type { HorizontalResizeService } from '../dragAndDrop/horizontalResizeService';
+import type { RowDragService } from '../dragAndDrop/rowDragService';
+import type { EditService } from '../edit/editService';
+import type { RowEditService } from '../edit/rowEditService';
+import type { GridOptions } from '../entities/gridOptions';
+import type { Environment } from '../environment';
+import type { EventService } from '../eventService';
+import type { AgGlobalEventListener } from '../events';
+import type { ColumnFilterService } from '../filter/columnFilterService';
+import type { FilterManager } from '../filter/filterManager';
+import type { FilterValueService } from '../filter/filterValueService';
+import type { QuickFilterService } from '../filter/quickFilterService';
+import type { FocusService } from '../focusService';
+import type { ScrollVisibleService } from '../gridBodyComp/scrollVisibleService';
+import type { GridDestroyService } from '../gridDestroyService';
+import type { GridOptionsService } from '../gridOptionsService';
+import type { RowNodeBlockLoader } from '../infiniteRowModel/rowNodeBlockLoader';
+import type { IChartService } from '../interfaces/IChartService';
+import type { IRangeService } from '../interfaces/IRangeService';
+import type { IAdvancedFilterService } from '../interfaces/iAdvancedFilterService';
+import type { IAggColumnNameService } from '../interfaces/iAggColumnNameService';
+import type { IAggFuncService } from '../interfaces/iAggFuncService';
+import type { IAutoColService } from '../interfaces/iAutoColService';
+import type { IClientSideNodeManager } from '../interfaces/iClientSideNodeManager';
+import type { IClipboardService } from '../interfaces/iClipboardService';
+import type { IColsService } from '../interfaces/iColsService';
+import type { IContextMenuService } from '../interfaces/iContextMenu';
+import type { ICsvCreator } from '../interfaces/iCsvCreator';
+import type { IExcelCreator } from '../interfaces/iExcelCreator';
+import type { IExpansionService } from '../interfaces/iExpansionService';
+import type { IFooterService } from '../interfaces/iFooterService';
+import type { IFrameworkOverrides } from '../interfaces/iFrameworkOverrides';
+import type { IGroupHideOpenParentsService } from '../interfaces/iGroupHideOpenParentsService';
+import type { IMenuFactory } from '../interfaces/iMenuFactory';
+import type { IPivotColDefService } from '../interfaces/iPivotColDefService';
+import type { IPivotResultColsService } from '../interfaces/iPivotResultColsService';
+import type { IRowChildrenService } from '../interfaces/iRowChildrenService';
+import type { IRowModel } from '../interfaces/iRowModel';
+import type { IRowNodeStage } from '../interfaces/iRowNodeStage';
+import type { ISelectionService } from '../interfaces/iSelectionService';
+import type { IServerSideTransactionManager } from '../interfaces/iServerSideRowModel';
+import type { IShowRowGroupColsService } from '../interfaces/iShowRowGroupColsService';
+import type { ISideBarService } from '../interfaces/iSideBar';
+import type { IStickyRowService } from '../interfaces/iStickyRows';
+import type { IMasterDetailService } from '../interfaces/masterDetail';
+import type { IRenderStatusService } from '../interfaces/renderStatusService';
+import type { AnimationFrameService } from '../misc/animationFrameService';
+import type { ApiEventService } from '../misc/apiEvents/apiEventService';
+import type { LocaleService } from '../misc/locale/localeService';
+import type { MenuService } from '../misc/menu/menuService';
+import type { StateService } from '../misc/state/stateService';
+import type { TouchService } from '../misc/touchService';
+import type { CellNavigationService } from '../navigation/cellNavigationService';
+import type { HeaderNavigationService } from '../navigation/headerNavigationService';
+import type { NavigationService } from '../navigation/navigationService';
+import type { PageBoundsListener } from '../pagination/pageBoundsListener';
+import type { PageBoundsService } from '../pagination/pageBoundsService';
+import type { PaginationAutoPageSizeService } from '../pagination/paginationAutoPageSizeService';
+import type { PaginationService } from '../pagination/paginationService';
+import type { PinnedColumnService } from '../pinnedColumns/pinnedColumnService';
+import type { PinnedRowModel } from '../pinnedRowModel/pinnedRowModel';
+import type { AriaAnnouncementService } from '../rendering/ariaAnnouncementService';
+import type { AutoWidthCalculator } from '../rendering/autoWidthCalculator';
+import type { CellFlashService } from '../rendering/cell/cellFlashService';
+import type { OverlayService } from '../rendering/overlays/overlayService';
+import type { RowAutoHeightService } from '../rendering/row/rowAutoHeightService';
+import type { RowContainerHeightService } from '../rendering/rowContainerHeightService';
+import type { RowRenderer } from '../rendering/rowRenderer';
+import type { RowNodeSorter } from '../sort/rowNodeSorter';
+import type { SortService } from '../sort/sortService';
+import type { CellStyleService } from '../styling/cellStyleService';
+import type { RowStyleService } from '../styling/rowStyleService';
+import type { SyncService } from '../syncService';
+import type { TooltipService } from '../tooltip/tooltipService';
+import type { UndoRedoService } from '../undoRedo/undoRedoService';
+import type { ValidationService } from '../validation/validationService';
+import type { ExpressionService } from '../valueService/expressionService';
+import type { ValueCache } from '../valueService/valueCache';
+import type { ValueService } from '../valueService/valueService';
+import type { PopupService } from '../widgets/popupService';
+import type { GenericContextParams, GenericSingletonBean } from './genericContext';
+import { GenericContext } from './genericContext';
+export interface ContextParams extends GenericContextParams<BeanName, BeanCollection> {
+    gridId: string;
+    destroyCallback?: () => void;
+}
+export interface SingletonBean extends GenericSingletonBean<BeanName, BeanCollection> {
+}
+export type DynamicBeanName = 'detailCellRendererCtrl' | 'dndSourceComp' | 'fillHandle' | 'groupCellRendererCtrl' | 'headerFilterCellCtrl' | 'headerGroupCellCtrl' | 'rangeHandle' | 'tooltipFeature';
+export type UserComponentName = 'agDragAndDropImage' | 'agColumnHeader' | 'agColumnGroupHeader' | 'agSortIndicator' | 'agAnimateShowChangeCellRenderer' | 'agAnimateSlideCellRenderer' | 'agLoadingCellRenderer' | 'agSkeletonCellRenderer' | 'agCheckboxCellRenderer' | 'agLoadingOverlay' | 'agNoRowsOverlay' | 'agTooltipComponent' | 'agReadOnlyFloatingFilter' | 'agTextColumnFilter' | 'agNumberColumnFilter' | 'agDateColumnFilter' | 'agDateInput' | 'agTextColumnFloatingFilter' | 'agNumberColumnFloatingFilter' | 'agDateColumnFloatingFilter' | 'agMultiColumnFilter' | 'agMultiColumnFloatingFilter' | 'agGroupColumnFilter' | 'agGroupColumnFloatingFilter' | 'agSetColumnFilter' | 'agSetColumnFloatingFilter' | 'agCellEditor' | 'agSelectCellEditor' | 'agTextCellEditor' | 'agNumberCellEditor' | 'agDateCellEditor' | 'agDateStringCellEditor' | 'agCheckboxCellEditor' | 'agLargeTextCellEditor' | 'agRichSelect' | 'agRichSelectCellEditor' | 'agMenuItem' | 'agColumnsToolPanel' | 'agFiltersToolPanel' | 'agGroupRowRenderer' | 'agGroupCellRenderer' | 'agDetailCellRenderer' | 'agSparklineCellRenderer' | 'agAggregationComponent' | 'agSelectedRowCountComponent' | 'agTotalRowCountComponent' | 'agFilteredRowCountComponent' | 'agTotalAndFilteredRowCountComponent';
+export type ClassImp = new (...args: []) => object;
+export type ComponentMeta = ClassImp | {
+    classImp: ClassImp;
+    /** Default params for provided components */
+    params?: any;
+};
+export interface CoreBeanCollection {
+    context: Context;
+    pageBoundsListener: PageBoundsListener;
+    gos: GridOptionsService;
+    environment: Environment;
+    rowRenderer: RowRenderer;
+    valueSvc: ValueService;
+    eventSvc: EventService;
+    colModel: ColumnModel;
+    colViewport: ColumnViewportService;
+    colNames: ColumnNameService;
+    visibleCols: VisibleColsService;
+    colMoves?: ColumnMoveService;
+    colFlex?: ColumnFlexService;
+    colResize?: ColumnResizeService;
+    headerNavigation?: HeaderNavigationService;
+    navigation?: NavigationService;
+    colAnimation?: ColumnAnimationService;
+    focusSvc: FocusService;
+    popupSvc?: PopupService;
+    cellStyles?: CellStyleService;
+    colHover?: ColumnHoverService;
+    userCompFactory: UserComponentFactory;
+    registry: Registry;
+    animationFrameSvc?: AnimationFrameService;
+    dragSvc?: DragService;
+    dragAndDrop?: DragAndDropService;
+    sortSvc?: SortService;
+    colFilter?: ColumnFilterService;
+    filterManager?: FilterManager;
+    rowContainerHeight: RowContainerHeightService;
+    frameworkOverrides: IFrameworkOverrides;
+    selectionSvc?: ISelectionService;
+    rowStyleSvc?: RowStyleService;
+    rowModel: IRowModel;
+    ctrlsSvc: CtrlsService;
+    valueCache?: ValueCache;
+    localeSvc?: LocaleService;
+    syncSvc: SyncService;
+    ariaAnnounce: AriaAnnouncementService;
+    rangeSvc?: IRangeService;
+    validation?: ValidationService;
+    gridApi: GridApi;
+    gridOptions: GridOptions;
+    eGridDiv: HTMLElement;
+    pivotResultCols?: IPivotResultColsService;
+    autoColSvc?: IAutoColService;
+    selectionColSvc?: SelectionColService;
+    colDefFactory?: ColumnDefFactory;
+    colAutosize?: ColumnAutosizeService;
+    rowGroupColsSvc?: IColsService;
+    valueColsSvc?: IColsService;
+    pivotColsSvc?: IColsService;
+    quickFilter?: QuickFilterService;
+    showRowGroupCols?: IShowRowGroupColsService;
+    dataTypeSvc?: DataTypeService;
+    globalListener: AgGlobalEventListener;
+    globalSyncListener: AgGlobalEventListener;
+    stateSvc?: StateService;
+    overlays?: OverlayService;
+    pinnedRowModel?: PinnedRowModel;
+    menuSvc?: MenuService;
+    apiEventSvc?: ApiEventService;
+    undoRedo?: UndoRedoService;
+    rowNodeBlockLoader?: RowNodeBlockLoader;
+    csvCreator?: ICsvCreator;
+    excelCreator?: IExcelCreator;
+    clipboardSvc?: IClipboardService;
+    cellNavigation?: CellNavigationService;
+    scrollVisibleSvc: ScrollVisibleService;
+    pinnedCols?: PinnedColumnService;
+    expressionSvc?: ExpressionService;
+    autoWidthCalc?: AutoWidthCalculator;
+    agCompUtils?: AgComponentUtils;
+    frameworkCompWrapper: FrameworkComponentWrapper;
+    horizontalResizeSvc?: HorizontalResizeService;
+    filterMenuFactory?: IMenuFactory;
+    enterpriseMenuFactory?: IMenuFactory;
+    contextMenuSvc?: IContextMenuService;
+    editSvc?: EditService;
+    rowEditSvc?: RowEditService;
+    alignedGridsSvc?: AlignedGridsService;
+    paginationAutoPageSizeSvc?: PaginationAutoPageSizeService;
+    pagination?: PaginationService;
+    pageBounds: PageBoundsService;
+    apiFunctionSvc: ApiFunctionService;
+    gridDestroySvc: GridDestroyService;
+    expansionSvc?: IExpansionService;
+    sideBar?: ISideBarService;
+    ssrmTxnManager?: IServerSideTransactionManager;
+    aggFuncSvc?: IAggFuncService;
+    advancedFilter: IAdvancedFilterService;
+    filterStage?: IRowNodeStage;
+    sortStage?: IRowNodeStage;
+    flattenStage?: IRowNodeStage;
+    groupStage?: IRowNodeStage;
+    aggStage?: IRowNodeStage;
+    pivotStage?: IRowNodeStage;
+    filterAggStage?: IRowNodeStage;
+    rowNodeSorter?: RowNodeSorter;
+    pivotColDefSvc?: IPivotColDefService;
+    chartSvc?: IChartService;
+    aggColNameSvc?: IAggColumnNameService;
+    renderStatus?: IRenderStatusService;
+    rowDragSvc?: RowDragService;
+    stickyRowSvc?: IStickyRowService;
+    groupHideOpenParentsSvc?: IGroupHideOpenParentsService;
+    filterValueSvc?: FilterValueService;
+    csrmNodeSvc?: IClientSideNodeManager;
+    csrmPathTreeNodeSvc?: IClientSideNodeManager;
+    csrmChildrenTreeNodeSvc?: IClientSideNodeManager;
+    cellFlashSvc?: CellFlashService;
+    masterDetailSvc?: IMasterDetailService;
+    tooltipSvc?: TooltipService;
+    colGroupSvc?: ColumnGroupService;
+    rowAutoHeight?: RowAutoHeightService;
+    rowChildrenSvc?: IRowChildrenService;
+    footerSvc?: IFooterService;
+    touchSvc?: TouchService;
+}
+export type BeanCollection = CoreBeanCollection & {
+    [key in Exclude<BeanName, keyof CoreBeanCollection>]?: unknown;
+};
+export declare class Context extends GenericContext<BeanName, BeanCollection> {
+    private gridId;
+    private destroyCallback?;
+    protected init(params: ContextParams): void;
+    destroy(): void;
+    getGridId(): string;
+}
+export type BeanName = 'advFilterExpSvc' | 'advancedFilter' | 'advSettingsMenuFactory' | 'aggFuncSvc' | 'agCompUtils' | 'aggColNameSvc' | 'aggStage' | 'alignedGridsSvc' | 'animationFrameSvc' | 'apiFunctionSvc' | 'ariaAnnounce' | 'apiEventSvc' | 'autoColSvc' | 'autoWidthCalc' | 'beans' | 'cellFlashSvc' | 'cellNavigation' | 'cellStyles' | 'changeDetectionSvc' | 'chartColSvc' | 'chartCrossFilterSvc' | 'chartMenuItemMapper' | 'chartMenuListFactory' | 'chartMenuSvc' | 'chartTranslation' | 'chartSvc' | 'agChartsExports' | 'clipboardSvc' | 'colAnimation' | 'colAutosize' | 'colChooserFactory' | 'colDefFactory' | 'colFilter' | 'colFlex' | 'colGroupSvc' | 'colHover' | 'colMenuFactory' | 'colModel' | 'colMoves' | 'colNames' | 'colResize' | 'colToolPanelFactory' | 'colViewport' | 'pivotResultCols' | 'context' | 'contextMenuSvc' | 'selectionColSvc' | 'ctrlsSvc' | 'csvCreator' | 'dataTypeSvc' | 'visibleCols' | 'dragAndDrop' | 'dragSvc' | 'editSvc' | 'excelCreator' | 'enterpriseMenuFactory' | 'environment' | 'eventSvc' | 'eGridDiv' | 'enterpriseChartProxyFactory' | 'expansionSvc' | 'expressionSvc' | 'filterAggStage' | 'filterManager' | 'filterMenuFactory' | 'filterStage' | 'filterValueSvc' | 'flashCellSvc' | 'flattenStage' | 'focusSvc' | 'footerSvc' | 'funcColsSvc' | 'pivotColsSvc' | 'rowGroupColsSvc' | 'valueColsSvc' | 'frameworkCompWrapper' | 'frameworkOverrides' | 'globalListener' | 'globalSyncListener' | 'gridApi' | 'gridDestroySvc' | 'gridOptions' | 'gos' | 'gridOptionsWrapper' | 'gridSerializer' | 'groupHideOpenParentsSvc' | 'groupStage' | 'headerNavigation' | 'horizontalResizeSvc' | 'lazyBlockLoadingSvc' | 'licenseManager' | 'localeSvc' | 'masterDetailSvc' | 'menuItemMapper' | 'menuSvc' | 'menuUtils' | 'navigation' | 'overlays' | 'paginationAutoPageSizeSvc' | 'pagination' | 'pinnedRowModel' | 'pinnedCols' | 'pivotColDefSvc' | 'pivotStage' | 'popupSvc' | 'quickFilter' | 'rangeSvc' | 'pageBoundsListener' | 'pageBounds' | 'registry' | 'renderStatus' | 'rowAutoHeight' | 'rowChildrenSvc' | 'rowContainerHeight' | 'rowDragSvc' | 'rowEditSvc' | 'rowModel' | 'rowNodeBlockLoader' | 'rowNodeSorter' | 'rowRenderer' | 'rowStyleSvc' | 'scrollVisibleSvc' | 'selectionController' | 'selectionSvc' | 'showRowGroupCols' | 'sideBar' | 'sortSvc' | 'sortStage' | 'ssrmBlockUtils' | 'ssrmExpandListener' | 'ssrmFilterListener' | 'ssrmListenerUtils' | 'ssrmNodeManager' | 'ssrmSortSvc' | 'ssrmStoreFactory' | 'ssrmStoreUtils' | 'ssrmTxnManager' | 'stateSvc' | 'statusBarSvc' | 'stickyRowSvc' | 'syncSvc' | 'tooltipSvc' | 'touchSvc' | 'undoRedo' | 'userCompFactory' | 'valueCache' | 'valueSvc' | 'validationLogger' | 'validation' | 'csrmNodeSvc' | 'csrmPathTreeNodeSvc' | 'csrmChildrenTreeNodeSvc';

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

@@ -0,0 +1,21 @@
+import type { NamedBean } from '../context/bean';
+import type { BeanCollection } from '../context/context';
+import { BaseCreator } from '../export/baseCreator';
+import type { CsvCustomContent, CsvExportParams } from '../interfaces/exportParams';
+import type { ICsvCreator } from '../interfaces/iCsvCreator';
+import { CsvSerializingSession } from './csvSerializingSession';
+export declare class CsvCreator extends BaseCreator<CsvCustomContent, CsvSerializingSession, CsvExportParams> implements NamedBean, ICsvCreator {
+    beanName: "csvCreator";
+    private colModel;
+    private colNames;
+    private rowGroupColsSvc?;
+    private valueSvc;
+    wireBeans(beans: BeanCollection): void;
+    protected getMergedParams(params?: CsvExportParams): CsvExportParams;
+    protected export(userParams?: CsvExportParams): void;
+    exportDataAsCsv(params?: CsvExportParams): void;
+    getDataAsCsv(params?: CsvExportParams, skipDefaultParams?: boolean): string;
+    getDefaultFileExtension(): string;
+    createSerializingSession(params?: CsvExportParams): CsvSerializingSession;
+    isExportSuppressed(): boolean;
+}

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

@@ -0,0 +1,4 @@
+import type { BeanCollection } from '../context/context';
+import type { CsvExportParams } from '../interfaces/exportParams';
+export declare function getDataAsCsv(beans: BeanCollection, params?: CsvExportParams): string | undefined;
+export declare function exportDataAsCsv(beans: BeanCollection, params?: CsvExportParams): void;

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

@@ -0,0 +1,6 @@
+import type { _CsvExportGridApi } from '../api/gridApi';
+import type { _ModuleWithApi } from '../interfaces/iModule';
+/**
+ * @feature Import & Export -> CSV Export
+ */
+export declare const CsvExportModule: _ModuleWithApi<_CsvExportGridApi>;