ag-grid-community 32.3.2 → 33.0.0

package/dist/types/src/theming/theme-types.d.ts

@@ -0,0 +1,216 @@
+export type Feature = 'colorScheme' | 'iconSet' | 'checkboxStyle' | 'inputStyle' | 'tabStyle';
+declare const paramTypes: readonly ["colorScheme", "color", "length", "scale", "borderStyle", "border", "shadow", "image", "fontFamily", "fontWeight", "duration"];
+export type ParamType = (typeof paramTypes)[number];
+/**
+ * Return the ParamType for a given param name,
+ */
+export declare const getParamType: (arg: string) => "length" | "image" | "colorScheme" | "color" | "scale" | "borderStyle" | "border" | "shadow" | "fontFamily" | "fontWeight" | "duration";
+export type WithParamTypes<T> = {
+    [K in keyof T]: K extends string ? ParamTypeForLowercaseKey<Lowercase<K>> : LengthValue;
+};
+type ParamTypeForLowercaseKey<K extends string> = K extends `${string}color` ? ColorValue : K extends `${string}colorscheme` ? ColorSchemeValue : K extends `${string}color` ? ColorValue : K extends `${string}scale` ? ScaleValue : K extends `${string}borderstyle` ? BorderStyleValue : K extends `${string}border` ? BorderValue : K extends `${string}shadow` ? ShadowValue : K extends `${string}image` ? ImageValue : K extends `${string}fontfamily` ? FontFamilyValue : K extends `${string}fontweight` ? FontWeightValue : K extends `${string}duration` ? DurationValue : LengthValue;
+type AnyString = string & {};
+/**
+ * The 'brand color' for the grid, used wherever a non-neutral color is
+ * required. Selections, focus outlines and checkboxes use the accent color by
+ * default.
+ */
+export type ColorValue = string | {
+    /**
+     * The name of the color parameter to reference
+     */
+    ref: string;
+    /**
+     * Enable color mixing. Provide a value between 0 and 1 determining the amount of the referenced color used in the mix.
+     *
+     * By default, the referenced color will be mixed with `transparent` so 0 = fully transparent and 1 = fully opaque.
+     */
+    mix?: number;
+    /**
+     * Provide a second color reference to mix with instead of `transparent`. This has no effect if `mix` is unspecified.
+     */
+    onto?: string;
+    /**
+     * Provide a CSS color value to mix with instead of `transparent`.
+     * This has no effect if `mix` is unspecified. This is an alternative
+     * to `onto`, if both are provided then `onto` will be take precedence.
+     */
+    ontoColor?: string;
+};
+export declare const colorValueToCss: (value: ColorValue) => string | false;
+/**
+ * A CSS color-scheme value, e.g. "light", "dark", or "inherit" to use the
+ * same setting as the parent application
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/CSS/color-scheme
+ */
+export type ColorSchemeValue = 'light' | 'dark' | 'inherit' | 'normal' | AnyString;
+export declare const colorSchemeValueToCss: (value: string | number) => string | false;
+/**
+ * A CSS dimension value with length units, e.g. "1px" or "2em". Alternatively:
+ *
+ * - `4` -> "4px" (a plain JavaScript number will be given pixel units)
+ * - `{ref: "foo"}` -> use the same value as the `foo` param (`ref` must be a valid param name)
+ * - `{calc: "foo + bar * 2"}` -> Use a dynamically calculated expression. You can use param names like spacing and fontSize in the expression, as well as built-in CSS math functions like `min(spacing, fontSize)`
+ */
+export type LengthValue = number | string | {
+    /**
+     * An expression that can include param names and maths, e.g.
+     * "spacing * 2". NOTE: In CSS the `-` character is valid in variable
+     * names, so leave a space around it.
+     */
+    calc: string;
+} | {
+    ref: string;
+};
+export declare const lengthValueToCss: (value: LengthValue) => string | false;
+/**
+ * A number without units.
+ */
+export type ScaleValue = number;
+export declare const scaleValueToCss: (value: string | number) => string | false;
+/**
+ * A CSS border value e.g. "solid 1px red". Alternatively an object containing optional properties:
+ *
+ * - `style` -> a CSS border-style, default `"solid"`
+ * - `width` -> a width in pixels, default `1`
+ * - `color` -> a ColorValue as you would pass to any color param, default `{ref: "borderColor"}`
+ *
+ * Or a reference:
+ * - `{ref: "foo"}` -> use the same value as the `foo` param (`ref` must be a valid param name)
+ *
+ * Or boolean value
+ * - `true` -> `{}` (the default border style, equivalent to `{style: "solid", width: 1, color: {ref: "borderColor"}`)
+ * - `false` -> `"none"` (no border).
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/CSS/border
+ */
+export type BorderValue = string | boolean | {
+    style?: BorderStyleValue;
+    width?: LengthValue;
+    color?: ColorValue;
+} | {
+    ref: string;
+};
+export declare const borderValueToCss: (value: BorderValue, param: string) => string;
+/**
+ * A CSS box shadow value e.g. "10px 5px 5px red;". Alternatively an object containing optional properties:
+ *
+ * - `offsetX` -> number of pixels to move the shadow to the right, or a negative value to move left, default 0
+ * - `offsetY` -> number of pixels to move the shadow downwards, or a negative value to move up, default 0
+ * - `radius` -> softness of the shadow. 0 = hard edge, 10 = 10px wide blur
+ * - `spread` -> size of the shadow. 0 = same size as the shadow-casting element. 10 = 10px wider in all directions.
+ * - `color` -> color of the shadow e.g. `"red"`. Default `{ref: "foregroundColor"}`
+ *
+ * Or a reference:
+ * - `{ref: "foo"}` -> use the same value as the `foo` param (`ref` must be a valid param name)
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/CSS/box-shadow
+ */
+export type ShadowValue = string | false | {
+    /**
+     * Positive values move the shadow to the right, negative values move left
+     *
+     * @default 0
+     * @see https://developer.mozilla.org/en-US/docs/Web/CSS/box-shadow
+     */
+    offsetX?: LengthValue;
+    /**
+     * Positive values move the shadow downwards, negative values move up
+     *
+     * @default 0
+     * @see https://developer.mozilla.org/en-US/docs/Web/CSS/box-shadow
+     */
+    offsetY?: LengthValue;
+    /**
+     * Softness of the shadow. 0 = hard edge, 10 = 10px wide blur.
+     *
+     * @default 0
+     * @see https://developer.mozilla.org/en-US/docs/Web/CSS/box-shadow
+     */
+    radius?: LengthValue;
+    /**
+     * Size of the shadow. 0 = same size as the shadow-casting element. 10 = 10px wider in all directions.
+     *
+     * @default 0
+     * @see https://developer.mozilla.org/en-US/docs/Web/CSS/box-shadow
+     */
+    spread?: LengthValue;
+    /**
+     * Shadow color. Can accept any value that is valid for a color parameter, e.g. 'red' or {ref: 'accentColor'}
+     *
+     * @default {ref: 'foregroundColor'}
+     */
+    color?: ColorValue;
+} | {
+    ref: string;
+};
+export declare const shadowValueToCss: (value: ShadowValue) => string | false;
+/**
+ * A CSS line-style value e.g. "solid" or "dashed".
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/CSS/line-style
+ */
+export type BorderStyleValue = 'none' | 'solid' | 'dotted' | 'dashed';
+export declare const borderStyleValueToCss: (value: string | number) => string | false;
+/**
+ * A CSS font-family value consisting of a font name or comma-separated list of fonts in order of preference e.g. `"Roboto, -apple-system, 'Segoe UI', sans-serif"`. Alternatively:
+ *
+ * - `["Roboto", "-apple-system", "Segoe UI", "sans-serif"]` -> an array of font names in order of preference
+ * - `["Dave's Font"]` -> when passing an array, special characters in font names will automatically be escaped
+ * - `{ref: "foo"}` -> use the same value as `foo` which must be a valid font family param name
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/CSS/font-family
+ */
+export type FontFamilyValue = string | {
+    googleFont: string;
+} | Array<string | {
+    googleFont: string;
+}> | {
+    ref: string;
+};
+export declare const fontFamilyValueToCss: (value: FontFamilyValue) => string | false;
+/**
+ * A CSS font-weight value e.g. `500` or `"bold"`
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/CSS/font-weight
+ */
+export type FontWeightValue = 'normal' | 'bold' | AnyString | number;
+export declare const fontWeightValueToCss: (value: string | number) => string | false;
+/**
+ * A CSS image value e.g. `"url(...image-url...)"`. Alternatively:
+ *
+ * - `{svg: "...XML source of SVG image..."}` -> embed an SVG as a data: uri
+ * - `{url: "https://..."}` -> a URL to load an image asset from. Can be a HTTPS URL, or image assets such as PNGs can be converted to data: URLs
+ * - `{ref: "foo"}` -> use the same value as the `foo` param (`ref` must be a valid param name)
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/CSS/image
+ */
+export type ImageValue = string | {
+    /**
+     * The URL of an image. data: URLs can be used embed assets.
+     */
+    url: string;
+} | {
+    /**
+     * The XML text of an SVG file
+     */
+    svg: string;
+} | {
+    ref: string;
+};
+export declare const imageValueToCss: (value: ImageValue) => string | false;
+/**
+ * A CSS time value with second or millisecond units e.g. `"0.3s"` or `"300ms"`. Alternatively:
+ *
+ * - `0.4` -> "0.4s" (a plain JavaScript number is assumed to be a number of seconds.
+ * - `{ref: "foo"}` -> use the same value as the `foo` param (`ref` must be a valid param name)
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/CSS/animation-duration
+ */
+export type DurationValue = number | string | {
+    ref: string;
+};
+export declare const durationValueToCss: (value: DurationValue, param: string) => string | false;
+export declare const paramValueToCss: (param: string, value: unknown) => string | false;
+export {};

package/dist/types/src/theming/theme-utils.d.ts

@@ -0,0 +1,12 @@
+import type { ColorValue } from './theme-types';
+export declare const kebabCase: (str: string) => string;
+export declare const paramToVariableName: (paramName: string) => string;
+export declare const paramToVariableExpression: (paramName: string) => string;
+export declare const clamp: (value: number, min: number, max: number) => number;
+export declare const logErrorMessage: (message: unknown, error?: unknown) => void;
+export declare const memoize: <R, A = void>(fn: (arg: A) => R) => (arg: A) => R;
+export declare const accentMix: (mix: number) => ColorValue;
+export declare const foregroundMix: (mix: number) => ColorValue;
+export declare const foregroundBackgroundMix: (mix: number) => ColorValue;
+export declare const foregroundColor: ColorValue;
+export declare const accentColor: ColorValue;

package/dist/types/src/tooltip/tooltip.css-GENERATED.d.ts

@@ -0,0 +1 @@
+export declare const tooltipCSS = ".ag-tooltip{background-color:var(--ag-tooltip-background-color);border:var(--ag-tooltip-border);border-radius:var(--ag-border-radius);color:var(--ag-tooltip-text-color);padding:var(--ag-widget-container-vertical-padding) var(--ag-widget-container-horizontal-padding);white-space:normal}.ag-tooltip,.ag-tooltip-custom{position:absolute;z-index:99999}.ag-tooltip-custom:where(:not(.ag-tooltip-interactive)),.ag-tooltip:where(:not(.ag-tooltip-interactive)){pointer-events:none}.ag-tooltip-animate{transition:opacity 1s;&:where(.ag-tooltip-hiding){opacity:0}}";

package/dist/types/src/tooltip/tooltipFeature.d.ts

@@ -0,0 +1,40 @@
+import { BeanStub } from '../context/beanStub';
+import type { BeanCollection } from '../context/context';
+import type { AgColumn } from '../entities/agColumn';
+import type { AgColumnGroup } from '../entities/agColumnGroup';
+import type { ColDef, ColGroupDef } from '../entities/colDef';
+import type { RowNode } from '../entities/rowNode';
+import type { GridOptionsService } from '../gridOptionsService';
+import type { TooltipLocation } from './tooltipComponent';
+export interface ITooltipCtrl {
+    getTooltipValue?(): any;
+    getGui(): HTMLElement;
+    getLocation?(): TooltipLocation;
+    getColumn?(): AgColumn | AgColumnGroup;
+    getColDef?(): ColDef | ColGroupDef;
+    getRowIndex?(): number;
+    getRowNode?(): RowNode;
+    getValueFormatted?(): string;
+    getTooltipShowDelayOverride?(): number;
+    getTooltipHideDelayOverride?(): number;
+    shouldDisplayTooltip?(): boolean;
+    /** Additional params to be passed to the tooltip */
+    getAdditionalParams?(): Record<string, any>;
+}
+export declare function _isShowTooltipWhenTruncated(gos: GridOptionsService): boolean;
+export declare function _getShouldDisplayTooltip(gos: GridOptionsService, getElement: () => HTMLElement | undefined): (() => boolean) | undefined;
+export declare function _shouldDisplayTooltip(getElement: () => HTMLElement | undefined): () => boolean;
+export declare class TooltipFeature extends BeanStub {
+    private readonly ctrl;
+    private tooltip;
+    private tooltipManager;
+    private browserTooltips;
+    constructor(ctrl: ITooltipCtrl, beans?: BeanCollection);
+    postConstruct(): void;
+    private setBrowserTooltip;
+    private updateTooltipText;
+    private createTooltipFeatureIfNeeded;
+    setTooltipAndRefresh(tooltip: any): void;
+    refreshTooltip(): void;
+    destroy(): void;
+}

package/dist/types/src/tooltip/tooltipModule.d.ts

@@ -0,0 +1,6 @@
+import type { _ModuleWithoutApi } from '../interfaces/iModule';
+/**
+ * @feature Tooltips
+ * @colDef tooltipField, tooltipValueGetter, headerTooltip
+ */
+export declare const TooltipModule: _ModuleWithoutApi;

package/dist/types/src/tooltip/tooltipService.d.ts

@@ -0,0 +1,17 @@
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+import type { AgColumn } from '../entities/agColumn';
+import type { HeaderCellCtrl } from '../headerRendering/cells/column/headerCellCtrl';
+import type { HeaderGroupCellCtrl } from '../headerRendering/cells/columnGroup/headerGroupCellCtrl';
+import type { CellCtrl } from '../rendering/cell/cellCtrl';
+import type { RowCtrl } from '../rendering/row/rowCtrl';
+import type { TooltipFeature } from './tooltipFeature';
+export declare class TooltipService extends BeanStub implements NamedBean {
+    beanName: "tooltipSvc";
+    setupHeaderTooltip(existingTooltipFeature: TooltipFeature | undefined, ctrl: HeaderCellCtrl, value?: string, shouldDisplayTooltip?: () => boolean): TooltipFeature | undefined;
+    setupHeaderGroupTooltip(existingTooltipFeature: TooltipFeature | undefined, ctrl: HeaderGroupCellCtrl, value?: string, shouldDisplayTooltip?: () => boolean): TooltipFeature | undefined;
+    enableCellTooltipFeature(ctrl: CellCtrl, value?: string, shouldDisplayTooltip?: () => boolean): TooltipFeature | undefined;
+    refreshRowTooltip(existingTooltipFeature: TooltipFeature | undefined, ctrl: RowCtrl, value: string, shouldDisplayTooltip?: () => boolean): TooltipFeature | undefined;
+    initCol(column: AgColumn): void;
+    private createTooltipFeature;
+}

package/dist/types/src/tooltip/tooltipStateManager.d.ts

@@ -0,0 +1,63 @@
+import { BeanStub } from '../context/beanStub';
+import type { BeanCollection } from '../context/context';
+import type { ITooltipCtrl } from './tooltipFeature';
+export declare class TooltipStateManager extends BeanStub {
+    private readonly tooltipCtrl;
+    private readonly getTooltipValue;
+    private popupSvc?;
+    private userCompFactory;
+    wireBeans(beans: BeanCollection): void;
+    private showTooltipTimeoutId;
+    private hideTooltipTimeoutId;
+    private interactiveTooltipTimeoutId;
+    private interactionEnabled;
+    private isInteractingWithTooltip;
+    private state;
+    private lastMouseEvent;
+    private tooltipComp;
+    private tooltipPopupDestroyFunc;
+    private tooltipInstanceCount;
+    private tooltipMouseTrack;
+    private tooltipTrigger;
+    private tooltipMouseEnterListener;
+    private tooltipMouseLeaveListener;
+    private tooltipFocusInListener;
+    private tooltipFocusOutListener;
+    private onBodyScrollEventCallback;
+    private onColumnMovedEventCallback;
+    private onDocumentKeyDownCallback;
+    constructor(tooltipCtrl: ITooltipCtrl, getTooltipValue: () => any);
+    postConstruct(): void;
+    private getGridOptionsTooltipDelay;
+    private getTooltipDelay;
+    destroy(): void;
+    private getTooltipTrigger;
+    onMouseEnter(e: MouseEvent): void;
+    private onMouseMove;
+    private onMouseDown;
+    private onMouseLeave;
+    private onFocusIn;
+    private onFocusOut;
+    private onKeyDown;
+    private prepareToShowTooltip;
+    private isLastTooltipHiddenRecently;
+    private setToDoNothing;
+    private showTooltip;
+    hideTooltip(forceHide?: boolean): void;
+    private newTooltipComponentCallback;
+    private onTooltipMouseEnter;
+    private onTooltipMouseLeave;
+    private onTooltipFocusIn;
+    private isTooltipFocused;
+    private onTooltipFocusOut;
+    private positionTooltip;
+    private destroyTooltipComp;
+    private clearTooltipListeners;
+    private lockService;
+    private unlockService;
+    private startHideTimeout;
+    private clearShowTimeout;
+    private clearHideTimeout;
+    private clearInteractiveTimeout;
+    private clearTimeouts;
+}

package/dist/types/src/undoRedo/undoRedoService.d.ts

@@ -0,0 +1,27 @@
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+export declare class UndoRedoService extends BeanStub implements NamedBean {
+    beanName: "undoRedo";
+    private gridBodyCtrl;
+    private cellValueChanges;
+    private undoStack;
+    private redoStack;
+    private activeCellEdit;
+    private activeRowEdit;
+    private isPasting;
+    private isRangeInAction;
+    postConstruct(): void;
+    private onCellValueChanged;
+    private clearStacks;
+    getCurrentUndoStackSize(): number;
+    getCurrentRedoStackSize(): number;
+    undo(source: 'api' | 'ui'): void;
+    redo(source: 'api' | 'ui'): void;
+    private undoRedo;
+    private processAction;
+    private processRange;
+    private processCell;
+    private setLastFocusedCell;
+    private addListeners;
+    private pushActionsToUndoStack;
+}

package/dist/types/src/utils/aria.d.ts

@@ -0,0 +1,34 @@
+import type { SortDirection } from '../entities/colDef';
+import type { LocaleTextFunc } from '../misc/locale/localeUtils';
+export type ColumnSortState = 'ascending' | 'descending' | 'other' | 'none';
+export declare function _setAriaRole(element: Element, role?: string | null): void;
+export declare function _getAriaSortState(sortDirection: SortDirection | 'mixed'): ColumnSortState;
+export declare function _getAriaLevel(element: Element): number;
+export declare function _getAriaPosInSet(element: Element): number;
+export declare function _getAriaLabel(element: Element): string | null;
+export declare function _setAriaLabel(element: Element, label?: string | null): void;
+export declare function _setAriaLabelledBy(element: Element, labelledBy?: string): void;
+export declare function _setAriaDescribedBy(element: Element, describedby?: string): void;
+export declare function _setAriaLive(element: Element, live?: 'polite' | 'assertive' | 'off' | null): void;
+export declare function _setAriaAtomic(element: Element, atomic: boolean | null): void;
+export declare function _setAriaRelevant(element: Element, relevant: 'additions' | 'additions text' | 'all' | 'removals' | 'text' | null): void;
+export declare function _setAriaLevel(element: Element, level: number): void;
+export declare function _setAriaDisabled(element: Element, disabled: boolean): void;
+export declare function _setAriaHidden(element: Element, hidden: boolean): void;
+export declare function _setAriaActiveDescendant(element: Element, descendantId: string | null): void;
+export declare function _setAriaExpanded(element: Element, expanded: boolean): void;
+export declare function _removeAriaExpanded(element: Element): void;
+export declare function _setAriaSetSize(element: Element, setsize: number): void;
+export declare function _setAriaPosInSet(element: Element, position: number): void;
+export declare function _setAriaMultiSelectable(element: Element, multiSelectable: boolean): void;
+export declare function _setAriaRowCount(element: Element, rowCount: number): void;
+export declare function _setAriaRowIndex(element: Element, rowIndex: number): void;
+export declare function _setAriaColCount(element: Element, colCount: number): void;
+export declare function _setAriaColIndex(element: Element, colIndex: number): void;
+export declare function _setAriaColSpan(element: Element, colSpan: number): void;
+export declare function _setAriaSort(element: Element, sort: ColumnSortState): void;
+export declare function _removeAriaSort(element: Element): void;
+export declare function _setAriaSelected(element: Element, selected?: boolean): void;
+export declare function _setAriaChecked(element: Element, checked?: boolean): void;
+export declare function _setAriaControls(controllerElement: Element, controlledElement: Element): void;
+export declare function _getAriaCheckboxStateName(translate: LocaleTextFunc, state?: boolean): string;

package/dist/types/src/utils/array.d.ts

@@ -0,0 +1,8 @@
+/** An array that is always empty and that cannot be modified */
+export declare const _EmptyArray: any[];
+export declare function _last<T>(arr: T[]): T;
+export declare function _last<T extends Node>(arr: NodeListOf<T>): T;
+export declare function _areEqual<T>(a?: readonly T[] | null, b?: readonly T[] | null, comparator?: (a: T, b: T) => boolean): boolean;
+export declare function _sortNumerically(array: number[]): number[];
+export declare function _removeFromArray<T>(array: T[], object: T): void;
+export declare function _moveInArray<T>(array: T[], objectsToMove: T[], toIndex: number): void;

package/dist/types/src/utils/browser.d.ts

@@ -0,0 +1,12 @@
+export declare function _isBrowserSafari(): boolean;
+/**
+ * Returns true for Chrome and also for Edge (Chromium)
+ */
+export declare function _isBrowserChrome(): boolean;
+export declare function _isBrowserFirefox(): boolean;
+export declare function _isMacOsUserAgent(): boolean;
+export declare function _isIOSUserAgent(): boolean;
+export declare function _getTabIndex(el: HTMLElement | null): string | null;
+export declare function _getMaxDivHeight(): number;
+export declare function _getScrollbarWidth(): number | null;
+export declare function _isInvisibleScrollbar(): boolean;

package/dist/types/src/utils/changedPath.d.ts

@@ -0,0 +1,21 @@
+import type { AgColumn } from '../entities/agColumn';
+import type { RowNode } from '../entities/rowNode';
+export declare class ChangedPath {
+    private readonly keepingColumns;
+    private readonly pathRoot;
+    active: boolean;
+    private nodeIdsToColumns;
+    private mapToItems;
+    constructor(keepingColumns: boolean, rootNode: RowNode);
+    private depthFirstSearchChangedPath;
+    private depthFirstSearchEverything;
+    forEachChangedNodeDepthFirst(callback: (rowNode: RowNode) => void, traverseLeafNodes?: boolean, includeUnchangedNodes?: boolean): void;
+    executeFromRootNode(callback: (rowNode: RowNode) => void): void;
+    private createPathItems;
+    private populateColumnsMap;
+    private linkPathItems;
+    addParentNode(rowNode: RowNode | null, columns?: AgColumn[]): void;
+    canSkip(rowNode: RowNode): boolean;
+    getValueColumnsForNode(rowNode: RowNode, valueColumns: AgColumn[]): AgColumn[];
+    getNotValueColumnsForNode(rowNode: RowNode, valueColumns: AgColumn[]): AgColumn[] | null;
+}

package/dist/types/src/utils/dom.d.ts

@@ -0,0 +1,94 @@
+import type { BeanCollection } from '../context/context';
+import type { CellStyle } from '../entities/colDef';
+import type { RowStyle } from '../entities/gridOptions';
+import type { ICellRendererComp } from '../rendering/cellRenderers/iCellRenderer';
+import type { AgPromise } from './promise';
+/**
+ * This method adds a class to an element and remove that class from all siblings.
+ * Useful for toggling state.
+ * @param {HTMLElement} element The element to receive the class
+ * @param {string} elementClass The class to be assigned to the element
+ * @param {boolean} otherElementClass The class to be assigned to siblings of the element, but not the element itself
+ */
+export declare function _radioCssClass(element: HTMLElement, elementClass: string | null, otherElementClass?: string | null): void;
+export declare const FOCUSABLE_SELECTOR = "[tabindex], input, select, button, textarea, [href]";
+export declare const FOCUSABLE_EXCLUDE = "[disabled], .ag-disabled:not(.ag-button), .ag-disabled *";
+export declare function _isFocusableFormField(element: HTMLElement): boolean;
+export declare function _setDisplayed(element: Element, displayed: boolean, options?: {
+    skipAriaHidden?: boolean;
+}): void;
+export declare function _setVisible(element: HTMLElement, visible: boolean, options?: {
+    skipAriaHidden?: boolean;
+}): void;
+export declare function _setDisabled(element: HTMLElement, disabled: boolean): void;
+export declare function _isElementChildOfClass(element: HTMLElement | null, cls: string, maxNest?: HTMLElement | number): boolean;
+export declare function _getElementSize(el: HTMLElement): {
+    height: number;
+    width: number;
+    borderTopWidth: number;
+    borderRightWidth: number;
+    borderBottomWidth: number;
+    borderLeftWidth: number;
+    paddingTop: number;
+    paddingRight: number;
+    paddingBottom: number;
+    paddingLeft: number;
+    marginTop: number;
+    marginRight: number;
+    marginBottom: number;
+    marginLeft: number;
+    boxSizing: string;
+};
+export declare function _getInnerHeight(el: HTMLElement): number;
+export declare function _getInnerWidth(el: HTMLElement): number;
+export declare function _getAbsoluteHeight(el: HTMLElement): number;
+export declare function _getAbsoluteWidth(el: HTMLElement): number;
+export declare function _getElementRectWithOffset(el: HTMLElement): {
+    top: number;
+    left: number;
+    right: number;
+    bottom: number;
+};
+export declare function _isRtlNegativeScroll(): boolean;
+export declare function _getScrollLeft(element: HTMLElement, rtl: boolean): number;
+export declare function _setScrollLeft(element: HTMLElement, value: number, rtl: boolean): void;
+export declare function _clearElement(el: HTMLElement): void;
+export declare function _removeFromParent(node: Element | null): void;
+export declare function _isInDOM(element: HTMLElement): boolean;
+export declare function _isVisible(element: HTMLElement): any;
+/**
+ * Loads the template and returns it as an element. makes up for no simple way in
+ * the dom api to load html directly, eg we cannot do this: document.createElement(template)
+ * @param {string} template
+ * @returns {HTMLElement}
+ */
+export declare function _loadTemplate(template: string): HTMLElement;
+export declare function _ensureDomOrder(eContainer: HTMLElement, eChild: HTMLElement, eChildBefore?: HTMLElement | null): void;
+export declare function _setDomChildOrder(eContainer: HTMLElement, orderedChildren: (HTMLElement | null)[]): void;
+export declare function _insertWithDomOrder(eContainer: HTMLElement, eToInsert: HTMLElement, eChildBefore: HTMLElement | null): void;
+export declare function _addStylesToElement(eElement: any, styles: RowStyle | CellStyle | null | undefined): void;
+export declare function _isHorizontalScrollShowing(element: HTMLElement): boolean;
+export declare function _isVerticalScrollShowing(element: HTMLElement): boolean;
+export declare function _setElementWidth(element: HTMLElement, width: string | number): void;
+export declare function _setFixedWidth(element: HTMLElement, width: string | number): void;
+export declare function _setElementHeight(element: HTMLElement, height: string | number): void;
+export declare function _setFixedHeight(element: HTMLElement, height: string | number): void;
+export declare function _formatSize(size: number | string): string;
+export declare function _isNodeOrElement(o: any): o is Node | Element;
+/**
+ * Makes a copy of a node list into a list
+ * @param {NodeList} nodeList
+ * @returns {Node[]}
+ */
+export declare function _copyNodeList(nodeList: NodeListOf<Node> | null): Node[];
+export declare function _iterateNamedNodeMap(map: NamedNodeMap, callback: (key: string, value: string) => void): void;
+export declare function _addOrRemoveAttribute(element: HTMLElement, name: string, value: string | number | null | undefined): void;
+export declare function _nodeListForEach<T extends Node>(nodeList: NodeListOf<T> | null, action: (value: T) => void): void;
+/**
+ * cell renderers are used in a few places. they bind to dom slightly differently to other cell renders as they
+ * can return back strings (instead of html element) in the getGui() method. common code placed here to handle that.
+ * @param {AgPromise<ICellRendererComp>} cellRendererPromise
+ * @param {HTMLElement} eTarget
+ */
+export declare function _bindCellRendererToHtmlElement(cellRendererPromise: AgPromise<ICellRendererComp>, eTarget: HTMLElement): void;
+export declare function _observeResize(beans: BeanCollection, element: HTMLElement, callback: () => void): () => void;

package/dist/types/src/utils/event.d.ts

@@ -0,0 +1,30 @@
+import type { GridOptionsService } from '../gridOptionsService';
+import type { IFrameworkOverrides } from '../interfaces/iFrameworkOverrides';
+/**
+ * a user once raised an issue - they said that when you opened a popup (eg context menu)
+ * and then clicked on a selection checkbox, the popup wasn't closed. this is because the
+ * popup listens for clicks on the body, however ag-grid WAS stopping propagation on the
+ * checkbox clicks (so the rows didn't pick them up as row selection selection clicks).
+ * to get around this, we have a pattern to stop propagation for the purposes of AG Grid,
+ * but we still let the event pass back to the body.
+ * @param {Event} event
+ */
+export declare function _stopPropagationForAgGrid(event: Event): void;
+export declare function _isStopPropagationForAgGrid(event: Event): boolean;
+export declare const _isEventSupported: (eventName: any) => boolean;
+export declare function _getCtrlForEventTarget<T>(gos: GridOptionsService, eventTarget: EventTarget | null, type: string): T | null;
+export declare function _isElementInEventPath(element: HTMLElement, event: Event): boolean;
+export declare function _createEventPath(event: {
+    target: EventTarget;
+}): EventTarget[];
+/**
+ * Gets the path for a browser Event or from the target on an AG Grid Event
+ * https://developer.mozilla.org/en-US/docs/Web/API/Event
+ * @param {Event| { target: EventTarget }} event
+ * @returns {EventTarget[]}
+ */
+export declare function _getEventPath(event: Event | {
+    target: EventTarget;
+}): EventTarget[];
+export declare function _addSafePassiveEventListener(frameworkOverrides: IFrameworkOverrides, eElement: HTMLElement, event: string, listener: (event?: any) => void): void;
+export declare const getPassiveStateForEvent: (event: string) => boolean | undefined;

package/dist/types/src/utils/focus.d.ts

@@ -0,0 +1,13 @@
+import type { BeanCollection } from '../context/context';
+import type { Component } from '../widgets/component';
+export declare function _registerKeyboardFocusEvents(beans: BeanCollection): () => void;
+export declare function _isKeyboardMode(): boolean;
+export declare function _addFocusableContainerListener(beans: BeanCollection, comp: Component, eGui: HTMLElement): void;
+export declare function _findFocusableElements(rootNode: HTMLElement, exclude?: string | null, onlyUnmanaged?: boolean): HTMLElement[];
+export declare function _focusInto(rootNode: HTMLElement, up?: boolean, onlyUnmanaged?: boolean): boolean;
+export declare function _findNextFocusableElement(beans: BeanCollection, rootNode: HTMLElement, onlyManaged?: boolean | null, backwards?: boolean): HTMLElement | null;
+export declare function _findTabbableParent(node: HTMLElement | null, limit?: number): HTMLElement | null;
+export declare function _focusGridInnerElement(beans: BeanCollection, fromBottom?: boolean): boolean;
+export declare function _isHeaderFocusSuppressed(beans: BeanCollection): boolean;
+export declare function _isCellFocusSuppressed(beans: BeanCollection): boolean;
+export declare function _focusNextGridCoreContainer(beans: BeanCollection, backwards: boolean, forceOut?: boolean): boolean;

package/dist/types/src/utils/function.d.ts

@@ -0,0 +1,27 @@
+import type { GridOptionsService } from '../gridOptionsService';
+/**
+ * If the key was passed before, then doesn't execute the func
+ * @param {Function} func
+ * @param {string} key
+ */
+export declare function _doOnce(func: () => void, key: string): void;
+export declare function _logIfDebug(gos: GridOptionsService, message: string, ...args: any[]): void;
+export declare function _warnOnce(msg: string, ...args: any[]): void;
+export declare function _errorOnce(msg: string, ...args: any[]): void;
+export declare function _executeNextVMTurn(func: () => void): void;
+/**
+ * Creates a debounced function a function, and attach it to a bean for lifecycle
+ * @param {Function} func The function to be debounced
+ * @param {number} delay The time in ms to debounce
+ * @return {Function} The debounced function
+ */
+export declare function _debounce(bean: {
+    isAlive(): boolean;
+}, func: (...args: any[]) => void, delay: number): (...args: any[]) => void;
+/**
+ * @param {Function} func The function to be throttled
+ * @param {number} wait The time in ms to throttle
+ * @return {Function} The throttled function
+ */
+export declare function _throttle(func: (...args: any[]) => void, wait: number): (...args: any[]) => void;
+export declare function _waitUntil(condition: () => boolean, callback: () => void, timeout?: number, timeoutMessage?: string): void;

package/dist/types/src/utils/generic.d.ts

@@ -0,0 +1,12 @@
+/**
+ * If value is undefined, null or blank, returns null, otherwise returns the value
+ * @param {T} value
+ * @returns {T | null}
+ */
+export declare function _makeNull<T>(value?: T): T | null;
+export declare function _exists(value: string | null | undefined): value is string;
+export declare function _exists<T>(value: T): value is NonNullable<T>;
+export declare function _missing<T>(value: T | null | undefined): value is Exclude<undefined | null, T>;
+export declare function _toStringOrNull(value: any): string | null;
+export declare function _jsonEquals<T1, T2>(val1: T1, val2: T2): boolean;
+export declare function _defaultComparator(valueA: any, valueB: any, accentedCompare?: boolean): number;