@refinitiv-ui/efx-grid 6.0.0-next.0

package/lib/tr-grid-printer/es6/SectionWriter.js

@@ -0,0 +1,205 @@
+import { Ext } from "../../tr-grid-util/es6/Ext.js";
+import { ElementWrapper } from "../../tr-grid-util/es6/ElementWrapper.js";
+import { Table } from "../../tr-grid-util/es6/Table.js";
+import { CellWriter } from "./CellWriter.js";
+
+/**
+* @constructor
+* @extends {ElementWrapper}
+*/
+var SectionWriter = function () {
+	this._cellWriter = new CellWriter();
+	this._table = new Table();
+	this._columns = [];
+	this._elem = this._table.getElement();
+};
+Ext.inherits(SectionWriter, ElementWrapper);
+/** @type {!CellWriter}
+* @private
+*/
+SectionWriter.prototype._cellWriter;
+/** @type {!Table}
+* @private
+*/
+SectionWriter.prototype._table;
+
+/** @public
+* @return {number}
+*/
+SectionWriter.prototype.getFirstIndexInView = function () {
+	return 0;
+};
+
+/** @public
+* @return {number}
+*/
+SectionWriter.prototype.getLastIndexInView = function () {
+	return this._table.getRowCount();
+};
+
+/** @public
+* @return {number}
+*/
+SectionWriter.prototype.getColumnCount = function () {
+	return this._table.getColumnCount();
+};
+/** @public
+ * @param {number} colIndex
+* @return {*}
+*/
+SectionWriter.prototype.getColumn = function (colIndex) {
+	var col = this._columns[colIndex];
+	if (!col) {
+		col = this._columns[colIndex] = {};
+	}
+	return col;
+};
+/** @public
+* @param {number} val
+*/
+SectionWriter.prototype.setColumnCount = function (val) {
+	this._table.setColumnCount(val);
+};
+/** @public
+* @return {number}
+*/
+SectionWriter.prototype.getRowCount = function () {
+	return this._table.getRowCount();
+};
+/** @public
+* @param {number} val
+*/
+SectionWriter.prototype.setRowCount = function (val) {
+	this._table.setRowCount(val);
+};
+
+
+/**
+* @public
+* @param {number} colIndex
+* @param {number} rowIndex
+* @return {CellWriter}
+*/
+SectionWriter.prototype.getCell = function (colIndex, rowIndex) {
+	var cell = this._table.getCell(colIndex, rowIndex);
+	if(cell) {
+		this._cellWriter.cloak(cell);
+		return this._cellWriter;
+	}
+	return null;
+};
+/** @public
+* @param {number} colIndex
+* @param {number} rowIndex
+* @return {Element|Node|NodeList}
+*/
+SectionWriter.prototype.getCellContent = function (colIndex, rowIndex) {
+	var cell = this.getCell(colIndex, rowIndex);
+	return cell ? cell.getContent() : null;
+};
+/** Set data to the specified cell
+* @public
+* @param {number} colIndex
+* @param {number} rowIndex
+* @param {string|Element|tr.IElementControl|*} data this can be HTML element, string, number, date, image
+*/
+SectionWriter.prototype.setCellContent = function (colIndex, rowIndex, data) {
+	var cell = this.getCell(colIndex, rowIndex);
+	if(cell) {
+		cell.setContent(data);
+	}
+};
+/** Apply CSS class to each cell in the row
+* @public
+* @param {number} rowIndex
+* @param {string} className
+* @param {boolean} enabled
+* @see {@link tr.ILayoutGrid.#setRowStyle}
+*/
+SectionWriter.prototype.enableRowClass = function (rowIndex, className, enabled) { };
+
+/** This will make the specified cell horizontally span to fit entire row regardless of position of the cell -- cell will shift to the left most of the section.<br>
+* If opt_noLeftStretching is true, the cell will not extend to the left most position<br>
+* This is different from cell colSpan, which the cell remain in the same position. tr-stretched class will also be added to the cell
+* @public
+* @param {number} colIndex
+* @param {number} rowIndex
+* @param {boolean=} opt_stretching Default is true
+* @param {boolean=} opt_noLeftStretching Default is false (expand cell to the left).
+*/
+SectionWriter.prototype.stretchCell = function (colIndex, rowIndex, opt_stretching, opt_noLeftStretching) {
+	var cell = this._table.getCell(colIndex, rowIndex);
+	cell.setAttribute("colspan", this._table.getColumnCount());
+};
+/** {@link SectionWriter#stretchCell}
+* @public
+* @ignore
+* @param {number} colIndex
+* @param {number} rowIndex
+*/
+SectionWriter.prototype.unstretchCell = function (colIndex, rowIndex) {};
+
+/** @public
+* @return {boolean}
+*/
+SectionWriter.prototype.hasCellSpan = function () { return false; };
+/** @description Returns zero or negative value, if the cell is spanned over (i.e. occupied by the spanning cell). <br>
+* Negative value is distance from the spanning cell (i.e. -1 means one cell from the spanning cell and -2 means two cells from the spanning cell) <br>
+* Return one, if the cell has no span (normal cell). <br>
+* Return value greater than one, if the cell is spanning (getting expanded)
+* @public
+* @param {number} colIndex
+* @param {number} rowIndex
+* @return {number}
+*/
+SectionWriter.prototype.getCellRowSpan = function (colIndex, rowIndex) { return 1; };
+/** @public
+* @param {number} colIndex
+* @param {number} rowIndex
+* @param {number} rowSpan
+*/
+SectionWriter.prototype.setCellRowSpan = function (colIndex, rowIndex, rowSpan) { };
+/** @description Returns zero or negative value, if the cell is spanned over (i.e. occupied by the spanning cell). <br>
+* Negative value is distance from the spanning cell (i.e. -1 means one cell from the spanning cell and -2 means two cells from the spanning cell) <br>
+* Return one, if the cell has no span (normal cell). <br>
+* Return value greater than one, if the cell is spanning (getting expanded)
+* @public
+* @param {number} colIndex
+* @param {number} rowIndex
+* @return {number}
+*/
+SectionWriter.prototype.getCellColSpan = function (colIndex, rowIndex) { return 1; };
+/** @public
+* @param {number} colIndex
+* @param {number} rowIndex
+* @param {number} colSpan
+*/
+SectionWriter.prototype.setCellColSpan = function (colIndex, rowIndex, colSpan) { };
+/** @public
+*/
+SectionWriter.prototype.clearCellSpans = function () { };
+/** @public
+* @param {number} colIndex
+*/
+SectionWriter.prototype.clearColumnSpans = function (colIndex) { };
+
+/** @public
+* @param {number} colIndex
+* @return {boolean}
+*/
+SectionWriter.prototype.isColumnActive = function (colIndex) {
+	return true;
+};
+
+/**
+* @public
+* @param {number} colIndex
+* @param {number} rowIndex
+* @return {Element}
+*/
+SectionWriter.prototype.getCellElement = function (colIndex, rowIndex) {
+	return this._table.getCell(colIndex, rowIndex);
+};
+
+
+export { SectionWriter };

package/lib/tr-grid-printer/es6/index.d.ts

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

package/lib/tr-grid-printer/es6/index.js

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

package/lib/tr-grid-range-bar/es6/RangeBar.d.ts

@@ -0,0 +1,39 @@
+import {Ext} from '../../tr-grid-util/es6/Ext.js';
+import {GridPlugin} from '../../tr-grid-util/es6/GridPlugin.js';
+import {RangeBar} from '../../tr-grid-util/es6/RangeBar.js';
+import {Dom} from '../../tr-grid-util/es6/Dom.js';
+import {ElfUtil} from '../../tr-grid-util/es6/ElfUtil.js';
+
+declare namespace RangeBarPlugin {
+
+    type ColumnOptions = {
+        rangeBar?: RangeBarPlugin.RangeDefinition
+    };
+
+    type RangeDefinition = {
+        field?: string,
+        start?: number,
+        end?: number,
+        low?: string,
+        high?: string,
+        last?: string
+    };
+
+}
+
+declare class RangeBarPlugin extends GridPlugin {
+
+    constructor();
+
+    public initialize(host: any, options?: any): void;
+
+    public unload(host: any): void;
+
+    public config(options?: any): void;
+
+    public getConfigObject(out_obj?: any): any;
+
+}
+
+export default RangeBarPlugin;
+export { RangeBarPlugin, RangeBarPlugin as RangeBar, RangeBarPlugin as RangeBarExtension };

package/lib/tr-grid-range-bar/es6/RangeBar.js

@@ -0,0 +1,353 @@
+import { Ext } from '../../tr-grid-util/es6/Ext.js';
+import { GridPlugin } from '../../tr-grid-util/es6/GridPlugin.js';
+import { RangeBar } from '../../tr-grid-util/es6/RangeBar.js';
+import { Dom } from '../../tr-grid-util/es6/Dom.js';
+import { ElfUtil } from '../../tr-grid-util/es6/ElfUtil.js';
+/** @typedef {Object} RangeBarPlugin~ColumnOptions
+* @description Extension column options that can be specified on each individual grid's column option:
+* @property {RangeBarPlugin~RangeDefinition=} rangeBar Range definition object
+*/
+
+/** @typedef {Object|boolean} RangeBarPlugin~RangeDefinition
+* @description Available options describing `rangeBar` object specified in grid's column option
+* @property {string=} field=THIS_COLUMN Field used as percentage. If specified, `low`, `high`, and `last` fields will be ignored.
+* @property {number=} start=0 minimum value used with percentage `field`
+* @property {number=} end=100 maximum value used with percentage `field`
+* @property {string=} low="" Field used as minimum range
+* @property {string=} high="" Field used as maximum range
+* @property {string=} last="" Field used as current absolute value (white bar)
+*/
+
+/** @constructor
+* @extends {GridPlugin}
+*/
+
+var RangeBarPlugin = function RangeBarPlugin() {
+  this._onColumnAdded = this._onColumnAdded.bind(this);
+  this._onColumnRemoved = this._onColumnRemoved.bind(this);
+  this._renderer = this._renderer.bind(this);
+  this._onThemeLoaded = this._onThemeLoaded.bind(this);
+  this._hosts = [];
+};
+
+Ext.inherits(RangeBarPlugin, GridPlugin);
+/** @type {boolean}
+* @private
+*/
+
+RangeBarPlugin._themeLoaded = false;
+/** @type {boolean}
+* @private
+*/
+
+RangeBarPlugin.prototype._themeLoading = false;
+/** @type {number}
+* @private
+*/
+
+RangeBarPlugin.prototype._start = 0;
+/** @type {number}
+* @private
+*/
+
+RangeBarPlugin.prototype._end = 100;
+/** @override
+* @return {string}
+*/
+
+RangeBarPlugin.prototype.getName = function () {
+  return "RangeBarPlugin"; // Readonly
+};
+/** @public
+* @param {Object} host core grid object
+* @param {Object=} options
+*/
+
+
+RangeBarPlugin.prototype.initialize = function (host, options) {
+  if (this._hosts.indexOf(host) >= 0) {
+    return;
+  }
+
+  this._hosts.push(host);
+
+  this.config(options);
+  host.listen("columnAdded", this._onColumnAdded);
+  host.listen("columnRemoved", this._onColumnRemoved);
+
+  if (!RangeBarPlugin._themeLoaded && !this._themeLoading) {
+    this._themeLoading = true;
+    ElfUtil.getThemeColors().then(this._onThemeLoaded);
+  }
+};
+/** @override */
+
+
+RangeBarPlugin.prototype._afterInit = function () {
+  var colCount = this.getColumnCount();
+
+  for (var i = 0; i < colCount; ++i) {
+    this._setColumnRenderer(i);
+  }
+};
+/** @public
+* @param {Object} host core grid object
+*/
+
+
+RangeBarPlugin.prototype.unload = function (host) {
+  var at = this._hosts.indexOf(host);
+
+  if (at < 0) {
+    return;
+  }
+
+  this._hosts.splice(at, 1);
+
+  host.unlisten("columnAdded", this._onColumnAdded);
+  host.unlisten("columnRemoved", this._onColumnRemoved);
+
+  this._dispose();
+};
+/** @public
+* @param {Object=} options
+*/
+
+
+RangeBarPlugin.prototype.config = function (options) {
+  if (!options) {
+    return;
+  }
+
+  var columns = options["columns"];
+
+  if (!columns) {
+    return;
+  }
+
+  var len = columns.length;
+
+  for (var i = 0; i < len; ++i) {
+    this._setColumnRangeBar(i, columns[i]);
+  }
+};
+/** Get a current state of grid and extension config
+ * @public
+ * @param {Object=} out_obj
+ * @returns {!Object}
+ */
+
+
+RangeBarPlugin.prototype.getConfigObject = function (out_obj) {
+  var obj = out_obj || {};
+  var columns = obj.columns;
+
+  if (!columns) {
+    columns = obj.columns = [];
+  }
+
+  var len = this.getColumnCount();
+
+  for (var i = 0; i < len; ++i) {
+    var col = columns[i];
+
+    if (!col) {
+      col = columns[i] = {};
+    }
+
+    var opt = this._getColumnData(i);
+
+    if (!opt || !opt.rangeBar) {
+      continue;
+    }
+
+    var rangeBar = col.rangeBar = {};
+    opt = opt.rangeBar;
+
+    if (opt.field != null) {
+      rangeBar.field = opt.field;
+    }
+
+    if (opt.start != null) {
+      rangeBar.start = opt.start;
+    }
+
+    if (opt.end != null) {
+      rangeBar.end = opt.end;
+    }
+
+    if (opt.low != null) {
+      rangeBar.low = opt.low;
+    }
+
+    if (opt.high != null) {
+      rangeBar.high = opt.high;
+    }
+
+    if (opt.last != null) {
+      rangeBar.last = opt.last;
+    }
+  }
+
+  return obj;
+};
+/** @private
+* @param {number} colIndex
+* @param {RangeBarPlugin~ColumnOptions} columnOptions
+* @example
+* var colDef = {
+*   "rangeBar": {
+*     "low": "YRLOW",
+*     "high": "YRHIGH",
+*     "last": "CF_LAST"
+*   }
+* };
+*
+* var colDef = {
+*   "rangeBar": {
+*     "field": "PCT_CHNG",
+*     "start": 0,
+*     "end": 100
+*   }
+* };
+*
+* var colDef = {
+*   "rangeBar": true
+* };
+*/
+
+
+RangeBarPlugin.prototype._setColumnRangeBar = function (colIndex, columnOptions) {
+  var rDef = columnOptions["rangeBar"];
+
+  if (rDef) {
+    var colData = this._newColumnData(colIndex);
+
+    if (rDef === true || typeof rDef["field"] === "string") {
+      rDef = {
+        "field": rDef["field"] || columnOptions["field"],
+        "start": rDef["start"] || this._start,
+        "end": typeof rDef["end"] == "number" ? rDef["end"] : this._end
+      };
+    }
+
+    colData["rangeBar"] = rDef;
+
+    this._setColumnRenderer(colIndex);
+  }
+};
+/** @private
+* @param {number} colIndex
+*/
+
+
+RangeBarPlugin.prototype._setColumnRenderer = function (colIndex) {
+  var rangeBarOption = this._getColumnOption(colIndex, "rangeBar");
+
+  if (rangeBarOption && this._initializedGrid) {
+    if (this._realTimeGrid) {
+      this._realTimeGrid.setColumnRenderer(colIndex, this._renderer);
+    } else {
+      this._hosts[0].setColumnDataBindingHandler(colIndex, this._renderer);
+    }
+  }
+};
+/** @private
+* @param {number} colIndex
+* @return {RangeBarPlugin~RangeDefinition}
+*/
+
+
+RangeBarPlugin.prototype._getColumnRangeDef = function (colIndex) {
+  return this._getColumnOption(colIndex, "rangeBar");
+};
+/** @private */
+
+
+RangeBarPlugin.prototype._onThemeLoaded = function () {
+  RangeBarPlugin._themeLoaded = true;
+
+  for (var i = this._hosts.length; --i >= 0;) {
+    this._hosts[i].requestRowRefresh();
+  }
+};
+/** @private
+* @param {Object} e
+*/
+
+
+RangeBarPlugin.prototype._renderer = function (e) {
+  if (!RangeBarPlugin._themeLoaded) {
+    return;
+  }
+
+  var colIndex = e["colIndex"];
+
+  var rBarOpt = this._getColumnOption(colIndex, "rangeBar");
+
+  if (!rBarOpt) {
+    return;
+  }
+
+  var cell = e["cell"];
+  var content = cell.getContent();
+  var rangeBar;
+
+  if (content && content._rangeBar) {
+    rangeBar = content._rangeBar;
+  } else {
+    content = Dom.div();
+    rangeBar = content._rangeBar = new RangeBar(content);
+  }
+
+  var rowData = e["rowData"];
+  var low, high, last;
+
+  if (rBarOpt["field"]) {
+    low = rBarOpt["start"];
+    high = rBarOpt["end"];
+    last = rowData[rBarOpt["field"]];
+  } else {
+    low = rowData[rBarOpt["low"]];
+    high = rowData[rBarOpt["high"]];
+    last = rowData[rBarOpt["last"]];
+  }
+
+  rangeBar.setValue(low, last, high);
+  cell.setContent(content);
+};
+/** @private
+* @param {Object} e
+*/
+
+
+RangeBarPlugin.prototype._onColumnAdded = function (e) {
+  if (e["context"]) {
+    this._setColumnRangeBar(e["colIndex"], e["context"]);
+  }
+};
+/** @private
+* @param {Object} e
+*/
+
+
+RangeBarPlugin.prototype._onColumnRemoved = function (e) {
+  var colData =
+  /** @type{Object} */
+  e.columnData;
+
+  if (!colData) {
+    return;
+  }
+
+  var rDef = colData["rangeBar"];
+
+  if (!rDef) {
+    return;
+  }
+
+  colData["rangeBar"] = null;
+};
+
+export default RangeBarPlugin;
+export { RangeBarPlugin, RangeBarPlugin as RangeBar, RangeBarPlugin as RangeBarExtension };

package/lib/tr-grid-range-bar/es6/index.d.ts

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

package/lib/tr-grid-range-bar/es6/index.js

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

package/lib/tr-grid-row-dragging/es6/RowDragging.d.ts

@@ -0,0 +1,53 @@
+import { Ext } from "../../tr-grid-util/es6/Ext.js";
+import { cloneObject, injectCss, prettifyCss } from "../../tr-grid-util/es6/Util.js";
+import { ElfUtil } from "../../tr-grid-util/es6/ElfUtil.js";
+import { GridPlugin } from "../../tr-grid-util/es6/GridPlugin.js";
+import Dom from "../../tr-grid-util/es6/Dom.js";
+
+declare namespace RowDraggingPlugin {
+
+    type Options = {
+        dragBox?: boolean,
+        disabled?: boolean,
+        mouseInput?: boolean,
+        dataTransfer?: boolean,
+        autoScroll?: boolean,
+        dragBoxRenderer?: ((...params: any[]) => any),
+        dragStart?: ((...params: any[]) => any),
+        drag?: ((...params: any[]) => any),
+        dragEnd?: ((...params: any[]) => any),
+        dataMoved?: ((...params: any[]) => any)
+    };
+
+}
+
+declare class RowDraggingPlugin extends GridPlugin {
+
+    constructor(options?: RowDraggingPlugin.Options);
+
+    public beforeProcessOption(optionName: string, optionValue: any): any;
+
+    public hasMultiTableSupport(): boolean;
+
+    public getName(): string;
+
+    public initialize(host: any, options: any): void;
+
+    public unload(host: any): void;
+
+    public config(options?: any): void;
+
+    public getConfigObject(out_obj?: any): any;
+
+    public startDrag(startRef: any, opt_suppressEvent?: boolean): void;
+
+    public stopDrag(): void;
+
+    public cancelDrag(): void;
+
+    public getGuideline(): Element;
+
+}
+
+export default RowDraggingPlugin;
+export { RowDraggingPlugin, RowDraggingPlugin as RowDragging, RowDraggingPlugin as RowDraggingExtension };