ag-grid-community 32.3.2 → 33.0.0

package/dist/types/src/sort/sortService.d.ts

@@ -0,0 +1,39 @@
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+import type { AgColumn } from '../entities/agColumn';
+import type { SortDirection } from '../entities/colDef';
+import type { ColumnEventType } from '../events';
+import type { SortModelItem } from '../interfaces/iSortModelItem';
+import type { SortOption } from '../interfaces/iSortOption';
+import type { Component, ComponentSelector } from '../widgets/component';
+import { SortIndicatorComp } from './sortIndicatorComp';
+export declare const DEFAULT_SORTING_ORDER: SortDirection[];
+export declare class SortService extends BeanStub implements NamedBean {
+    beanName: "sortSvc";
+    progressSort(column: AgColumn, multiSort: boolean, source: ColumnEventType): void;
+    progressSortFromEvent(column: AgColumn, event: MouseEvent | KeyboardEvent): void;
+    setSortForColumn(column: AgColumn, sort: SortDirection, multiSort: boolean, source: ColumnEventType): void;
+    private updateSortIndex;
+    onSortChanged(source: string, columns?: AgColumn[]): void;
+    isSortActive(): boolean;
+    dispatchSortChangedEvents(source: string, columns?: AgColumn[]): void;
+    private clearSortBarTheseColumns;
+    private getNextSortDirection;
+    /**
+     * @returns a map of sort indexes for every sorted column, if groups sort primaries then they will have equivalent indices
+     */
+    private getIndexedSortMap;
+    getColumnsWithSortingOrdered(): AgColumn[];
+    getSortModel(): SortModelItem[];
+    getSortOptions(): SortOption[];
+    canColumnDisplayMixedSort(column: AgColumn): boolean;
+    getDisplaySortForColumn(column: AgColumn): SortDirection | 'mixed' | undefined;
+    getDisplaySortIndexForColumn(column: AgColumn): number | null | undefined;
+    setupHeader(comp: Component, column: AgColumn, clickElement?: HTMLElement): void;
+    initCol(column: AgColumn): void;
+    updateColSort(column: AgColumn, sort: SortDirection | undefined, source: ColumnEventType): void;
+    private setColSort;
+    setColSortIndex(column: AgColumn, sortOrder?: number | null): void;
+    createSortIndicator(skipTemplate?: boolean): SortIndicatorComp;
+    getSortIndicatorSelector(): ComponentSelector;
+}

package/dist/types/src/styling/cellCustomStyleFeature.d.ts

@@ -0,0 +1,16 @@
+import { BeanStub } from '../context/beanStub';
+import type { BeanCollection } from '../context/context';
+import type { CellCtrl, ICellComp } from '../rendering/cell/cellCtrl';
+export declare class CellCustomStyleFeature extends BeanStub {
+    private readonly cellCtrl;
+    private readonly column;
+    private staticClasses;
+    private cellComp;
+    private cellClassRules?;
+    constructor(cellCtrl: CellCtrl, beans: BeanCollection);
+    setComp(comp: ICellComp): void;
+    applyCellClassRules(): void;
+    applyUserStyles(): void;
+    applyClassesFromColDef(): void;
+    private getCellClassParams;
+}

package/dist/types/src/styling/cellStyleService.d.ts

@@ -0,0 +1,13 @@
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+import type { BeanCollection } from '../context/context';
+import type { CellClassParams, ColDef } from '../entities/colDef';
+import type { CellCtrl } from '../rendering/cell/cellCtrl';
+import { CellCustomStyleFeature } from './cellCustomStyleFeature';
+export declare class CellStyleService extends BeanStub implements NamedBean {
+    beanName: "cellStyles";
+    processAllCellClasses(colDef: ColDef, params: CellClassParams, onApplicableClass: (className: string) => void, onNotApplicableClass?: (className: string) => void): void;
+    getStaticCellClasses(colDef: ColDef, params: CellClassParams): string[];
+    createCellCustomStyleFeature(ctrl: CellCtrl, beans: BeanCollection): CellCustomStyleFeature;
+    private processStaticCellClasses;
+}

package/dist/types/src/styling/layoutFeature.d.ts

@@ -0,0 +1,20 @@
+import { BeanStub } from '../context/beanStub';
+export interface LayoutView {
+    updateLayoutClasses(layoutClass: string, params: UpdateLayoutClassesParams): void;
+}
+export declare const LayoutCssClasses: {
+    readonly AUTO_HEIGHT: "ag-layout-auto-height";
+    readonly NORMAL: "ag-layout-normal";
+    readonly PRINT: "ag-layout-print";
+};
+export interface UpdateLayoutClassesParams {
+    autoHeight: boolean;
+    normal: boolean;
+    print: boolean;
+}
+export declare class LayoutFeature extends BeanStub {
+    private view;
+    constructor(view: LayoutView);
+    postConstruct(): void;
+    private updateLayoutClasses;
+}

package/dist/types/src/styling/rowStyleService.d.ts

@@ -0,0 +1,12 @@
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+import type { RowStyle } from '../entities/gridOptions';
+import type { RowNode } from '../entities/rowNode';
+export declare function calculateRowLevel(rowNode: RowNode): number;
+export declare class RowStyleService extends BeanStub implements NamedBean {
+    beanName: "rowStyleSvc";
+    processClassesFromGridOptions(classes: string[], rowNode: RowNode): void;
+    preProcessRowClassRules(classes: string[], rowNode: RowNode): void;
+    processRowClassRules(rowNode: RowNode, onApplicableClass: (className: string) => void, onNotApplicableClass?: (className: string) => void): void;
+    processStylesFromGridOptions(rowNode: RowNode): RowStyle | undefined;
+}

package/dist/types/src/styling/stylingModule.d.ts

@@ -0,0 +1,11 @@
+import type { _ModuleWithoutApi } from '../interfaces/iModule';
+/**
+ * @feature Cells -> Styling Cells
+ * @colDef cellStyle, cellClass, cellClassRules
+ */
+export declare const CellStyleModule: _ModuleWithoutApi;
+/**
+ * @feature Rows -> Styling Rows
+ * @gridOption rowStyle, getRowStyle, rowClass, getRowClass, rowClassRules
+ */
+export declare const RowStyleModule: _ModuleWithoutApi;

package/dist/types/src/styling/stylingUtils.d.ts

@@ -0,0 +1,8 @@
+import type { CellClassParams } from '../entities/colDef';
+import type { RowClassParams } from '../entities/gridOptions';
+import type { ExpressionService } from '../valueService/expressionService';
+export declare function processClassRules(expressionSvc: ExpressionService | undefined, previousClassRules: {
+    [cssClassName: string]: ((...args: any[]) => any) | string;
+} | undefined, classRules: {
+    [cssClassName: string]: ((...args: any[]) => any) | string;
+} | undefined, params: RowClassParams | CellClassParams, onApplicableClass: (className: string) => void, onNotApplicableClass?: (className: string) => void): void;

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

@@ -0,0 +1,11 @@
+import type { NamedBean } from './context/bean';
+import { BeanStub } from './context/beanStub';
+export declare class SyncService extends BeanStub implements NamedBean {
+    beanName: "syncSvc";
+    private waitingForColumns;
+    postConstruct(): void;
+    start(): void;
+    private setColumnsAndData;
+    private gridReady;
+    private setColumnDefs;
+}

package/dist/types/src/theming/Part.d.ts

@@ -0,0 +1,64 @@
+import type { Feature, WithParamTypes } from './theme-types';
+/**
+ * A collection of CSS styles and default parameter values that can be added to
+ * a theme. Parts are created with the createPart helper function.
+ */
+export type Part<TParams = unknown> = {
+    readonly feature?: string;
+    readonly modeParams: Record<string, TParams>;
+    readonly css?: string | (() => string) | undefined;
+};
+type AnyString = string & {};
+export type ExpandTypeKeys<T> = T extends infer O ? {
+    [K in keyof O]: O[K];
+} : never;
+type CreatePartArgs<T> = {
+    /**
+     * A string feature, e.g. 'iconSet'. Adding a part to a theme will remove
+     * any existing part with the same feature.
+     */
+    feature?: Feature | AnyString;
+    /**
+     * Default parameters for the part.
+     */
+    params?: WithParamTypes<T>;
+    /**
+     * Parameters for different theme modes, e.g. 'dark' or 'light'. Setting
+     * `modeParams: {myMode: {myColor: 'red'}}` on a theme part is the equivalent
+     * of `theme.withParams({myColor: 'red'}, 'myMode')`.
+     */
+    modeParams?: Record<string, WithParamTypes<T>>;
+    /**
+     * CSS styles associated with this part. The CSS will be injected into the
+     * page when the theme is used by a grid.
+     *
+     * The grid uses CSS nested to wrap this CSS in a selector that ensures it
+     * only applies to grids that are using a theme containing this part.
+     */
+    css?: string | (() => string);
+    /**
+     * URLs of CSS files to import before the part's CSS.
+     */
+    cssImports?: string[];
+};
+/**
+ * Create a new empty part.
+ *
+ * @param feature an The part feature, e.g. 'iconSet'. Adding a part to a theme will remove any existing part with the same feature.
+ * @param variant an optional identifier for debugging, if omitted one will be generated
+ */
+export declare const createPart: <T = unknown>(args: CreatePartArgs<T>) => Part<ExpandTypeKeys<WithParamTypes<T>>>;
+export declare const defaultModeName = "$default";
+export declare class PartImpl implements Part {
+    feature?: string | undefined;
+    modeParams: Record<string, Record<string, unknown>>;
+    css?: string | (() => string) | undefined;
+    cssImports?: string[];
+    _inject?: {
+        css: string;
+        class: string;
+    } | false;
+    constructor({ feature, params, modeParams, css, cssImports }: CreatePartArgs<unknown>);
+    use(container?: HTMLElement): string | false;
+}
+export {};

package/dist/types/src/theming/Theme.d.ts

@@ -0,0 +1,70 @@
+import type { Part } from './Part';
+import { PartImpl } from './Part';
+import type { CoreParams } from './core/core-css';
+import type { WithParamTypes } from './theme-types';
+export type Theme<TParams = unknown> = {
+    /**
+     * Return a new theme that uses an theme part. The part will replace any
+     * existing part of the same feature
+     *
+     * @param part a part, or a no-arg function that returns a part
+     */
+    withPart<TPartParams>(part: Part<TPartParams> | (() => Part<TPartParams>)): Theme<TParams & TPartParams>;
+    /**
+     * Return a new theme removes any existing part with a feature.
+     *
+     * @param feature the name of the part to remove, e.g. 'checkboxStyle'
+     */
+    withoutPart(feature: string): Theme<TParams>;
+    /**
+     * Return a new theme with different default values for the specified
+     * params.
+     *
+     * @param defaults an object containing params e.g. {spacing: 10}
+     */
+    withParams(defaults: Partial<TParams>, mode?: string): Theme<TParams>;
+};
+export declare const _asThemeImpl: <TParams>(theme: Theme<TParams>) => ThemeImpl;
+/**
+ * Create a custom theme containing core grid styles but no parts.
+ */
+export declare const createTheme: () => Theme<CoreParams>;
+type GridThemeUseArgs = {
+    loadThemeGoogleFonts: boolean | undefined;
+    container: HTMLElement;
+};
+export declare class ThemeImpl {
+    readonly parts: PartImpl[];
+    constructor(parts?: PartImpl[]);
+    withPart(part: Part | (() => Part)): ThemeImpl;
+    withoutPart(feature: string): ThemeImpl;
+    withParams(params: WithParamTypes<unknown>, mode?: string): ThemeImpl;
+    /**
+     * Called by a grid instance when it starts using the theme. This installs
+     * the theme's parts into document head, or the shadow DOM if the provided
+     * container is within a shadow root.
+     */
+    _startUse({ container, loadThemeGoogleFonts }: GridThemeUseArgs): void;
+    private _cssClassCache?;
+    /**
+     * Return CSS that that applies the params of this theme to elements with
+     * the provided class name
+     */
+    _getCssClass(this: ThemeImpl): string;
+    private _paramsCache?;
+    _getModeParams(): ModalParamValues;
+    private _paramsCssCache?;
+    /**
+     * Return the CSS chunk that is inserted into the grid DOM, and will
+     * therefore be removed automatically when the grid is destroyed or it
+     * starts to use a new theme.
+     *
+     * @param className a unique class name on the grid wrapper used to scope the returned CSS to the grid instance
+     */
+    _getPerGridCss(className: string): string;
+}
+type ParamValues = Record<string, unknown>;
+type ModalParamValues = {
+    [mode: string]: ParamValues;
+};
+export {};