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

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

@@ -0,0 +1,142 @@
+import { IGrid, IRenderer, IModelGenerator, NotifyArgs } from '../base/interface';
+import { Column } from '../models/column';
+import { HeaderRender } from './header-renderer';
+import { ContentRender } from './content-renderer';
+import { ServiceLocator } from '../services/service-locator';
+import { Row } from '../models/row';
+import { ColumnWidthService } from '../services/width-controller';
+import { freezeTable } from '../base/enum';
+/**
+ * Freeze module is used to render grid content with frozen rows and columns
+ *
+ * @hidden
+ */
+export declare class FreezeContentRender extends ContentRender implements IRenderer {
+    private frozenContent;
+    private movableContent;
+    private idx;
+    protected widthService: ColumnWidthService;
+    protected isInitialRender: boolean;
+    constructor(parent?: IGrid, locator?: ServiceLocator);
+    addEventListener(): void;
+    protected batchAdd(args: {
+        name: string;
+    }): void;
+    protected setHeightToContent(height: number): void;
+    protected actionComplete(args: NotifyArgs): void;
+    removeEventListener(): void;
+    renderPanel(): void;
+    renderFrozenRigthPanel(): void;
+    renderEmpty(tbody: HTMLElement): void;
+    protected renderFrozenRightEmpty(tbody: HTMLElement): void;
+    private setFrozenContent;
+    /**
+     * @param {Element} ele - specifies the element
+     * @returns {void}
+     * @hidden
+     */
+    setMovableContent(ele: Element): void;
+    getFrozenContent(): Element;
+    getMovableContent(): Element;
+    getModelGenerator(): IModelGenerator<Column>;
+    protected renderFrozenRightTable(): void;
+    renderTable(): void;
+    protected getScrollbarDisplay(): string;
+    protected renderHorizontalScrollbar(className: string, display: string, isRight?: boolean): void;
+    protected appendScrollbar(frozen: Element, movable: Element, isRight?: boolean): void;
+    private setScrollbarHeight;
+    /**
+     * @param {NotifyArgs} args - specifies the NotifyArgs
+     * @param {freezeTable} tableName - specifies the Freeze Table
+     * @returns {void}
+     * @hidden
+     */
+    setIsFrozen(args: NotifyArgs, tableName: freezeTable): void;
+    /**
+     * @param {Row<Column>[]} modelData - specifies the modeldata
+     * @param {NotifyArgs} args - specifies the args
+     * @returns {freezeTable} returns the freeze table
+     * @hidden
+     */
+    setTbody(modelData: Row<Column>[], args: NotifyArgs): freezeTable;
+    /**
+     * @param {string} tableName - specifies the table name
+     * @returns {void}
+     * @hidden
+     */
+    splitRows(tableName: string): void;
+    /**
+     * @param {NotifyArgs} args - specifies the notifyargs
+     * @param {string} tableName - specifies the tableName
+     * @returns {void}
+     * @hidden
+     */
+    renderNextFrozentPart(args: NotifyArgs, tableName: string): void;
+    appendContent(tbody: Element, frag: DocumentFragment | HTMLElement, args: NotifyArgs, tableName?: string): void;
+    refreshScrollOffset(): void;
+    /**
+     * @param {string} tableName - specifies the table name
+     * @returns {HTMLElement} returns the Html element
+     * @hidden
+     */
+    getFrozenHeader(tableName: string): HTMLElement;
+    protected refreshTbody(tbody: Element): void;
+    protected refreshHeight(): void;
+    private setIdx;
+    protected getIdx(): number;
+    /**
+     * @param {freezeTable} tableName - specifies the table name
+     * @returns {Element} returns the element
+     * @hidden
+     */
+    getTbody(tableName: freezeTable): Element;
+}
+export declare class FreezeRender extends HeaderRender implements IRenderer {
+    private frozenHeader;
+    private movableHeader;
+    private eventHandler;
+    constructor(parent?: IGrid, locator?: ServiceLocator);
+    addEventListener(): void;
+    removeEventListener(): void;
+    renderTable(): void;
+    renderPanel(): void;
+    renderFrozenRightPanel(): void;
+    renderFrozenRightTable(): void;
+    refreshUI(): void;
+    protected refreshFrozenLeftUI(): void;
+    protected rfshMovable(): void;
+    protected addMovableFirstCls(): void;
+    protected refreshFreeze(obj: {
+        case: string;
+        isModeChg?: boolean;
+    }): void;
+    protected refreshHeight(obj: {
+        case: string;
+        isModeChg?: boolean;
+    }): void;
+    private enableAfterRender;
+    private updateResizeHandler;
+    protected setWrapHeight(fRows: NodeListOf<HTMLElement>, mRows: NodeListOf<HTMLElement>, isModeChg: boolean, isContReset?: boolean, isStackedHdr?: boolean): void;
+    protected setFrozenHeight(height?: number): void;
+    protected refreshStackedHdrHgt(): void;
+    protected getRowSpan(row: Element): {
+        min: number;
+        max: number;
+    };
+    protected updateStackedHdrRowHgt(idx: number, maxRowSpan: number, row: Element, rows: NodeListOf<Element>): void;
+    private setFrozenHeader;
+    /**
+     * @param {Element} ele - specifies the element
+     * @returns {void}
+     * @hidden
+     */
+    setMovableHeader(ele: Element): void;
+    protected getFrozenHeader(): Element;
+    getMovableHeader(): Element;
+    /**
+     * @returns {void}
+     * @hidden
+     */
+    updateColgroup(): void;
+    protected filterRenderer(ele: Element, frozenColumn: number, total?: number): Element;
+}

package/src/grid/renderer/group-lazy-load-renderer.d.ts

@@ -0,0 +1,177 @@
+import { IRenderer, IGrid } from '../base/interface';
+import { ServiceLocator } from '../services/service-locator';
+import { ContentRender } from './content-renderer';
+import { Row } from '../models/row';
+import { Column } from '../models/column';
+/**
+ * GroupLazyLoadRenderer is used to perform lazy load grouping
+ *
+ * @hidden
+ */
+export declare class GroupLazyLoadRenderer extends ContentRender implements IRenderer {
+    private locator;
+    private groupGenerator;
+    private summaryModelGen;
+    private captionModelGen;
+    private rowRenderer;
+    constructor(parent: IGrid, locator?: ServiceLocator);
+    private childCount;
+    private scrollData;
+    private rowIndex;
+    private rowObjectIndex;
+    private isFirstChildRow;
+    private isScrollDown;
+    private isScrollUp;
+    private uid1;
+    private uid2;
+    private uid3;
+    private blockSize;
+    private groupCache;
+    private startIndexes;
+    private captionCounts;
+    private rowsByUid;
+    private objIdxByUid;
+    private initialGroupCaptions;
+    private requestType;
+    private scrollTopCache;
+    /** @hidden */
+    refRowsObj: {
+        [x: number]: Row<Column>[];
+    };
+    /** @hidden */
+    pageSize: number;
+    /** @hidden */
+    cacheMode: boolean;
+    /** @hidden */
+    cacheBlockSize: number;
+    /** @hidden */
+    ignoreAccent: boolean;
+    /** @hidden */
+    allowCaseSensitive: boolean;
+    private eventListener;
+    /**
+     * @param {HTMLTableRowElement} tr - specifies the table row element
+     * @returns {void}
+     * @hidden
+     */
+    captionExpand(tr: HTMLTableRowElement): void;
+    /**
+     * @param {HTMLTableRowElement} tr - specifies the table row element
+     * @returns {void}
+     * @hidden
+     */
+    captionCollapse(tr: HTMLTableRowElement): void;
+    /**
+     * @returns {void}
+     * @hidden */
+    setLazyLoadPageSize(): void;
+    /**
+     * @returns {void}
+     * @hidden */
+    clearLazyGroupCache(): void;
+    private clearCache;
+    private refreshCaches;
+    private getInitialCaptionIndexes;
+    /**
+     * @param {string} uid - specifies the uid
+     * @returns {number} returns the row object uid
+     * @hidden
+     */
+    getRowObjectIndexByUid(uid: string): number;
+    private collapseShortcut;
+    private getRowByUid;
+    private actionBegin;
+    private actionComplete;
+    private resetRowMaintenance;
+    private moveCells;
+    private removeRows;
+    private addClass;
+    private getNextChilds;
+    private lazyLoadHandler;
+    private setRowIndexes;
+    private getStartIndex;
+    private prevCaptionCount;
+    private setStartIndexes;
+    private hasLastChildRow;
+    private refreshCaptionRowCount;
+    private render;
+    /**
+     * @param {Row<Column>} row - specifies the row
+     * @param {number} index - specifies the index
+     * @returns {void}
+     * @hidden
+     */
+    maintainRows(row: Row<Column>, index?: number): void;
+    private confirmRowRendering;
+    private refreshRowObjects;
+    private getAggregateByCaptionIndex;
+    private getChildRowsByParentIndex;
+    /**
+     * @param {boolean} isReorder - specifies the isreorder
+     * @returns {Row<Column>[]} returns the row
+     * @hidden
+     */
+    initialGroupRows(isReorder?: boolean): Row<Column>[];
+    /**
+     * @returns {Row<Column>[]} retruns the row
+     * @hidden */
+    getRenderedRowsObject(): Row<Column>[];
+    private getCacheRowsOnDownScroll;
+    private getCacheRowsOnUpScroll;
+    private scrollHandler;
+    private scrollUpEndRowHandler;
+    private scrollDownHandler;
+    private getCurrentBlockEndIndex;
+    private removeBlock;
+    private scrollUpHandler;
+    private findRowElements;
+    private getRowElementByUid;
+    private removeTopRows;
+    private removeBottomRows;
+    private setCache;
+    private captionRowExpand;
+    private scrollReset;
+    private updateCurrentViewData;
+    /**
+     * @returns {Row<Column>[]} returns the row
+     * @hidden */
+    getGroupCache(): {
+        [x: number]: Row<Column>[];
+    };
+    /**
+     * @returns {Row<Column>[]} returns the row
+     * @hidden */
+    getRows(): Row<Column>[];
+    /**
+     * @returns {Element} returns the element
+     * @hidden */
+    getRowElements(): Element[];
+    /**
+     * @param {number} index - specifies the index
+     * @returns {Element} returns the element
+     * @hidden
+     */
+    getRowByIndex(index: number): Element;
+    /**
+     * Tucntion to set the column visibility
+     *
+     * @param {Column[]} columns - specifies the column
+     * @returns {void}
+     * @hidden
+     */
+    setVisible(columns?: Column[]): void;
+    /**
+     * Function to set display.
+     *
+     * @param {Object} tr - specifies the row object
+     * @param {number} idx - specifies the index
+     * @param {string} displayVal - specifies the display value
+     * @param {Row<Column>[]} rows - specifies the array of rows
+     * @param {number} oriIdx - specifies the index
+     * @returns {void}
+     * @hidden
+     */
+    setDisplayNone(tr: Object, idx: number, displayVal: string, rows: Row<Column>[], oriIdx?: number): void;
+    private changeCaptionRow;
+    private showAndHideCells;
+}

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

@@ -0,0 +1,54 @@
+import { Column } from '../models/column';
+import { Cell } from '../models/cell';
+import { ICellRenderer } from '../base/interface';
+import { CellRenderer } from './cell-renderer';
+/**
+ * HeaderCellRenderer class which responsible for building header cell content.
+ *
+ * @hidden
+ */
+export declare class HeaderCellRenderer extends CellRenderer implements ICellRenderer<Column> {
+    element: HTMLElement;
+    private ariaService;
+    private hTxtEle;
+    private sortEle;
+    private gui;
+    private chkAllBox;
+    /**
+     * Function to return the wrapper for the TH content.
+     *
+     * @returns {string | Element} returns the element
+     */
+    getGui(): string | Element;
+    /**
+     * Function to render the cell content based on Column object.
+     *
+     * @param {Cell} cell - specifies the column
+     * @param {Object} data - specifies the data
+     * @param {object} attributes - specifies the aattributes
+     * @returns {Element} returns the element
+     */
+    render(cell: Cell<Column>, data: Object, attributes?: {
+        [x: string]: Object;
+    }): Element;
+    /**
+     * Function to refresh the cell content based on Column object.
+     *
+     * @param  {Cell} cell - specifies the cell
+     * @param  {Element} node - specifies the noe
+     * @returns {Element} returns the element
+     */
+    refresh(cell: Cell<Column>, node: Element): Element;
+    private clean;
+    private prepareHeader;
+    getValue(field: string, column: Column): Object;
+    private extendPrepareHeader;
+    /**
+     * Function to specifies how the result content to be placed in the cell.
+     *
+     * @param  {Element} node - specifies the node
+     * @param  {string|Element} innerHtml - specifies the innerHtml
+     * @returns {Element} returns the element
+     */
+    appendHtml(node: Element, innerHtml: string | Element): Element;
+}

package/src/grid/renderer/header-indent-renderer.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';
+/**
+ * HeaderIndentCellRenderer class which responsible for building header indent cell.
+ *
+ * @hidden
+ */
+export declare class HeaderIndentCellRenderer extends CellRenderer implements ICellRenderer<Column> {
+    element: HTMLElement;
+    /**
+     * Function to render the 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/header-renderer.d.ts

@@ -0,0 +1,156 @@
+import { freezeTable } from '../base/enum';
+import { IRenderer, IGrid } from '../base/interface';
+import { Column } from '../models/column';
+import { Row } from '../models/row';
+import { ServiceLocator } from '../services/service-locator';
+import { Draggable } from '@syncfusion/ej2-base';
+import { ColumnWidthService } from '../services/width-controller';
+import { AriaService } from '../services/aria-service';
+/**
+ * Content module is used to render grid content
+ *
+ * @hidden
+ */
+export declare class HeaderRender implements IRenderer {
+    private headerTable;
+    private headerPanel;
+    private colgroup;
+    private caption;
+    protected colDepth: number;
+    private column;
+    protected rows: Row<Column>[];
+    private frzIdx;
+    private notfrzIdx;
+    private lockColsRendered;
+    freezeReorder: boolean;
+    draggable: Draggable;
+    private isFirstCol;
+    private isReplaceDragEle;
+    private helper;
+    private dragStart;
+    private drag;
+    private dragStop;
+    private drop;
+    protected parent: IGrid;
+    protected serviceLocator: ServiceLocator;
+    protected widthService: ColumnWidthService;
+    protected ariaService: AriaService;
+    /**
+     * Constructor for header renderer module
+     *
+     * @param {IGrid} parent - specifies the IGrid
+     * @param {ServiceLocator} serviceLocator - specifies the serviceLocator
+     */
+    constructor(parent?: IGrid, serviceLocator?: ServiceLocator);
+    /**
+     * The function is used to render grid header div
+     *
+     * @returns {void}
+     */
+    renderPanel(): void;
+    /**
+     * The function is used to render grid header div
+     *
+     * @returns {void}
+     */
+    renderTable(): void;
+    /**
+     * Get the header content div element of grid
+     *
+     * @returns {Element} returns the element
+     */
+    getPanel(): Element;
+    /**
+     * Set the header content div element of grid
+     *
+     * @param  {Element} panel - specifies the panel element
+     * @returns {void}
+     */
+    setPanel(panel: Element): void;
+    /**
+     * Get the header table element of grid
+     *
+     * @returns {Element} returns the element
+     */
+    getTable(): Element;
+    /**
+     * Set the header table element of grid
+     *
+     * @param  {Element} table - specifies the table element
+     * @returns {void}
+     */
+    setTable(table: Element): void;
+    /**
+     * Get the header colgroup element
+     *
+     * @returns {Element} returns the element
+     */
+    getColGroup(): Element;
+    /**
+     * Set the header colgroup element
+     *
+     * @param {Element} colGroup - specifies the colgroup
+     * @returns {Element} returns the element
+     */
+    setColGroup(colGroup: Element): Element;
+    /**
+     * Get the header row element collection.
+     *
+     * @returns {Element[]} returns the element
+     */
+    getRows(): Row<Column>[] | HTMLCollectionOf<HTMLTableRowElement>;
+    /**
+     * The function is used to create header table elements
+     *
+     * @returns {Element} returns the element
+     * @hidden
+     */
+    private createHeaderTable;
+    /**
+     * The function is used to create header table elements
+     *
+     * @param {Element} tableEle - specifies the table Element
+     * @param {freezeTable} tableName - specifies the table name
+     * @returns {Element} returns the element
+     * @hidden
+     */
+    createHeader(tableEle?: Element, tableName?: freezeTable): Element;
+    /**
+     * @param {Element} tableEle - specifies the column
+     * @returns {Element} returns the element
+     * @hidden
+     */
+    createTable(tableEle?: Element): Element;
+    private createHeaderContent;
+    private updateColGroup;
+    private ensureColumns;
+    private getHeaderCells;
+    private appendCells;
+    private ensureStackedFrozen;
+    private getStackedLockColsCount;
+    private getColSpan;
+    private getFrozenColSpan;
+    private generateRow;
+    private generateCell;
+    /**
+     * Function to hide header table column based on visible property
+     *
+     * @param {Column[]} columns - specifies the column
+     * @returns {void}
+     */
+    setVisible(columns?: Column[]): void;
+    private colPosRefresh;
+    /**
+     * Refresh the header of the Grid.
+     *
+     * @returns {void}
+     */
+    refreshUI(): void;
+    toggleStackClass(div: Element): void;
+    appendContent(table?: Element): void;
+    private getCellCnt;
+    protected initializeHeaderDrag(): void;
+    protected initializeHeaderDrop(): void;
+    private renderCustomToolbar;
+    private updateCustomResponsiveToolbar;
+}

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

@@ -0,0 +1,20 @@
+import { Cell } from '../models/cell';
+import { Column } from '../models/column';
+import { ICellRenderer } from '../base/interface';
+import { CellRenderer } from './cell-renderer';
+/**
+ * IndentCellRenderer class which responsible for building group indent cell.
+ *
+ * @hidden
+ */
+export declare class IndentCellRenderer extends CellRenderer implements ICellRenderer<Column> {
+    element: HTMLElement;
+    /**
+     * Function to render the 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/inline-edit-renderer.d.ts

@@ -0,0 +1,39 @@
+import { IGrid } from '../base/interface';
+/**
+ * Edit render module is used to render grid edit row.
+ *
+ * @hidden
+ */
+export declare class InlineEditRender {
+    private parent;
+    private isEdit;
+    /**
+     * Constructor for render module
+     *
+     * @param {IGrid} parent - returns the IGrid
+     */
+    constructor(parent?: IGrid);
+    addNew(elements: Object, args: {
+        row?: Element;
+        rowData?: Object;
+        isScroll?: boolean;
+    }): void;
+    private renderFrozenRightForm;
+    private renderMovableform;
+    private updateFreezeEdit;
+    private getFreezeRightRow;
+    private getFreezeRow;
+    update(elements: Object, args: {
+        row?: Element;
+        rowData?: Object;
+    }): void;
+    private refreshFreezeEdit;
+    private refreshEditForm;
+    private updateFrozenRightCont;
+    private updateFrozenCont;
+    private renderRightFrozen;
+    private renderMovable;
+    private getEditElement;
+    removeEventListener(): void;
+    private appendChildren;
+}

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

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

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

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

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

@@ -0,0 +1,30 @@
+import { IGrid, IFilterMUI, IFilterCreate } from '../base/interface';
+import { Column } from '../models/column';
+import { FilterSettings } from '../base/grid';
+import { ServiceLocator } from '../services/service-locator';
+import { Filter } from '../actions/filter';
+/**
+ * `numberfilterui` render number column.
+ *
+ * @hidden
+ */
+export declare class NumberFilterUI implements IFilterMUI {
+    private parent;
+    protected serviceLocator: ServiceLocator;
+    private instance;
+    private value;
+    private numericTxtObj;
+    private filterSettings;
+    private filter;
+    constructor(parent?: IGrid, serviceLocator?: ServiceLocator, filterSettings?: FilterSettings);
+    private keyEventHandler;
+    create(args: IFilterCreate): void;
+    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 destroy;
+}