@refinitiv-ui/efx-grid 0.0.0-dev.12023565035.1

package/lib/tr-grid-filter-input/es6/index.d.ts

@@ -0,0 +1 @@
+export * from "./FilterInput";

package/lib/tr-grid-filter-input/es6/index.js

@@ -0,0 +1 @@
+export * from "./FilterInput.js";

package/lib/tr-grid-heat-map/es6/HeatMap.d.ts

@@ -0,0 +1,45 @@
+import {Ext} from '../../tr-grid-util/es6/Ext.js';
+import {GridPlugin, colDataGetter} from '../../tr-grid-util/es6/GridPlugin.js';
+import {CellPainter} from '../../tr-grid-util/es6/CellPainter.js';
+import {ElfUtil} from '../../tr-grid-util/es6/ElfUtil.js';
+
+declare namespace HeatMapPlugin {
+
+    type ColumnOptions = {
+        field: string,
+        heatMap?: HeatMapPlugin.HeatMap|null
+    };
+
+    type HeatMap = {
+        midPoint?: number|null,
+        mode?: string|null
+    };
+
+}
+
+declare class HeatMapPlugin extends GridPlugin {
+
+    constructor();
+
+    public getName(): string;
+
+    public initialize(host: any, options?: any): void;
+
+    public unload(host: any): void;
+
+    public config(options?: any, opt_grid?: any): void;
+
+    public getConfigObject(out_obj?: any): any;
+
+    public getColumnHeatMap(colIndex: number, grid?: any): CellPainter|null;
+
+    public setColumnHeatMap(colIndex: number, columnDef: any, opt_grid?: any): void;
+
+    public getColumnHeatMapOptions(colIndex: number, options?: any): any;
+
+}
+
+declare function cond(colIndex: number, options?: any): any;
+
+export default HeatMapPlugin;
+export { HeatMapPlugin, HeatMapPlugin as HeatMap, HeatMapPlugin as HeatMapExtension };

package/lib/tr-grid-heat-map/es6/HeatMap.js

@@ -0,0 +1,401 @@
+import {Ext} from '../../tr-grid-util/es6/Ext.js';
+import {GridPlugin, colDataGetter} from '../../tr-grid-util/es6/GridPlugin.js';
+import {CellPainter} from '../../tr-grid-util/es6/CellPainter.js';
+import {ElfUtil} from '../../tr-grid-util/es6/ElfUtil.js';
+
+/** @typedef {Object} HeatMapPlugin~ColumnOptions
+* @description Extension column options that can be specified on each individual grid's column option:
+* @property {string} field Field used by the heat map
+* @property {HeatMapPlugin~HeatMap=} heatMap=null Heat map options
+*/
+
+/** @typedef {Object} HeatMapPlugin~HeatMap
+* @description Available options describing `heatMap` object
+* @property {number=} midPoint=0 Middle point between values representing up and down colors
+* @property {string=} mode="cell" In cell mode, heat map color will be applied to the entire cell
+*/
+
+/** @constructor
+* @extends {GridPlugin}
+*/
+let HeatMapPlugin = function () {
+	this._onSectionBinding = this._onSectionBinding.bind(this);
+	this._onColumnAdded = this._onColumnAdded.bind(this);
+	this._onColumnRemoved = this._onColumnRemoved.bind(this);
+	this._onThemeLoaded = this._onThemeLoaded.bind(this);
+
+	this._hosts = [];
+};
+Ext.inherits(HeatMapPlugin, GridPlugin);
+
+/** @type {number}
+* @private
+*/
+HeatMapPlugin._runningId = 0;
+/** @type {boolean}
+* @private
+*/
+HeatMapPlugin.prototype._themeLoading = false;
+
+/** @public
+* @return {string}
+*/
+HeatMapPlugin.prototype.getName = function () {
+	return "HeatMapPlugin"; // Read Only
+};
+
+/**
+* @override
+* @return {boolean}
+*/
+HeatMapPlugin.prototype.hasMultiTableSupport = function() {
+	return true;
+};
+
+/** @public
+* @param {Object} host core grid object
+* @param {Object=} options
+*/
+HeatMapPlugin.prototype.initialize = function (host, options) {
+	if(this._hosts.indexOf(host) >= 0) { return; }
+
+	this._hosts.push(host);
+
+	this.config(options, host);
+
+	host.listen("postSectionDataBinding", this._onSectionBinding);
+	host.listen("columnAdded", this._onColumnAdded);
+	host.listen("columnRemoved", this._onColumnRemoved);
+
+	if(!this._themeLoading) {
+		this._themeLoading = true;
+		CellPainter.loadThemeColors()
+			.then(this._onThemeLoaded)
+			.catch(this._onThemeLoaded);
+	}
+};
+/** @private
+*/
+HeatMapPlugin.prototype._afterInit = function () {
+	if(this._realTimeGrid) {
+		let colStats, painter;
+		let colCount = this.getColumnCount();
+		for(let c = 0; c < colCount; c++) {
+			painter = this.getColumnHeatMap(c);
+			if(painter) {
+				colStats = painter.getColumnStats();
+				if(colStats) {
+					colStats.setColumnDataGetter(colDataGetter);
+				}
+			}
+		}
+	}
+};
+/** @public
+* @param {Object} host core grid object
+*/
+HeatMapPlugin.prototype.unload = function (host) {
+	let at = this._hosts.indexOf(host);
+	if(at < 0) { return; }
+
+	this._hosts.splice(at, 1);
+
+	host.unlisten("postSectionDataBinding", this._onSectionBinding);
+	host.unlisten("columnAdded", this._onColumnAdded);
+	host.unlisten("columnRemoved", this._onColumnRemoved);
+
+	this._dispose();
+};
+
+/** @public
+* @param {Object=} options
+* @param {Object=} opt_grid core grid object
+*/
+HeatMapPlugin.prototype.config = function (options, opt_grid) {
+	if(!options) { return; }
+
+	let columns = options["columns"];
+	if(!columns) { return; }
+
+	let len = columns.length;
+	for(let i = 0; i < len; ++i) {
+		let column = columns[i];
+		this.setColumnHeatMap(i, column, opt_grid);
+	}
+};
+
+/** Get a current state of grid and extension config
+ * @public
+ * @param {Object=} out_obj
+ * @returns {!Object}
+ */
+HeatMapPlugin.prototype.getConfigObject = function (out_obj) {
+	let obj = out_obj || {};
+
+	let columns = obj.columns;
+	if (!columns) {
+		columns = obj.columns = [];
+	}
+
+	let len = this.getColumnCount();
+	for(let i = 0; i < len; ++i) {
+		let col = columns[i];
+		if (!col) {
+			col = columns[i] = {};
+		}
+
+
+		let opt = this.getColumnHeatMap(i);
+
+		if (!opt) { // We are only interested in the columns that have heat map informations
+			continue;
+		}
+
+		// default value of midPoint and mode
+		if(opt.midPoint === 0 && opt.mode === "cell") {
+			col.heatMap = true;
+			continue;
+		}
+
+		let heatMap = col.heatMap = {};
+
+		if (opt.midPoint != null) {
+			heatMap.midPoint = opt.midPoint;
+		}
+
+		if (opt.mode != null) {
+			heatMap.mode = opt.mode;
+		}
+	}
+
+	return obj;
+};
+
+/** @public
+* @param {number} colIndex
+* @param {Object=} grid core grid object
+* @return {CellPainter}
+*/
+HeatMapPlugin.prototype.getColumnHeatMap = function (colIndex, grid) {
+	let painter = this._getColumnOption(colIndex, "painter", grid);
+	if(painter && painter.getColoringType() === CellPainter.ColoringTypes.HEATMAP) {
+		return /** @type{CellPainter} */painter;
+	}
+	return null;
+};
+
+/** @public
+* @param {number} colIndex
+* @param {Object} columnDef
+* @param {Object=} opt_grid core grid object
+* @example
+* plugin.setColumnHeatMap(1, {
+*   "field": "CF_LAST",
+*   "heatMap": {
+*     "midPoint": 0, // optional number
+*     "mode": "cell" // optional string (cell|text)
+*   }
+* });
+*/
+HeatMapPlugin.prototype.setColumnHeatMap = function (colIndex, columnDef, opt_grid) {
+	let hmMode = "";
+	let midPoint = 0;
+	let field = columnDef ? /** @type{string} */(columnDef["field"]) : "";
+	let hmOptions = field ? columnDef["heatMap"] || columnDef["heatmap"] : null;
+	if(hmOptions) {
+		let userMode = hmOptions["mode"] || hmOptions["type"];
+		hmMode = (typeof userMode == "string") ? userMode : "cell";
+
+		let userMidPoint = /** @type{number} */(hmOptions["midPoint"]);
+		if(typeof userMidPoint != "number") {
+			userMidPoint = +userMidPoint;
+		}
+		midPoint = (userMidPoint) ? userMidPoint : 0;
+	}
+	if(opt_grid) {
+		this._setColumnHeatMap(opt_grid, colIndex, hmMode, midPoint, field);
+	} else {
+		for(let i = this._hosts.length; --i >= 0;) {
+			this._setColumnHeatMap(this._hosts[i], colIndex, hmMode, midPoint, field);
+		}
+	}
+};
+/** @private
+* @param {Object} grid core grid object
+* @param {number} colIndex
+* @param {string} hmMode
+* @param {number} midPoint
+* @param {string} field
+*/
+HeatMapPlugin.prototype._setColumnHeatMap = function (grid, colIndex, hmMode, midPoint, field) {
+	let dv = grid.getDataSource();
+	if(!dv) {
+		return;
+	}
+
+	let colData = this._newColumnData(colIndex);
+	let painter = /** @type{CellPainter} */(colData["painter"]);
+
+	let cond, sect, rowCount, r, cell;
+	if(hmMode && field) { // Update or create new painter for heatMap
+		if(painter) {
+			// Clear currrent style, blinking and existing styles related to blinking
+			sect = grid.getSection("content");
+			rowCount = sect.getRowCount();
+			for (r = 0; r < rowCount; ++r) {
+				cell = sect.getCell(colIndex, r, false);
+				if(cell) {
+					CellPainter.clearCellStyle(cell, CellPainter.bgStyles);
+				}
+			}
+
+			cond = painter.getConditions()[0];
+			if(cond) {
+				dv.enableColumnStats(cond.field, false, cond.refId);
+			}
+			painter.resetHeatMap(); // Release any used memory
+		} else {
+			painter = colData["painter"] = new CellPainter();
+		}
+
+		painter["midPoint"] = midPoint; // For saving
+		painter["mode"] = hmMode;
+
+		cond = painter.addHeatmapWithTheme(field, midPoint, (hmMode === "text"));
+		cond.refId = "_hm" + HeatMapPlugin._runningId++;
+
+		let colStats = dv.enableColumnStats(field, true, cond.refId);
+		if(this._initializedGrid && this._realTimeGrid) {
+			colStats.setColumnDataGetter(colDataGetter);
+		}
+		painter.setColumnStats(colStats);
+
+		grid.enableColumnClass(colIndex, "heat-map", true);
+		grid["requestRowRefresh"]();
+	} else {
+		if(painter) {
+			if(this._clearPainter(colData, grid)) {
+				// Clear existing heatMap styles
+				grid.enableColumnClass(colIndex, "heat-map", false);
+				sect = grid.getSection("content");
+				rowCount = sect.getRowCount();
+				for(r = 0; r < rowCount; ++r) {
+					cell = sect.getCell(colIndex, r, false);
+					if(cell) {
+						cell.setStyle("color", "");
+						cell.setStyle("backgroundColor", "");
+					}
+				}
+			}
+		}
+	}
+};
+/** @public
+* @param {number} colIndex
+* @param {Object=} options
+* @return {!Object}
+* @example
+* var obj = {
+*  "heatMap": {
+*    "midPoint": 0, // optional number
+*    "mode": "cell", // optional string
+*  }
+* };
+*/
+HeatMapPlugin.prototype.getColumnHeatMapOptions = function(colIndex, options) {
+	if(!options) { options = {}; }
+
+	let hm = this.getColumnHeatMap(colIndex);
+	if(hm) {
+		options["midPoint"] = hm["midPoint"];
+		options["mode"] = hm["mode"];
+	}
+	return options;
+};
+
+/** @private
+* @param {Object} colData
+* @param {Object=} grid core grid object
+* @return {boolean}
+*/
+HeatMapPlugin.prototype._clearPainter = function (colData, grid) {
+	if(colData) {
+		let painter = colData["painter"];
+		if(painter && painter.getColoringType() === CellPainter.ColoringTypes.HEATMAP) {
+			let cond = painter.getConditions()[0];
+			if(cond) {
+				let dv = grid.getDataSource();
+				dv.enableColumnStats(cond.field, false, cond.refId);
+			}
+			if(painter.clearHeatMap()) {
+				colData["painter"] = null;
+			}
+			return true;
+		}
+	}
+	return false;
+};
+/** @private */
+HeatMapPlugin.prototype._onThemeLoaded = function () {
+	for(let i = this._hosts.length; --i >= 0;) {
+		this._hosts[i].requestRowRefresh();
+	}
+};
+/** @private
+* @param {Object} e
+*/
+HeatMapPlugin.prototype._onSectionBinding = function (e) {
+	if(!ElfUtil.isThemeLoaded()) {
+		return;
+	}
+
+	let grid = e["sender"];
+	let section = e["section"];
+	let dataRows = /** @type{Array.<Object>} */(e["dataRows"]);
+	let colCount = section.getColumnCount();
+	let fromR = /** @type{number} */(e["fromRowIndex"]);
+	let toR = /** @type{number} */(e["toRowIndex"]);
+
+	for (let c = 0; c < colCount; ++c) {
+		let painter = this.getColumnHeatMap(c, grid);
+		if(painter) {
+			let columnStats = painter.getColumnStats();
+			let min = columnStats.getMin();
+			let max = columnStats.getMax();
+			for (let r = fromR; r < toR; ++r) {
+				let cell = section.getCell(c, r, false);
+				if(cell) {
+					painter.renderHeatMap(cell, this._getRowData(dataRows[r]), min, max);
+				}
+			}
+		}
+	}
+};
+/** @private
+* @param {Object} e
+*/
+HeatMapPlugin.prototype._onColumnAdded = function(e) {
+	if(e.context) {
+		this.setColumnHeatMap(e.colIndex, e.context, e.sender);
+		if(this._realTimeGrid) {
+			let painter = this.getColumnHeatMap(e.colIndex);
+			if(painter) {
+				let colStats = painter.getColumnStats();
+				if(colStats) {
+					colStats.setColumnDataGetter(colDataGetter);
+				}
+			}
+		}
+	}
+};
+/** @private
+* @param {Object} e
+*/
+HeatMapPlugin.prototype._onColumnRemoved = function(e) {
+	this._clearPainter(e.columnData, e.sender);
+};
+
+
+
+export default HeatMapPlugin;
+export { HeatMapPlugin, HeatMapPlugin as HeatMap, HeatMapPlugin as HeatMapExtension };

package/lib/tr-grid-heat-map/es6/index.d.ts

@@ -0,0 +1 @@
+export * from "./HeatMap";

package/lib/tr-grid-heat-map/es6/index.js

@@ -0,0 +1 @@
+export * from "./HeatMap.js";

package/lib/tr-grid-in-cell-editing/es6/InCellEditing.d.ts

@@ -0,0 +1,148 @@
+import { Ext } from "../../tr-grid-util/es6/Ext.js";
+import { GridPlugin } from "../../tr-grid-util/es6/GridPlugin.js";
+import { Dom } from "../../tr-grid-util/es6/Dom.js";
+import { Popup } from "../../tr-grid-util/es6/Popup.js";
+import { ElfUtil } from "../../tr-grid-util/es6/ElfUtil.js";
+import { isTouchDevice, injectCss, prettifyCss } from "../../tr-grid-util/es6/Util.js";
+import { ElfDate } from "../../tr-grid-util/es6/ElfDate.js";
+import { CoralItems } from "../../tr-grid-util/es6/CoralItems.js";
+import { Conflator } from "../../tr-grid-util/es6/Conflator.js";
+
+declare namespace InCellEditingPlugin {
+
+    type Options = {
+        balloonMode?: boolean|null,
+        editableTitle?: boolean|null,
+        editableContent?: boolean|null,
+        autoCommitText?: boolean|null,
+        dataBinding?: boolean|null,
+        popupElement?: Element|null,
+        doubleClick?: boolean|null,
+        tabToMove?: boolean|null,
+        contentSource?: string|null,
+        inlineStyling?: boolean|null,
+        disablingScroll?: boolean|null,
+        uiBlocking?: boolean|null,
+        preEditorOpening?: ((...params: any[]) => any)|null,
+        editorOpened?: ((...params: any[]) => any)|null,
+        beforeCommit?: ((...params: any[]) => any)|null,
+        editorClosed?: ((...params: any[]) => any)|null,
+        keyUp?: ((...params: any[]) => any)|null,
+        beforeRowCommit?: ((...params: any[]) => any)|null,
+        rowEditorClosed?: ((...params: any[]) => any)|null,
+        autoSuggest?: Element|null,
+        closingOnScroll?: boolean|null,
+        autoHiding?: boolean|null,
+        readonly?: boolean|null,
+        starterText?: (string|boolean)|null
+    };
+
+    type Cache = {
+        editor: Element|null,
+        balloonPopup: Element|null,
+        inputElement: Element|null
+    };
+
+    type EditorOptions = {
+        type?: string|null,
+        entries?: any[]|null,
+        attributes?: any
+    };
+
+    type ColumnOptions = {
+        editableContent?: boolean|null,
+        inCellEditing?: InCellEditingPlugin.EditorOptions|null
+    };
+
+}
+
+declare class InCellEditingPlugin extends GridPlugin {
+
+    constructor(options?: InCellEditingPlugin.Options|null);
+
+    public initialize(host: any, options: any): void;
+
+    public beforeProcessOption(optionName: string, optionVal: any): any;
+
+    public config(options?: any): void;
+
+    public getConfigObject(out_obj?: any): any;
+
+    public openEditor(colIndex: number, rowIndex: number, sectionRef?: any, grid?: any): void;
+
+    public closeCellEditor(opt_forceCommit?: boolean|null): void;
+
+    public enableBalloonMode(opt_enabled?: boolean|null): void;
+
+    public enableTitleEditing(opt_enabled?: boolean|null): void;
+
+    public disableTitleEditing(opt_disabled?: boolean|null): void;
+
+    public disableCellEditing(cell: any, opt_disabled?: boolean|null): void;
+
+    public disableDataBinding(opt_disabled?: boolean|null): void;
+
+    public disableDblClick(opt_disabled?: boolean|null): void;
+
+    public showStarterText(shown?: boolean|null): void;
+
+    public _requestUpdateStarterText(): void;
+
+    public updateStarterText(shown?: boolean|null): void;
+
+    public isEditing(): boolean;
+
+    public getTextBox(columnIndex?: number|null, grid?: any): Element|null;
+
+    public getInitialText(): string;
+
+    public _getRowIndex(rowId: string): number;
+
+    public getActiveColIndex(): number;
+
+    public getActiveRowIndex(): number;
+
+    public getInputElementPosition(): any;
+
+    public enableAutoCommitText(opt_enable?: boolean|null): void;
+
+    public isColumnEditable(colIndex: number): boolean;
+
+    public setColumnEditability(colIndex: number, bool?: (boolean|null)|null): void;
+
+    public enableReadonly(enabled?: boolean|null): void;
+
+    public disableReadonly(disabled?: boolean|null): void;
+
+    public openRowEditor(rowIndex: number, grid?: any): void;
+
+    public closeRowEditor(isCommit?: boolean|null): void;
+
+    public toggleRowEditor(rowIndex: number, isCommit?: boolean|null, grid?: any): void;
+
+    public setPopupElement(elm: Element|null): void;
+
+    public setText(content: any): void;
+
+    public getText(): string;
+
+    public getValue(): any;
+
+    public clearText(): void;
+
+    public appendText(word: string): void;
+
+    public commitText(word?: string|null): void;
+
+    public getBalloonPopup(): Popup|null|null;
+
+    public getAutoSuggest(): Element|null;
+
+    public setDisablingScroll(disabled?: boolean|null): boolean;
+
+    public requestShowEditorPopup(): void;
+
+}
+
+export default InCellEditingPlugin;
+export { InCellEditingPlugin, InCellEditingPlugin as InCellEditing, InCellEditingPlugin as InCellEditingExtension };