@syncfusion/ej2-grids 20.3.47-54738 → 20.3.47-54739

package/src/grid/renderer/numeric-edit-cell.d.ts

@@ -0,0 +1,27 @@
+import { IGrid, IEditCell } from '../base/interface';
+import { Column } from '../models/column';
+/**
+ * `NumericEditCell` is used to handle numeric cell type editing.
+ *
+ * @hidden
+ */
+export declare class NumericEditCell implements IEditCell {
+    private parent;
+    private obj;
+    private instances;
+    constructor(parent?: IGrid);
+    private keyEventHandler;
+    create(args: {
+        column: Column;
+        value: string;
+    }): Element;
+    read(element: Element): number;
+    write(args: {
+        rowData: Object;
+        element: Element;
+        column: Column;
+        row: HTMLElement;
+        requestType: string;
+    }): void;
+    destroy(): void;
+}

package/src/grid/renderer/render.d.ts

@@ -0,0 +1,104 @@
+import { IGrid, NotifyArgs } from '../base/interface';
+import { ReturnType } from '../base/type';
+import { Data } from '../actions/data';
+import { ServiceLocator } from '../services/service-locator';
+/**
+ * Content module is used to render grid content
+ *
+ * @hidden
+ */
+export declare class Render {
+    private isColTypeDef;
+    private parent;
+    private locator;
+    private headerRenderer;
+    private contentRenderer;
+    private l10n;
+    data: Data;
+    private ariaService;
+    private renderer;
+    private emptyGrid;
+    private isLayoutRendered;
+    private counter;
+    /**
+     * Constructor for render module
+     *
+     * @param {IGrid} parent - specifies the IGrid
+     * @param {ServiceLocator} locator - specifies the serviceLocator
+     */
+    constructor(parent?: IGrid, locator?: ServiceLocator);
+    /**
+     * To initialize grid header, content and footer rendering
+     *
+     * @returns {void}
+     */
+    render(): void;
+    /**
+     * Refresh the entire Grid.
+     *
+     * @param {NotifyArgs} e - specifies the NotifyArgs
+     * @returns {void}
+     */
+    refresh(e?: NotifyArgs): void;
+    /**
+     * @returns {void}
+     * @hidden
+     */
+    resetTemplates(): void;
+    private refreshComplete;
+    /**
+     * The function is used to refresh the dataManager
+     *
+     * @param {NotifyArgs} args - specifies the args
+     * @returns {void}
+     */
+    private refreshDataManager;
+    private getFData;
+    private isNeedForeignAction;
+    private foreignKey;
+    private sendBulkRequest;
+    private dmSuccess;
+    private dmFailure;
+    /**
+     * Render empty row to Grid which is used at the time to represent to no records.
+     *
+     * @returns {void}
+     * @hidden
+     */
+    renderEmptyRow(): void;
+    emptyRow(isTrigger?: boolean): void;
+    private dynamicColumnChange;
+    private updateColumnType;
+    /**
+     * @param {ReturnType} e - specifies the return type
+     * @param {NotifyArgs} args - specifies the Notifyargs
+     * @returns {void}
+     * @hidden
+     */
+    dataManagerSuccess(e: ReturnType, args?: NotifyArgs): void;
+    /**
+     * @param {object} e - specifies the object
+     * @param {Object[]} e.result - specifies the result
+     * @param {NotifyArgs} args - specifies the args
+     * @returns {void}
+     * @hidden
+     */
+    dataManagerFailure(e: {
+        result: Object[];
+    }, args: NotifyArgs): void;
+    private setRowCount;
+    private isInfiniteEnd;
+    private updatesOnInitialRender;
+    private iterateComplexColumns;
+    private buildColumns;
+    private instantiateRenderer;
+    private addEventListener;
+    /**
+     * @param {ReturnType} e - specifies the Return type
+     * @returns {Promise<Object>} returns the object
+     * @hidden
+     */
+    validateGroupRecords(e: ReturnType): Promise<Object>;
+    private getPredicate;
+    private updateGroupInfo;
+}

package/src/grid/renderer/responsive-dialog-renderer.d.ts

@@ -0,0 +1,84 @@
+import { IAction, IGrid, ResponsiveDialogArgs } from '../base/interface';
+import { ServiceLocator } from '../services/service-locator';
+import { Column } from '../models/column';
+import { ResponsiveDialogAction } from '../base/enum';
+/**
+ *
+ * The `ResponsiveDialogRenderer` module is used to render the responsive dialogs.
+ */
+export declare class ResponsiveDialogRenderer implements IAction {
+    private parent;
+    private serviceLocator;
+    private customResponsiveDlg;
+    private customFilterDlg;
+    private customColumnDiv;
+    private filterParent;
+    private customExcelFilterParent;
+    private sortedCols;
+    private isSortApplied;
+    private filterClearBtn;
+    private saveBtn;
+    private backBtn;
+    private sortPredicate;
+    private filteredCol;
+    private isCustomDlgRender;
+    private isFiltered;
+    private isRowResponsive;
+    private isDialogClose;
+    private onActionCompleteFn;
+    private evtHandlers;
+    /** @hidden */
+    action: ResponsiveDialogAction;
+    /** @hidden */
+    isCustomDialog: boolean;
+    constructor(parent?: IGrid, serviceLocator?: ServiceLocator);
+    addEventListener(): void;
+    private customExFilterClose;
+    private renderCustomFilterDiv;
+    private renderResponsiveContextMenu;
+    private refreshCustomFilterClearBtn;
+    private refreshCustomFilterOkBtn;
+    private renderResponsiveContent;
+    private getSortedFieldsAndDirections;
+    private sortButtonClickHandler;
+    private resetSortButtons;
+    private setSortedCols;
+    private getCurrentSortedFields;
+    private customFilterColumnClickHandler;
+    /**
+     * Function to show the responsive dialog
+     *
+     * @param {Column} col - specifies the column
+     * @returns {void}
+     */
+    showResponsiveDialog(col?: Column): void;
+    private setTopToChildDialog;
+    private renderCustomFilterDialog;
+    private getDialogOptions;
+    private renderResponsiveDialog;
+    private dialogCreated;
+    private dialogOpen;
+    private beforeDialogClose;
+    private sortColumn;
+    private getHeaderTitle;
+    private getDialogName;
+    private getButtonText;
+    /**
+     * Function to render the responsive header
+     *
+     * @param {Column} col - specifies the column
+     * @param {ResponsiveDialogArgs} args - specifies the responsive dialog arguments
+     * @param {boolean} isCustomFilter - specifies whether it is custom filter or not
+     * @returns {HTMLElement | string} returns the html element or string
+     */
+    renderResponsiveHeader(col: Column, args?: ResponsiveDialogArgs, isCustomFilter?: boolean): HTMLElement | string;
+    private filterClear;
+    private dialogHdrBtnClickHandler;
+    private closeCustomDialog;
+    private destroyCustomFilterDialog;
+    private closeCustomFilter;
+    private removeCustomDlgFilterEle;
+    private keyHandler;
+    private editComplate;
+    removeEventListener(): void;
+}

package/src/grid/renderer/row-drag-drop-renderer.d.ts

@@ -0,0 +1,20 @@
+import { ICellRenderer } from '../base/interface';
+import { CellRenderer } from './cell-renderer';
+import { Column } from '../models/column';
+import { Cell } from '../models/cell';
+/**
+ * ExpandCellRenderer class which responsible for building group expand cell.
+ *
+ * @hidden
+ */
+export declare class RowDragDropRenderer extends CellRenderer implements ICellRenderer<Column> {
+    element: HTMLElement;
+    /**
+     * Function to render the detail expand cell
+     *
+     * @param {Cell<Column>} cell - specifies the cell
+     * @param {Object} data - specifies the data
+     * @returns {Element} returns the element
+     */
+    render(cell: Cell<Column>, data: Object): Element;
+}

package/src/grid/renderer/row-drag-header-indent-render.d.ts

@@ -0,0 +1,20 @@
+import { Cell } from '../models/cell';
+import { ICellRenderer } from '../base/interface';
+import { CellRenderer } from './cell-renderer';
+import { Column } from '../models/column';
+/**
+ * DetailHeaderIndentCellRenderer class which responsible for building detail header indent cell.
+ *
+ * @hidden
+ */
+export declare class RowDragDropHeaderRenderer extends CellRenderer implements ICellRenderer<Column> {
+    element: HTMLElement;
+    /**
+     * Function to render the detail indent cell
+     *
+     * @param  {Cell} cell - specifies the cell
+     * @param  {Object} data - specifies the data
+     * @returns {Element} returns the element
+     */
+    render(cell: Cell<Column>, data: Object): Element;
+}

package/src/grid/renderer/row-renderer.d.ts

@@ -0,0 +1,55 @@
+import { Column } from '../models/column';
+import { Row } from '../models/row';
+import { IRowRenderer, IGrid } from '../base/interface';
+import { CellType } from '../base/enum';
+import { ServiceLocator } from '../services/service-locator';
+/**
+ * RowRenderer class which responsible for building row content.
+ *
+ * @hidden
+ */
+export declare class RowRenderer<T> implements IRowRenderer<T> {
+    element: Element;
+    private cellRenderer;
+    private serviceLocator;
+    private cellType;
+    private isSpan;
+    protected parent: IGrid;
+    constructor(serviceLocator?: ServiceLocator, cellType?: CellType, parent?: IGrid);
+    /**
+     * Function to render the row content based on Column[] and data.
+     *
+     * @param {Row<T>} row - specifies the row
+     * @param {Column[]} columns - specifies the columns
+     * @param {Object} attributes - specifies the attributes
+     * @param {string} rowTemplate - specifies the rowTemplate
+     * @param {Element} cloneNode - specifies the cloneNode
+     * @returns {Element} returns the element
+     */
+    render(row: Row<T>, columns: Column[], attributes?: {
+        [x: string]: Object;
+    }, rowTemplate?: string, cloneNode?: Element): Element;
+    /**
+     * Function to refresh the row content based on Column[] and data.
+     *
+     * @param {Row<T>} row - specifies the row
+     * @param {Column[]} columns - specifies the column
+     * @param {boolean} isChanged - specifies isChanged
+     * @param {Object} attributes - specifies the attributes
+     * @param {string} rowTemplate - specifies the rowTemplate
+     * @returns {void}
+     */
+    refresh(row: Row<T>, columns: Column[], isChanged: boolean, attributes?: {
+        [x: string]: Object;
+    }, rowTemplate?: string): void;
+    private refreshRow;
+    private refreshMergeCells;
+    /**
+     * Function to check and add alternative row css class.
+     *
+     * @param {Element} tr - specifies the tr element
+     * @param {Row<T>} row - specifies the row
+     * @returns {void}
+     */
+    buildAttributeFromRow(tr: Element, row: Row<T>): void;
+}

package/src/grid/renderer/stacked-cell-renderer.d.ts

@@ -0,0 +1,23 @@
+import { Column } from '../models/column';
+import { Cell } from '../models/cell';
+import { ICellRenderer } from '../base/interface';
+import { CellRenderer } from './cell-renderer';
+/**
+ * StackedHeaderCellRenderer class which responsible for building stacked header cell content.
+ *
+ * @hidden
+ */
+export declare class StackedHeaderCellRenderer extends CellRenderer implements ICellRenderer<Column> {
+    element: HTMLElement;
+    /**
+     * Function to render the cell content based on Column object.
+     *
+     * @param {Cell<Column>} cell - specifies the cell
+     * @param {Object} data - specifies the data
+     * @param {object} attributes - specifies the attributes
+     * @returns {Element} returns the element
+     */
+    render(cell: Cell<Column>, data: Object, attributes?: {
+        [x: string]: Object;
+    }): Element;
+}

package/src/grid/renderer/string-filter-ui.d.ts

@@ -0,0 +1,39 @@
+import { IGrid, IFilterMUI, IFilterCreate } from '../base/interface';
+import { Column } from '../models/column';
+import { FilterSettings } from '../base/grid';
+import { AutoComplete } from '@syncfusion/ej2-dropdowns';
+import { ServiceLocator } from '../services/service-locator';
+import { Filter } from '../actions/filter';
+/**
+ * `string filterui` render string column.
+ *
+ * @hidden
+ */
+export declare class StringFilterUI implements IFilterMUI {
+    private parent;
+    protected serLocator: ServiceLocator;
+    private instance;
+    private value;
+    actObj: AutoComplete;
+    private filterSettings;
+    private filter;
+    private dialogObj;
+    private acOpen;
+    private acFocus;
+    private acComplete;
+    constructor(parent?: IGrid, serviceLocator?: ServiceLocator, filterSettings?: FilterSettings);
+    create(args: IFilterCreate): void;
+    private processDataOperation;
+    private getAutoCompleteOptions;
+    write(args: {
+        column: Column;
+        target: Element;
+        parent: IGrid;
+        filteredValue: number | string | Date | boolean;
+    }): void;
+    read(element: Element, column: Column, filterOptr: string, filterObj: Filter): void;
+    private openPopup;
+    private focus;
+    private actionComplete;
+    private destroy;
+}

package/src/grid/renderer/summary-cell-renderer.d.ts

@@ -0,0 +1,15 @@
+import { AggregateColumnModel } from '../models/models';
+import { Cell } from '../models/cell';
+import { ICellRenderer } from '../base/interface';
+import { CellRenderer } from './cell-renderer';
+/**
+ * SummaryCellRenderer class which responsible for building summary cell content.
+ *
+ * @hidden
+ */
+export declare class SummaryCellRenderer extends CellRenderer implements ICellRenderer<AggregateColumnModel> {
+    element: HTMLElement;
+    getValue(field: string, data: Object, column: AggregateColumnModel): Object;
+    evaluate(node: Element, cell: Cell<AggregateColumnModel>, data: Object, attributes?: Object): boolean;
+    refreshWithAggregate(node: Element, cell: Cell<AggregateColumnModel>): Function;
+}

package/src/grid/renderer/template-edit-cell.d.ts

@@ -0,0 +1,13 @@
+import { IEditCell, IGrid } from '../base/interface';
+/**
+ * `TemplateEditCell` is used to handle template cell.
+ *
+ * @hidden
+ */
+export declare class TemplateEditCell implements IEditCell {
+    private parent;
+    constructor(parent?: IGrid);
+    read(element: Element, value: string): string;
+    write(): void;
+    destroy(): void;
+}

package/src/grid/renderer/timepicker-edit-cell.d.ts

@@ -0,0 +1,18 @@
+import { Column } from '../models/column';
+import { IEditCell } from '../base/interface';
+import { EditCellBase } from './edit-cell-base';
+/**
+ * `TimePickerEditCell` is used to handle Timepicker cell type editing.
+ *
+ * @hidden
+ */
+export declare class TimePickerEditCell extends EditCellBase implements IEditCell {
+    write(args: {
+        rowData: Object;
+        element: Element;
+        column: Column;
+        type: string;
+        row: HTMLElement;
+        requestType: string;
+    }): void;
+}

package/src/grid/renderer/toggleswitch-edit-cell.d.ts

@@ -0,0 +1,27 @@
+import { IEditCell } from '../base/interface';
+import { Column } from '../models/column';
+import { EditCellBase } from './edit-cell-base';
+/**
+ * `ToggleEditCell` is used to handle boolean cell type editing.
+ *
+ * @hidden
+ */
+export declare class ToggleEditCell extends EditCellBase implements IEditCell {
+    private editRow;
+    private editType;
+    private activeClasses;
+    create(args: {
+        column: Column;
+        value: string;
+        type: string;
+    }): Element;
+    read(element: Element): boolean;
+    write(args: {
+        rowData: Object;
+        element: Element;
+        column: Column;
+        requestType: string;
+        row: Element;
+    }): void;
+    private switchModeChange;
+}

package/src/grid/renderer/virtual-content-renderer.d.ts

@@ -0,0 +1,221 @@
+import { IGrid, IRenderer, NotifyArgs, VirtualInfo, IModelGenerator } from '../base/interface';
+import { Column } from '../models/column';
+import { Row } from '../models/row';
+import { ContentRender } from './content-renderer';
+import { HeaderRender } from './header-renderer';
+import { ServiceLocator } from '../services/service-locator';
+import { InterSectionObserver } from '../services/intersection-observer';
+import { VirtualRowModelGenerator } from '../services/virtual-row-model-generator';
+/**
+ * VirtualContentRenderer
+ *
+ * @hidden
+ */
+export declare class VirtualContentRenderer extends ContentRender implements IRenderer {
+    private count;
+    private maxPage;
+    private maxBlock;
+    private prevHeight;
+    /** @hidden */
+    observer: InterSectionObserver;
+    /**
+     * @hidden
+     */
+    vgenerator: VirtualRowModelGenerator;
+    /** @hidden */
+    header: VirtualHeaderRenderer;
+    /** @hidden */
+    startIndex: number;
+    private preStartIndex;
+    private preEndIndex;
+    /** @hidden */
+    startColIndex: number;
+    /** @hidden */
+    endColIndex: number;
+    private locator;
+    private preventEvent;
+    private actions;
+    /** @hidden */
+    content: HTMLElement;
+    /** @hidden */
+    movableContent: HTMLElement;
+    /** @hidden */
+    offsets: {
+        [x: number]: number;
+    };
+    private tmpOffsets;
+    /** @hidden */
+    virtualEle: VirtualElementHandler;
+    private offsetKeys;
+    private isFocused;
+    private isSelection;
+    private selectedRowIndex;
+    private isBottom;
+    private rndrCount;
+    /** @hidden */
+    activeKey: string;
+    /** @hidden */
+    rowIndex: number;
+    /** @hidden */
+    blzRowIndex: number;
+    /** @hidden */
+    blazorDataLoad: boolean;
+    private cellIndex;
+    private empty;
+    private isAdd;
+    private isCancel;
+    /** @hidden */
+    requestType: string;
+    private editedRowIndex;
+    private requestTypes;
+    private isNormaledit;
+    /** @hidden */
+    virtualData: Object;
+    private emptyRowData;
+    private vfColIndex;
+    private frzIdx;
+    private initialRowTop;
+    private isContextMenuOpen;
+    private selectRowIndex;
+    private isSelectionScroll;
+    private validationCheck;
+    private validationCol;
+    constructor(parent: IGrid, locator?: ServiceLocator);
+    renderTable(): void;
+    renderEmpty(tbody: HTMLElement): void;
+    getReorderedFrozenRows(args: NotifyArgs): Row<Column>[];
+    private scrollListener;
+    private block;
+    private getInfoFromView;
+    private setKeyboardNavIndex;
+    ensureBlocks(info: VirtualInfo): number[];
+    appendContent(target: HTMLElement, newChild: DocumentFragment | HTMLElement, e: NotifyArgs): void;
+    private validationScrollLeft;
+    private ensureSelectedRowPosition;
+    private checkFirstBlockColIndexes;
+    private focusCell;
+    private restoreEdit;
+    private getVirtualEditedData;
+    private restoreAdd;
+    protected onDataReady(e?: NotifyArgs): void;
+    /**
+     * @param {number} height - specifies the height
+     * @returns {void}
+     * @hidden
+     */
+    setVirtualHeight(height?: number): void;
+    private getPageFromTop;
+    protected getTranslateY(sTop: number, cHeight: number, info?: VirtualInfo, isOnenter?: boolean): number;
+    getOffset(block: number): number;
+    private onEntered;
+    private dataBound;
+    private rowSelected;
+    private isLastBlockRow;
+    private refreshMaxPage;
+    private setVirtualPageQuery;
+    eventListener(action: string): void;
+    private scrollToEdit;
+    private refreshCells;
+    private resetVirtualFocus;
+    /**
+     * @param {Object} data - specifies the data
+     * @param {Object} data.virtualData -specifies the data
+     * @param {boolean} data.isAdd - specifies isAdd
+     * @param {boolean} data.isCancel - specifies boolean in cancel
+     * @param {boolean} data.isScroll - specifies boolean for scroll
+     * @returns {void}
+     * @hidden
+     */
+    getVirtualData(data: {
+        virtualData: Object;
+        isAdd: boolean;
+        isCancel: boolean;
+        isScroll: boolean;
+    }): void;
+    private selectRowOnContextOpen;
+    private editCancel;
+    private editSuccess;
+    private updateCurrentViewData;
+    private actionBegin;
+    private virtualCellFocus;
+    private editActionBegin;
+    private getEditedRowObject;
+    private refreshCache;
+    private actionComplete;
+    private resetIsedit;
+    private scrollAfterEdit;
+    private createEmptyRowdata;
+    private addActionBegin;
+    /**
+     * @param {number} index - specifies the index
+     * @returns {Object} returns the object
+     * @hidden
+     */
+    getRowObjectByIndex(index: number): Object;
+    getBlockSize(): number;
+    getBlockHeight(): number;
+    isEndBlock(index: number): boolean;
+    getGroupedTotalBlocks(): number;
+    getTotalBlocks(): number;
+    getColumnOffset(block: number): number;
+    getModelGenerator(): IModelGenerator<Column>;
+    private resetScrollPosition;
+    private onActionBegin;
+    getRows(): Row<Column>[];
+    getRowByIndex(index: number): Element;
+    getMovableVirtualRowByIndex(index: number): Element;
+    getFrozenRightVirtualRowByIndex(index: number): Element;
+    getRowCollection(index: number, isMovable: boolean, isRowObject?: boolean, isFrozenRight?: boolean): Element | Object;
+    getVirtualRowIndex(index: number): number;
+    /**
+     * @returns {void}
+     * @hidden */
+    refreshOffsets(): void;
+    refreshVirtualElement(): void;
+    setVisible(columns?: Column[]): void;
+    private selectVirtualRow;
+    private isRowInView;
+}
+/**
+ * @hidden
+ */
+export declare class VirtualHeaderRenderer extends HeaderRender implements IRenderer {
+    virtualEle: VirtualElementHandler;
+    /** @hidden */
+    gen: VirtualRowModelGenerator;
+    movableTbl: Element;
+    private isMovable;
+    constructor(parent: IGrid, locator: ServiceLocator);
+    renderTable(): void;
+    appendContent(table: Element): void;
+    refreshUI(): void;
+    setVisible(columns?: Column[]): void;
+    private setFrozenTable;
+    private setDisplayNone;
+}
+/**
+ * @hidden
+ */
+export declare class VirtualElementHandler {
+    wrapper: HTMLElement;
+    placeholder: HTMLElement;
+    content: HTMLElement;
+    table: HTMLElement;
+    movableWrapper: HTMLElement;
+    movablePlaceholder: HTMLElement;
+    movableTable: HTMLElement;
+    movableContent: HTMLElement;
+    renderWrapper(height?: number): void;
+    renderPlaceHolder(position?: string): void;
+    renderFrozenWrapper(height?: number): void;
+    renderFrozenPlaceHolder(): void;
+    renderMovableWrapper(height?: number): void;
+    renderMovablePlaceHolder(): void;
+    adjustTable(xValue: number, yValue: number): void;
+    adjustMovableTable(xValue: number, yValue: number): void;
+    setMovableWrapperWidth(width: string, full?: boolean): void;
+    setMovableVirtualHeight(height?: number, width?: string): void;
+    setWrapperWidth(width: string, full?: boolean): void;
+    setVirtualHeight(height?: number, width?: string): void;
+    setFreezeWrapperWidth(wrapper: HTMLElement, width: string, full?: boolean): void;
+}