ag-grid-community 32.3.2 → 33.0.0

package/dist/types/src/validation/resolvableModuleNames.d.ts

@@ -0,0 +1,8 @@
+import type { CommunityModuleName, EnterpriseModuleName, ResolvableModuleName, ValidationModuleName } from '../interfaces/iModule';
+import type { RowModelType } from '../interfaces/iRowModel';
+/**
+ * Some of these modules are (for now) included by default in core. For these, we just return AllCommunityModule.
+ */
+export declare const RESOLVABLE_MODULE_NAMES: Record<ResolvableModuleName, readonly (CommunityModuleName | EnterpriseModuleName)[]>;
+export declare const MODULES_FOR_ROW_MODELS: Partial<Record<CommunityModuleName | EnterpriseModuleName, RowModelType>>;
+export declare function resolveModuleNames(moduleName: ValidationModuleName | ValidationModuleName[], rowModelType: RowModelType): (CommunityModuleName | EnterpriseModuleName)[];

package/dist/types/src/validation/rules/colDefValidations.d.ts

@@ -0,0 +1,3 @@
+import type { ColDef, ColGroupDef } from '../../entities/colDef';
+import type { OptionsValidator } from '../validationTypes';
+export declare const COL_DEF_VALIDATORS: () => OptionsValidator<ColDef | ColGroupDef>;

package/dist/types/src/validation/rules/gridOptionsValidations.d.ts

@@ -0,0 +1,3 @@
+import type { GridOptions } from '../../entities/gridOptions';
+import type { OptionsValidator } from '../validationTypes';
+export declare const GRID_OPTIONS_VALIDATORS: () => OptionsValidator<GridOptions>;

package/dist/types/src/validation/rules/iconValidations.d.ts

@@ -0,0 +1,5 @@
+import type { ValidationModuleName } from '../../interfaces/iModule';
+import type { IconName, IconValue } from '../../utils/icon';
+export declare const ICON_VALUES: Record<IconValue, 1>;
+export declare const ICON_MODULES: Record<IconName, ValidationModuleName | ValidationModuleName[]>;
+export declare const DEPRECATED_ICONS_V33: Set<IconName>;

package/dist/types/src/validation/rules/menuItemValidations.d.ts

@@ -0,0 +1,3 @@
+import type { ValidationModuleName } from '../../interfaces/iModule';
+import type { DefaultMenuItem } from '../../interfaces/menuItem';
+export declare const MENU_ITEM_MODULES: Record<DefaultMenuItem, ValidationModuleName | ValidationModuleName[]>;

package/dist/types/src/validation/rules/userCompValidations.d.ts

@@ -0,0 +1,3 @@
+import type { UserComponentName } from '../../context/context';
+import type { ValidationModuleName } from '../../interfaces/iModule';
+export declare const USER_COMP_MODULES: Record<UserComponentName, ValidationModuleName>;

package/dist/types/src/validation/validationModule.d.ts

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

package/dist/types/src/validation/validationService.d.ts

@@ -0,0 +1,36 @@
+import type { ApiFunction, ApiFunctionName } from '../api/iApiFunction';
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+import type { BeanCollection, UserComponentName } from '../context/context';
+import type { ColDef, ColGroupDef } from '../entities/colDef';
+import type { GridOptions } from '../entities/gridOptions';
+import type { PropertyChangedSource } from '../gridOptionsService';
+import type { RowNodeEventType } from '../interfaces/iRowNode';
+import type { IconName } from '../utils/icon';
+import type { ErrorId, GetErrorParams } from './errorMessages/errorText';
+export declare class ValidationService extends BeanStub implements NamedBean {
+    beanName: "validation";
+    private gridOptions;
+    wireBeans(beans: BeanCollection): void;
+    postConstruct(): void;
+    warnOnInitialPropertyUpdate(source: PropertyChangedSource, key: string): void;
+    processGridOptions(options: GridOptions): void;
+    validateApiFunction<TFunctionName extends ApiFunctionName>(functionName: TFunctionName, apiFunction: ApiFunction<TFunctionName>): ApiFunction<TFunctionName>;
+    missingUserComponent(propertyName: string, componentName: string, agGridDefaults: {
+        [key in UserComponentName]?: any;
+    }, jsComps: {
+        [key: string]: any;
+    }): void;
+    checkRowEvents(eventType: RowNodeEventType): void;
+    validateIcon(iconName: IconName): void;
+    validateMenuItem(key: string): void;
+    isProvidedUserComp(compName: string): boolean;
+    validateColDef(colDef: ColDef | ColGroupDef, colId: string, skipInferenceCheck?: boolean): void;
+    private processOptions;
+    private checkForRequiredDependencies;
+    private checkProperties;
+    getConsoleMessage<TId extends ErrorId>(id: TId, args: GetErrorParams<TId>): any[];
+}
+export declare function _fuzzyCheckStrings(inputValues: string[], validValues: string[], allSuggestions: string[]): {
+    [p: string]: string[];
+};

package/dist/types/src/validation/validationTypes.d.ts

@@ -0,0 +1,39 @@
+import type { BeanCollection } from '../context/context';
+import type { GridOptions } from '../entities/gridOptions';
+import type { ValidationModuleName } from '../interfaces/iModule';
+import type { RowModelType } from '../interfaces/iRowModel';
+export interface OptionsValidator<T extends object> {
+    objectName: string;
+    allProperties?: string[];
+    propertyExceptions?: string[];
+    docsUrl?: `${string}/`;
+    deprecations: Deprecations<T>;
+    validations: Validations<T>;
+}
+export type Deprecations<T extends object> = Partial<{
+    [key in keyof T]: {
+        version: string;
+        message?: string;
+    };
+}>;
+type TypeOfArray<T> = NonNullable<T extends Array<infer U> ? U : T>;
+export type Validations<T extends object> = Partial<{
+    [key in keyof T]: (TypeOfArray<T[key]> extends object ? () => OptionsValidator<TypeOfArray<T[key]>> : never) | ((options: T, gridOptions: GridOptions, beans: BeanCollection) => OptionsValidation<T> | null) | OptionsValidation<T> | undefined;
+}>;
+export type ValidationsRequired<T extends object> = Required<Validations<T>>;
+export interface OptionsValidation<T extends object> {
+    module?: ValidationModuleName | ValidationModuleName[];
+    supportedRowModels?: RowModelType[];
+    dependencies?: RequiredOptions<T>;
+    validate?: (options: T, gridOptions: GridOptions, beans: BeanCollection) => string | null;
+    /** Currently only supports boolean or number */
+    expectedType?: 'boolean' | 'number';
+}
+export type DependentValues<T extends object, K extends keyof T> = {
+    required: T[K][];
+    reason?: string;
+};
+export type RequiredOptions<T extends object> = {
+    [K in keyof T]: DependentValues<T, K>;
+};
+export {};

package/dist/types/src/valueService/cellApi.d.ts

@@ -0,0 +1,4 @@
+import type { GetCellValueParams } from '../api/gridApi';
+import type { BeanCollection } from '../context/context';
+export declare function expireValueCache(beans: BeanCollection): void;
+export declare function getCellValue<TValue = any>(beans: BeanCollection, params: GetCellValueParams<TValue>): any;

package/dist/types/src/valueService/changeDetectionService.d.ts

@@ -0,0 +1,8 @@
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+export declare class ChangeDetectionService extends BeanStub implements NamedBean {
+    beanName: "changeDetectionSvc";
+    private clientSideRowModel;
+    postConstruct(): void;
+    private onCellValueChanged;
+}

package/dist/types/src/valueService/expressionService.d.ts

@@ -0,0 +1,10 @@
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+export declare class ExpressionService extends BeanStub implements NamedBean {
+    beanName: "expressionSvc";
+    private cache;
+    evaluate(expression: string | undefined, params: any): any;
+    private evaluateExpression;
+    private createExpressionFunction;
+    private createFunctionBody;
+}

package/dist/types/src/valueService/valueModule.d.ts

@@ -0,0 +1,20 @@
+import type { _ValueApi, _ValueCacheApi } from '../api/gridApi';
+import type { _ModuleWithApi, _ModuleWithoutApi } from '../interfaces/iModule';
+/**
+ * @feature Performance -> Value Cache
+ * @gridOption valueCache
+ */
+export declare const ValueCacheModule: _ModuleWithApi<_ValueCacheApi>;
+/**
+ * @feature Cells -> Expression
+ */
+export declare const ExpressionModule: _ModuleWithoutApi;
+/**
+ * @feature Change Detection
+ * @gridOption suppressChangeDetection
+ */
+export declare const ChangeDetectionModule: _ModuleWithoutApi;
+/**
+ * @feature Cells -> API
+ */
+export declare const CellApiModule: _ModuleWithApi<_ValueApi<any>>;

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

@@ -0,0 +1,45 @@
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+import type { BeanCollection } from '../context/context';
+import type { AgColumn } from '../entities/agColumn';
+import type { IRowNode } from '../interfaces/iRowNode';
+export declare class ValueService extends BeanStub implements NamedBean {
+    beanName: "valueSvc";
+    private expressionSvc?;
+    private colModel;
+    private valueCache?;
+    private dataTypeSvc?;
+    wireBeans(beans: BeanCollection): void;
+    private cellExpressions;
+    private isTreeData;
+    private initialised;
+    private isSsrm;
+    private executeValueGetter;
+    postConstruct(): void;
+    private init;
+    /**
+     * Use this function to get a displayable cell value.
+     * This hides values in expanded group rows which are instead displayed by the footer row.
+     */
+    getValueForDisplay(column: AgColumn, node: IRowNode): any;
+    getValue(column: AgColumn, rowNode?: IRowNode | null, ignoreAggData?: boolean): any;
+    parseValue(column: AgColumn, rowNode: IRowNode | null, newValue: any, oldValue: any): any;
+    getDeleteValue(column: AgColumn, rowNode: IRowNode): any;
+    formatValue(column: AgColumn, node: IRowNode | null, value: any, suppliedFormatter?: (value: any) => string, useFormatterFromColumn?: boolean): string | null;
+    private getOpenedGroup;
+    /**
+     * Sets the value of a GridCell
+     * @param rowNode The `RowNode` to be updated
+     * @param colKey The `Column` to be updated
+     * @param newValue The new value to be set
+     * @param eventSource The event source
+     * @returns `True` if the value has been updated, otherwise`False`.
+     */
+    setValue(rowNode: IRowNode, colKey: string | AgColumn, newValue: any, eventSource?: string): boolean;
+    private callColumnCellValueChangedHandler;
+    private setValueUsingField;
+    private executeValueGetterWithValueCache;
+    private executeValueGetterWithoutValueCache;
+    getValueCallback(node: IRowNode, field: string | AgColumn): any;
+    getKeyForNode(col: AgColumn, rowNode: IRowNode): any;
+}

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

@@ -0,0 +1,16 @@
+import type { FrameworkOverridesIncomingSource, IFrameworkOverrides } from './interfaces/iFrameworkOverrides';
+import { AgPromise } from './utils/promise';
+/** The base frameworks, eg React & Angular, override this bean with implementations specific to their requirement. */
+export declare class VanillaFrameworkOverrides implements IFrameworkOverrides {
+    private frameworkName;
+    renderingEngine: 'vanilla' | 'react';
+    private baseDocLink;
+    constructor(frameworkName?: 'javascript' | 'angular' | 'react' | 'vue');
+    setInterval(action: any, timeout?: any): AgPromise<number>;
+    addEventListener(element: HTMLElement, type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    wrapIncoming: <T>(callback: () => T, source?: FrameworkOverridesIncomingSource) => T;
+    wrapOutgoing: <T>(callback: () => T) => T;
+    frameworkComponent(_: string): any;
+    isFrameworkComponent(_: any): boolean;
+    getDocLink(path?: string): string;
+}

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

@@ -0,0 +1 @@
+export declare const VERSION = "33.0.0";

package/dist/types/src/widgets/agAbstractLabel.css-GENERATED.d.ts

@@ -0,0 +1 @@
+export declare const agAbstractLabelCSS = ".ag-label{white-space:nowrap}:where(.ag-ltr) .ag-label{margin-right:var(--ag-spacing)}:where(.ag-rtl) .ag-label{margin-left:var(--ag-spacing)}:where(.ag-label-align-right) .ag-label{order:1}:where(.ag-ltr) :where(.ag-label-align-right) .ag-label{margin-left:var(--ag-spacing)}:where(.ag-rtl) :where(.ag-label-align-right) .ag-label{margin-right:var(--ag-spacing)}.ag-label-align-right>*{flex:none}.ag-label-align-top{align-items:flex-start;flex-direction:column;>*{align-self:stretch}}.ag-label-ellipsis{flex:1;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}:where(.ag-label-align-top) .ag-label{margin-bottom:calc(var(--ag-spacing)*.5)}";

package/dist/types/src/widgets/agPickerField.css-GENERATED.d.ts

@@ -0,0 +1 @@
+export declare const agPickerFieldCSS = ".ag-picker-field-display{flex:1 1 auto}.ag-picker-field{align-items:center;display:flex}.ag-picker-field-icon{border:0;cursor:pointer;display:flex;margin:0;padding:0}.ag-picker-field-wrapper{background-color:var(--ag-background-color);border:var(--ag-input-border);border-radius:5px;min-height:max(var(--ag-list-item-height),calc(var(--ag-spacing)*4));overflow:hidden;&:disabled{opacity:.5}&.ag-picker-has-focus,&:focus-within{border:var(--ag-input-focus-border);box-shadow:var(--ag-focus-shadow)}}.ag-picker-field-button{background-color:var(--ag-background-color)}";

package/dist/types/src/widgets/agPickerField.d.ts

@@ -0,0 +1,45 @@
+import type { AgPickerFieldParams } from '../interfaces/agFieldParams';
+import type { AgAbstractFieldEvent } from './agAbstractField';
+import { AgAbstractField } from './agAbstractField';
+import type { Component } from './component';
+export type AgPickerFieldEvent = AgAbstractFieldEvent;
+export declare abstract class AgPickerField<TValue, TConfig extends AgPickerFieldParams = AgPickerFieldParams, TEventType extends string = AgPickerFieldEvent, TComponent extends Component<TEventType | AgPickerFieldEvent> = Component<TEventType | AgPickerFieldEvent>> extends AgAbstractField<TValue, TConfig, TEventType | AgPickerFieldEvent> {
+    protected abstract createPickerComponent(): TComponent;
+    protected pickerComponent: TComponent | undefined;
+    protected isPickerDisplayed: boolean;
+    protected maxPickerHeight: string | undefined;
+    protected variableWidth: boolean;
+    protected minPickerWidth: string | undefined;
+    protected maxPickerWidth: string | undefined;
+    protected value: TValue;
+    private skipClick;
+    private pickerGap;
+    private hideCurrentPicker;
+    private destroyMouseWheelFunc;
+    private ariaRole?;
+    protected readonly eLabel: HTMLElement;
+    protected readonly eWrapper: HTMLElement;
+    protected readonly eDisplayField: HTMLElement;
+    private readonly eIcon;
+    constructor(config?: TConfig);
+    postConstruct(): void;
+    protected setupAria(): void;
+    private onLabelOrWrapperMouseDown;
+    protected onKeyDown(e: KeyboardEvent): void;
+    showPicker(): void;
+    protected renderAndPositionPicker(): () => void;
+    protected alignPickerToComponent(): void;
+    protected beforeHidePicker(): void;
+    protected toggleExpandedStyles(expanded: boolean): void;
+    private onPickerFocusIn;
+    private onPickerFocusOut;
+    private togglePickerHasFocus;
+    hidePicker(): void;
+    setInputWidth(width: number | 'flex'): this;
+    getFocusableElement(): HTMLElement;
+    setPickerGap(gap: number): this;
+    setPickerMinWidth(width?: number | string): this;
+    setPickerMaxWidth(width?: number | string): this;
+    setPickerMaxHeight(height?: number | string): this;
+    destroy(): void;
+}

package/dist/types/src/widgets/agSelect.css-GENERATED.d.ts

@@ -0,0 +1 @@
+export declare const agSelectCSS = ".ag-select{align-items:center;display:flex;&.ag-disabled{opacity:.5}}:where(.ag-select){.ag-picker-field-wrapper{cursor:default}&.ag-disabled .ag-picker-field-wrapper:focus{box-shadow:none}&:not(.ag-cell-editor,.ag-label-align-top){min-height:var(--ag-list-item-height)}.ag-picker-field-display{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.ag-picker-field-icon{align-items:center;display:flex}}:where(.ag-ltr) :where(.ag-select){.ag-picker-field-wrapper{padding-left:calc(var(--ag-cell-horizontal-padding)/2);padding-right:var(--ag-spacing)}}:where(.ag-rtl) :where(.ag-select){.ag-picker-field-wrapper{padding-left:var(--ag-spacing);padding-right:calc(var(--ag-cell-horizontal-padding)/2)}}";

package/dist/types/src/widgets/agSelect.d.ts

@@ -0,0 +1,30 @@
+import type { AgPickerFieldParams } from '../interfaces/agFieldParams';
+import type { ListOption } from './agList';
+import { AgList } from './agList';
+import { AgPickerField } from './agPickerField';
+import type { ComponentSelector } from './component';
+export interface AgSelectParams<TValue = string> extends Omit<AgPickerFieldParams, 'pickerType' | 'pickerAriaLabelKey' | 'pickerAriaLabelValue'> {
+    options?: ListOption<TValue>[];
+    pickerType?: string;
+    pickerAriaLabelKey?: string;
+    pickerAriaLabelValue?: string;
+    placeholder?: string;
+}
+export type AgSelectEvent = 'selectedItem';
+export declare class AgSelect<TValue = string | null> extends AgPickerField<TValue, AgSelectParams<TValue> & AgPickerFieldParams, AgSelectEvent, AgList<AgSelectEvent, TValue>> {
+    protected listComponent: AgList<AgSelectEvent, TValue> | undefined;
+    private tooltipFeature?;
+    constructor(config?: AgSelectParams<TValue>);
+    postConstruct(): void;
+    private onWrapperFocusOut;
+    private createListComponent;
+    protected createPickerComponent(): AgList<"selectedItem", TValue>;
+    protected onKeyDown(e: KeyboardEvent): void;
+    showPicker(): void;
+    addOptions(options: ListOption<TValue>[]): this;
+    addOption(option: ListOption<TValue>): this;
+    clearOptions(): this;
+    setValue(value?: TValue, silent?: boolean, fromPicker?: boolean): this;
+    destroy(): void;
+}
+export declare const AgSelectSelector: ComponentSelector;

package/dist/types/src/widgets/agToggleButton.css-GENERATED.d.ts

@@ -0,0 +1 @@
+export declare const agToggleButtonCSS = ".ag-toggle-button{flex:none;min-width:unset;width:unset}.ag-toggle-button-input-wrapper{background-color:var(--ag-toggle-button-off-background-color);border-radius:calc(var(--ag-toggle-button-height)*.5);flex:none;height:var(--ag-toggle-button-height);max-width:var(--ag-toggle-button-width);min-width:var(--ag-toggle-button-width);position:relative;transition:background-color .1s;:where(.ag-toggle-button-input){-webkit-appearance:none;-moz-appearance:none;appearance:none;cursor:pointer;display:block;height:var(--ag-toggle-button-height);margin:0;max-width:var(--ag-toggle-button-width);min-width:var(--ag-toggle-button-width);opacity:0}&:before{background-color:var(--ag-toggle-button-switch-background-color);border-radius:100%;content:\"\";display:block;height:calc(var(--ag-toggle-button-height) - var(--ag-toggle-button-switch-inset)*2);left:var(--ag-toggle-button-switch-inset);pointer-events:none;position:absolute;top:var(--ag-toggle-button-switch-inset);transition:left .1s;width:calc(var(--ag-toggle-button-height) - var(--ag-toggle-button-switch-inset)*2)}&.ag-checked{background-color:var(--ag-toggle-button-on-background-color);&:before{left:calc(100% - var(--ag-toggle-button-height) + var(--ag-toggle-button-switch-inset))}}&:focus-within{box-shadow:var(--ag-focus-shadow)}&.ag-disabled{opacity:.5}}";

package/dist/types/src/widgets/component.d.ts

@@ -0,0 +1,77 @@
+import type { BeanStubEvent } from '../context/beanStub';
+import { BeanStub } from '../context/beanStub';
+import type { BeanCollection } from '../context/context';
+import type { BaseBean, ComponentBean } from '../context/genericContext';
+import type { AgEvent } from '../events';
+/** The RefPlaceholder is used to control when data-ref attribute should be applied to the component
+ * There are hanging data-refs in the DOM that are not being used internally by the component which we don't want to apply to the component.
+ * There is also the case where data-refs are solely used for passing parameters to the component and should not be applied to the component.
+ * It also enables validation to catch typo errors in the data-ref attribute vs component name.
+ * The value is `null` so that it can be identified in the component and distinguished from just missing with undefined.
+ * The `null` value also allows for existing falsy checks to work as expected when code can be run before the template is setup.
+ */
+export declare const RefPlaceholder: any;
+export type ComponentEvent = 'displayChanged' | BeanStubEvent;
+export interface VisibleChangedEvent extends AgEvent<'displayChanged'> {
+    visible: boolean;
+}
+export type ComponentSelector = {
+    component: {
+        new (params?: any): Component<any>;
+    };
+    selector: AgComponentSelector;
+};
+export declare class Component<TLocalEvent extends string = ComponentEvent> extends BeanStub<TLocalEvent | ComponentEvent> implements ComponentBean, BaseBean<BeanCollection> {
+    private eGui;
+    private componentSelectors;
+    private suppressDataRefValidation;
+    private displayed;
+    private visible;
+    private css;
+    protected parentComponent: Component | undefined;
+    private compId;
+    private cssClassManager;
+    constructor(template?: string, componentSelectors?: ComponentSelector[]);
+    preConstruct(): void;
+    private wireTemplate;
+    getCompId(): number;
+    private getDataRefAttribute;
+    private applyElementsToComponent;
+    private createChildComponentsFromTags;
+    private createComponentFromElement;
+    private copyAttributesFromNode;
+    private swapComponentForNode;
+    protected activateTabIndex(elements?: Element[]): void;
+    setTemplate(template: string | null | undefined, componentSelectors?: ComponentSelector[], paramsMap?: {
+        [key: string]: any;
+    }): void;
+    setTemplateFromElement(element: HTMLElement, components?: ComponentSelector[], paramsMap?: {
+        [key: string]: any;
+    }, suppressDataRefValidation?: boolean): void;
+    getGui(): HTMLElement;
+    getFocusableElement(): HTMLElement;
+    getAriaElement(): Element;
+    setParentComponent(component: Component<any>): void;
+    getParentComponent(): Component | undefined;
+    protected setGui(eGui: HTMLElement): void;
+    protected queryForHtmlElement(cssSelector: string): HTMLElement;
+    private getContainerAndElement;
+    prependChild(newChild: HTMLElement | Component<any>, container?: HTMLElement): void;
+    appendChild(newChild: HTMLElement | Component<any>, container?: HTMLElement): void;
+    isDisplayed(): boolean;
+    setVisible(visible: boolean, options?: {
+        skipAriaHidden?: boolean;
+    }): void;
+    setDisplayed(displayed: boolean, options?: {
+        skipAriaHidden?: boolean;
+    }): void;
+    destroy(): void;
+    addGuiEventListener(event: string, listener: (event: any) => void, options?: AddEventListenerOptions): void;
+    addCssClass(className: string): void;
+    removeCssClass(className: string): void;
+    containsCssClass(className: string): boolean;
+    addOrRemoveCssClass(className: string, addOrRemove: boolean): void;
+    protected registerCSS(css: string): void;
+}
+/** All the AG Grid components that are used within internal templates via <ag-autocomplete> syntax */
+export type AgComponentSelector = 'AG-AUTOCOMPLETE' | 'AG-CHECKBOX' | 'AG-COLOR-INPUT' | 'AG-COLOR-PICKER' | 'AG-FAKE-HORIZONTAL-SCROLL' | 'AG-FAKE-VERTICAL-SCROLL' | 'AG-FILTERS-TOOL-PANEL-HEADER' | 'AG-FILTERS-TOOL-PANEL-LIST' | 'AG-GRID-BODY' | 'AG-GRID-HEADER-DROP-ZONES' | 'AG-GROUP-COMPONENT' | 'AG-HEADER-ROOT' | 'AG-INPUT-DATE-FIELD' | 'AG-INPUT-NUMBER-FIELD' | 'AG-INPUT-RANGE' | 'AG-INPUT-TEXT-AREA' | 'AG-INPUT-TEXT-FIELD' | 'AG-NAME-VALUE' | 'AG-OVERLAY-WRAPPER' | 'AG-PAGE-SIZE-SELECTOR' | 'AG-PAGINATION' | 'AG-PRIMARY-COLS-HEADER' | 'AG-PRIMARY-COLS-LIST' | 'AG-PRIMARY-COLS' | 'AG-ROW-CONTAINER' | 'AG-SELECT' | 'AG-SIDE-BAR' | 'AG-SIDE-BAR-BUTTONS' | 'AG-SLIDER' | 'AG-SORT-INDICATOR' | 'AG-STATUS-BAR' | 'AG-TOGGLE-BUTTON' | 'AG-WATERMARK';

package/dist/types/src/widgets/managedFocusFeature.d.ts

@@ -0,0 +1,16 @@
+import { BeanStub } from '../context/beanStub';
+export interface ManagedFocusCallbacks {
+    shouldStopEventPropagation?: (e: KeyboardEvent) => boolean;
+    onTabKeyDown?: (e: KeyboardEvent) => void;
+    handleKeyDown?: (e: KeyboardEvent) => void;
+    onFocusIn?: (e: FocusEvent) => void;
+    onFocusOut?: (e: FocusEvent) => void;
+}
+export declare const FOCUS_MANAGED_CLASS = "ag-focus-managed";
+export declare class ManagedFocusFeature extends BeanStub {
+    private readonly eFocusable;
+    private callbacks;
+    constructor(eFocusable: HTMLElement, callbacks?: ManagedFocusCallbacks);
+    postConstruct(): void;
+    private addKeyDownListeners;
+}

package/dist/types/src/widgets/popupModule.d.ts

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

package/dist/types/src/widgets/popupService.d.ts

@@ -0,0 +1,71 @@
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+import type { AgColumn } from '../entities/agColumn';
+import type { IAfterGuiAttachedParams } from '../interfaces/iAfterGuiAttachedParams';
+import type { PopupEventParams, PopupPositionParams } from '../interfaces/iPopup';
+import type { IRowNode } from '../interfaces/iRowNode';
+import { AgPromise } from '../utils/promise';
+export interface AddPopupParams {
+    modal?: boolean;
+    eChild: HTMLElement;
+    closeOnEsc?: boolean;
+    closedCallback?: (e?: MouseEvent | TouchEvent | KeyboardEvent) => void;
+    click?: MouseEvent | Touch | null;
+    alwaysOnTop?: boolean;
+    afterGuiAttached?: (params: IAfterGuiAttachedParams) => void;
+    positionCallback?: () => void;
+    anchorToElement?: HTMLElement;
+    ariaLabel: string;
+}
+export interface AddPopupResult {
+    hideFunc: (params?: PopupEventParams) => void;
+}
+export declare class PopupService extends BeanStub implements NamedBean {
+    beanName: "popupSvc";
+    private gridCtrl;
+    private popupList;
+    postConstruct(): void;
+    getPopupParent(): HTMLElement;
+    positionPopupForMenu(params: {
+        eventSource: HTMLElement;
+        ePopup: HTMLElement;
+    }): void;
+    positionPopupUnderMouseEvent(params: PopupPositionParams & {
+        type: string;
+        mouseEvent: MouseEvent | Touch;
+    }): void;
+    private calculatePointerAlign;
+    positionPopupByComponent(params: PopupPositionParams & {
+        type: string;
+        eventSource: HTMLElement;
+    }): void;
+    private shouldRenderUnderOrAbove;
+    private setAlignedStyles;
+    callPostProcessPopup(type: string, ePopup: HTMLElement, eventSource?: HTMLElement | null, mouseEvent?: MouseEvent | Touch | null, column?: AgColumn | null, rowNode?: IRowNode | null): void;
+    positionPopup(params: PopupPositionParams): void;
+    getActivePopups(): HTMLElement[];
+    getParentRect(): {
+        top: number;
+        left: number;
+        right: number;
+        bottom: number;
+    };
+    private keepXYWithinBounds;
+    addPopup(params: AddPopupParams): AddPopupResult;
+    private initialisePopupPosition;
+    private createPopupWrapper;
+    private handleThemeChange;
+    private addEventListenersToPopup;
+    private addPopupToPopupList;
+    private getPopupIndex;
+    setPopupPositionRelatedToElement(popupEl: HTMLElement, relativeElement?: HTMLElement | null): AgPromise<() => void> | undefined;
+    private removePopupFromPopupList;
+    private keepPopupPositionedRelativeTo;
+    hasAnchoredPopup(): boolean;
+    private isEventFromCurrentPopup;
+    isElementWithinCustomPopup(el: HTMLElement): boolean;
+    private getWrapper;
+    setAlwaysOnTop(ePopup: HTMLElement, alwaysOnTop?: boolean): void;
+    /** @return true if moved */
+    bringPopupToFront(ePopup: HTMLElement): void;
+}

package/dist/types/src/widgets/tabGuardCtrl.d.ts

@@ -0,0 +1,58 @@
+import { BeanStub } from '../context/beanStub';
+export declare const TabGuardClassNames: {
+    readonly TAB_GUARD: "ag-tab-guard";
+    readonly TAB_GUARD_TOP: "ag-tab-guard-top";
+    readonly TAB_GUARD_BOTTOM: "ag-tab-guard-bottom";
+};
+export interface ITabGuard {
+    setTabIndex(tabIndex?: string): void;
+}
+export declare class TabGuardCtrl extends BeanStub {
+    private readonly comp;
+    private readonly eTopGuard;
+    private readonly eBottomGuard;
+    private readonly eFocusableElement;
+    private readonly focusTrapActive;
+    private readonly forceFocusOutWhenTabGuardsAreEmpty;
+    private readonly isFocusableContainer;
+    private readonly providedFocusInnerElement?;
+    private readonly providedFocusIn?;
+    private readonly providedFocusOut?;
+    private readonly providedShouldStopEventPropagation?;
+    private readonly providedOnTabKeyDown?;
+    private readonly providedHandleKeyDown?;
+    private skipTabGuardFocus;
+    private forcingFocusOut;
+    private allowFocus;
+    constructor(params: {
+        comp: ITabGuard;
+        eTopGuard: HTMLElement;
+        eBottomGuard: HTMLElement;
+        eFocusableElement: HTMLElement;
+        focusTrapActive?: boolean;
+        forceFocusOutWhenTabGuardsAreEmpty?: boolean;
+        isFocusableContainer?: boolean;
+        focusInnerElement?: (fromBottom: boolean) => void;
+        onFocusIn?: (event: FocusEvent) => void;
+        onFocusOut?: (event: FocusEvent) => void;
+        shouldStopEventPropagation?: () => boolean;
+        onTabKeyDown?: (e: KeyboardEvent) => void;
+        handleKeyDown?: (e: KeyboardEvent) => void;
+    });
+    postConstruct(): void;
+    private handleKeyDown;
+    private tabGuardsAreActive;
+    private shouldStopEventPropagation;
+    private activateTabGuards;
+    private deactivateTabGuards;
+    private onFocus;
+    private findNextElementOutsideAndFocus;
+    private onFocusIn;
+    private onFocusOut;
+    onTabKeyDown(e: KeyboardEvent): void;
+    focusInnerElement(fromBottom?: boolean): void;
+    getNextFocusableElement(backwards?: boolean): HTMLElement | null;
+    forceFocusOutOfContainer(up?: boolean): void;
+    isTabGuard(element: HTMLElement, bottom?: boolean): boolean;
+    setAllowFocus(allowFocus: boolean): void;
+}

package/dist/types/src/widgets/touchListener.d.ts

@@ -0,0 +1,32 @@
+import type { AgEvent } from '../events';
+import type { IEventEmitter, IEventListener } from '../interfaces/iEventEmitter';
+export interface TapEvent extends AgEvent<'tap'> {
+    touchStart: Touch;
+}
+export interface DoubleTapEvent extends AgEvent<'doubleTap'> {
+    touchStart: Touch;
+}
+export interface LongTapEvent extends AgEvent<'longTap'> {
+    touchStart: Touch;
+    touchEvent: TouchEvent;
+}
+export type TouchListenerEvent = 'tap' | 'doubleTap' | 'longTap';
+export declare class TouchListener implements IEventEmitter<TouchListenerEvent> {
+    private DOUBLE_TAP_MILLIS;
+    private destroyFuncs;
+    private moved;
+    private touching;
+    private touchStart;
+    private lastTapTime;
+    private localEventService;
+    private preventMouseClick;
+    constructor(eElement: Element, preventMouseClick?: boolean);
+    private getActiveTouch;
+    addEventListener<T extends TouchListenerEvent>(eventType: T, listener: IEventListener<T>): void;
+    removeEventListener<T extends TouchListenerEvent>(eventType: T, listener: IEventListener<T>): void;
+    private onTouchStart;
+    private onTouchMove;
+    private onTouchEnd;
+    private checkForDoubleTap;
+    destroy(): void;
+}