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

package/lib/tr-grid-conditional-coloring/es6/index.d.ts

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

package/lib/tr-grid-conditional-coloring/es6/index.js

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

package/lib/tr-grid-content-wrap/es6/ContentWrap.d.ts

@@ -0,0 +1,43 @@
+import {Ext} from '../../tr-grid-util/es6/Ext.js';
+import { GridPlugin } from '../../tr-grid-util/es6/GridPlugin.js';
+
+declare namespace ContentWrapPlugin {
+
+    type Options = {
+        evenRowHeight?: boolean
+    };
+
+    type ColumnOptions = {
+        contentWrap?: boolean
+    };
+
+}
+
+declare class ContentWrapPlugin extends GridPlugin {
+
+    constructor();
+
+    public beforeProcessOption(optionName: string): any;
+
+    public getName(): string;
+
+    public initialize(host: any, options?: any): void;
+
+    public unload(host: any): void;
+
+    public config(options?: any): void;
+
+    public getConfigObject(gridOptions?: any): any;
+
+    public adjustRowHeight(sectionRef: any, from?: number, to?: number): boolean;
+
+    public adjustRowHeightAt(sectionRef: any, rowIndex: number): boolean;
+
+    public enableContentWrapping(colIndex: number, bool?: boolean): void;
+
+    public isWrappingContent(colIndex: number): boolean;
+
+}
+
+export default ContentWrapPlugin;
+export { ContentWrapPlugin, ContentWrapPlugin as ContentWrap, ContentWrapPlugin as ContentWrapExtension };

package/lib/tr-grid-content-wrap/es6/ContentWrap.js

@@ -0,0 +1,478 @@
+import { Ext } from '../../tr-grid-util/es6/Ext.js';
+import { GridPlugin } from '../../tr-grid-util/es6/GridPlugin.js';
+/** @typedef {Object} ContentWrapPlugin~Options
+* @description The options can be specified by `contentWrap` property of the main grid's options
+* @property {boolean=} evenRowHeight=false If enabled, max row height will be applied for all the rows
+*/
+
+/** @typedef {Object} ContentWrapPlugin~ColumnOptions
+* @description Extension column options that can be specified on each individual grid's column option:
+* @property {boolean=} contentWrap=false Content wrapping flag. If enabled, the column will be counted toward row height calculation.
+*/
+
+/** @constructor
+* @extends {GridPlugin}
+*/
+
+var ContentWrapPlugin = function ContentWrapPlugin() {
+  this._onColumnAdded = this._onColumnAdded.bind(this);
+  this._onRecalculation = this._onRecalculation.bind(this);
+  this._setReCalculationTimer = this._setReCalculationTimer.bind(this);
+  this._hosts = [];
+};
+
+Ext.inherits(ContentWrapPlugin, GridPlugin);
+/** @type {boolean}
+* @private
+*/
+
+ContentWrapPlugin.prototype._adjusting = false;
+/** @type {number}
+* @private
+*/
+
+ContentWrapPlugin.prototype._freezingThreshold = 10;
+/** @type {number}
+* @private
+*/
+
+ContentWrapPlugin.prototype._recalTimer = 0;
+/** @type {boolean}
+* @private
+*/
+
+ContentWrapPlugin.prototype._evenRowHeight = false;
+/** Grid parameter support
+* @public
+* @param {string} optionName
+* @return {*}
+*/
+
+ContentWrapPlugin.prototype.beforeProcessOption = function (optionName) {
+  if (optionName === "rowVirtualRendering") {
+    // Content can be virtually rendered
+    return false; // eslint-disable-line
+  }
+
+  return; // eslint-disable-line
+};
+/** @public
+* @return {string}
+*/
+
+
+ContentWrapPlugin.prototype.getName = function () {
+  return "ContentWrapPlugin"; // Read Only
+};
+/** @public
+* @param {Object} host core grid object
+* @param {Object=} options
+*/
+
+
+ContentWrapPlugin.prototype.initialize = function (host, options) {
+  if (this._hosts.indexOf(host) >= 0) {
+    return;
+  }
+
+  this._hosts.push(host);
+
+  window.addEventListener("load", this._setReCalculationTimer); // Since CSS can impact font, we need adjust accordingly
+
+  host.listen("widthChanged", this._setReCalculationTimer);
+  host.listen("postSectionDataBinding", this._setReCalculationTimer);
+
+  if (host["disableLazyRendering"]) {
+    host["disableLazyRendering"]();
+  } // In case of lazy loading
+
+
+  this.config(options);
+  host.listen("columnAdded", this._onColumnAdded);
+};
+/** @public
+* @param {Object} host core grid object
+*/
+
+
+ContentWrapPlugin.prototype.unload = function (host) {
+  var at = this._hosts.indexOf(host);
+
+  if (at < 0) {
+    return;
+  }
+
+  this._hosts.splice(at, 1);
+
+  window.removeEventListener("load", this._setReCalculationTimer);
+  host.unlisten("widthChanged", this._setReCalculationTimer);
+  host.unlisten("postSectionDataBinding", this._setReCalculationTimer);
+  host.unlisten("columnAdded", this._onColumnAdded);
+
+  this._clearTimer();
+};
+/** @public
+* @param {Object=} options
+*/
+
+
+ContentWrapPlugin.prototype.config = function (options) {
+  if (!options) {
+    return;
+  }
+
+  var extOptions = options["contentWrap"];
+
+  if (extOptions) {
+    this._evenRowHeight = extOptions["evenRowHeight"] ? true : false;
+  }
+
+  var columns = options.columns;
+
+  if (!columns) {
+    return;
+  }
+
+  var len = columns.length;
+
+  for (var i = 0; i < len; ++i) {
+    this._setColumnContentWrapping(i, columns[i]);
+  }
+};
+/** @public
+* @param {Object=} gridOptions
+* @return {!Object}
+*/
+
+
+ContentWrapPlugin.prototype.getConfigObject = function (gridOptions) {
+  var obj = gridOptions || {};
+  var columns = obj.columns;
+
+  if (!columns) {
+    columns = obj.columns = [];
+  }
+
+  var len = this.getColumnCount();
+
+  for (var i = 0; i < len; ++i) {
+    var column = columns[i];
+
+    if (!column) {
+      column = columns[i] = {};
+    }
+
+    var contentWrap = this._getColumnOption(i, 'contentWrap', this._hosts[0]);
+
+    if (contentWrap) {
+      column.contentWrap = contentWrap;
+    }
+  }
+
+  var extOptions = obj.contentWrap;
+
+  if (!extOptions) {
+    extOptions = obj.contentWrap = {};
+  }
+
+  extOptions.evenRowHeight = this._evenRowHeight;
+  return obj;
+};
+/** @public
+* @param {Object} sectionRef core grid SectionReference object
+* @param {number=} from
+* @param {number=} to
+* @return {boolean}
+*/
+
+
+ContentWrapPlugin.prototype.adjustRowHeight = function (sectionRef, from, to) {
+  if (this._adjusting || this._hosts.length === 0) {
+    return false; // Quite if grid has not been registered or in the process of adjusting row height
+  }
+
+  this._clearTimer();
+
+  if (sectionRef == null) {
+    sectionRef = "content";
+  }
+
+  var section = this._hosts[0].getSection(sectionRef);
+
+  if (!section) {
+    return false;
+  }
+
+  this._adjusting = true; // Prevent infinite loop
+
+  var dirtyRows = []; // Collect dirty rows
+
+  var results = this._calculateRowHeight(section, from, to, dirtyRows); // Setting row height for multiple rows can cause performance issue
+
+
+  var rowCount = dirtyRows.length;
+  var prevFState = false;
+
+  if (rowCount > this._freezingThreshold) {
+    if (section.getFrozenLayout) {
+      prevFState = section.getFrozenLayout();
+      section.setFrozenLayout(true);
+    }
+  } // Apply new height
+
+
+  var r, rowIndex;
+
+  if (this._evenRowHeight) {
+    var max = results["max"];
+
+    for (r = 0; r < rowCount; ++r) {
+      rowIndex = dirtyRows[r];
+      section.setRowHeight(rowIndex, max);
+    }
+  } else {
+    var heights = results["heights"];
+
+    for (r = 0; r < rowCount; ++r) {
+      rowIndex = dirtyRows[r];
+      section.setRowHeight(rowIndex, heights[rowIndex]);
+    }
+  }
+
+  if (rowCount > this._freezingThreshold) {
+    if (section.setFrozenLayout) {
+      section.setFrozenLayout(prevFState);
+    }
+  }
+
+  this._adjusting = false;
+  return rowCount ? true : false;
+};
+/** @public
+* @param {Object} sectionRef core grid SectionReference object
+* @param {number} rowIndex
+* @return {boolean} True if the row height changes
+*/
+
+
+ContentWrapPlugin.prototype.adjustRowHeightAt = function (sectionRef, rowIndex) {
+  var section = this._hosts[0].getSection(sectionRef);
+
+  if (!section) {
+    return false;
+  }
+
+  var maxHeight = this._calculateRowHeightAt(section, rowIndex);
+
+  if (maxHeight && section.getRowHeight(rowIndex) !== maxHeight) {
+    section.setRowHeight(rowIndex, maxHeight);
+    return true;
+  }
+
+  return false;
+};
+/** @private
+* @param {Object} sectionRef core grid SectionReference object
+* @param {number} rowIndex
+* @return {number}
+*/
+
+
+ContentWrapPlugin.prototype.calculateRowHeightAt = function (sectionRef, rowIndex) {
+  var section = this._hosts[0].getSection(sectionRef);
+
+  if (!section) {
+    return NaN;
+  }
+
+  return this._calculateRowHeightAt(section, rowIndex);
+};
+/** @private
+* @param {number} colIndex
+* @param {ContentWrapPlugin~ColumnOptions} columnOptions
+*/
+
+
+ContentWrapPlugin.prototype._setColumnContentWrapping = function (colIndex, columnOptions) {
+  var val = columnOptions["contentWrap"] ? true : false;
+
+  var colData = this._newColumnData(colIndex);
+
+  colData["contentWrap"] = val;
+
+  this._wrapContent(colIndex, val);
+};
+/** @private */
+
+
+ContentWrapPlugin.prototype._setReCalculationTimer = function () {
+  if (!this._recalTimer) {
+    this._recalTimer = setTimeout(this._onRecalculation, 100);
+  }
+};
+/** @private */
+
+
+ContentWrapPlugin.prototype._onRecalculation = function () {
+  this._recalTimer = 0;
+  this.adjustRowHeight("content");
+};
+/** @private */
+
+
+ContentWrapPlugin.prototype._clearTimer = function () {
+  if (this._recalTimer) {
+    clearTimeout(this._recalTimer);
+    this._recalTimer = 0;
+  }
+};
+/** @private
+* @param {number} height
+* @return {number}
+*/
+
+
+ContentWrapPlugin.prototype._getSteppingHeight = function (height) {
+  return Math.floor(height + 1) + 12; // Add top and bottom padding
+};
+/** @private
+* @param {Object} section ILayoutGrid
+* @param {number} rowIndex
+* @return {number}
+*/
+
+
+ContentWrapPlugin.prototype._calculateRowHeightAt = function (section, rowIndex) {
+  var maxHeight = section.getDefaultRowHeight(); //Find maximum row height from all monitored columns
+
+  var colCount = section.getColumnCount();
+
+  for (var c = 0; c < colCount; ++c) {
+    if (this.isWrappingContent(c)) {
+      var cell = section.getCell(c, rowIndex, false); // TODO: Handle cell spanning
+
+      if (cell && cell.isVisible()) {
+        var cellContent = cell.getContent();
+
+        if (cellContent) {
+          if (!cellContent.offsetParent) {
+            // Cell content is not in the document, so the height cannot be calculated
+            return NaN;
+          }
+
+          var contentHeight = this._getSteppingHeight(cellContent.offsetHeight);
+
+          if (contentHeight > maxHeight) {
+            maxHeight = contentHeight;
+          }
+        }
+      }
+    }
+  }
+
+  return maxHeight;
+};
+/** @private
+* @param {Object} section ILayoutGrid
+* @param {number=} from
+* @param {number=} to
+* @param {Array.<number>=} opt_dirtyRows
+* @return {!Object}
+*/
+
+
+ContentWrapPlugin.prototype._calculateRowHeight = function (section, from, to, opt_dirtyRows) {
+  if (!from || from < 0) {
+    from = 0;
+  }
+
+  var rowCount = section.getRowCount();
+
+  if (!to || to > rowCount) {
+    to = rowCount;
+  }
+
+  var r, h;
+  var results = {};
+
+  if (this._evenRowHeight) {
+    var max = 0;
+
+    for (r = from; r < to; ++r) {
+      h = this._calculateRowHeightAt(section, r);
+
+      if (max < h) {
+        max = h;
+      }
+    }
+
+    results["max"] = max;
+
+    for (r = from; r < to; ++r) {
+      if (max && opt_dirtyRows && max !== section.getRowHeight(r)) {
+        opt_dirtyRows.push(r);
+      }
+    }
+  } else {
+    var heights = new Array(to);
+
+    for (r = from; r < to; ++r) {
+      h = this._calculateRowHeightAt(section, r);
+      heights[r] = h;
+
+      if (h && opt_dirtyRows && h !== section.getRowHeight(r)) {
+        opt_dirtyRows.push(r);
+      }
+    }
+
+    results["heights"] = heights;
+  }
+
+  return results;
+};
+/** @private
+* @param {number} colIndex
+* @param {boolean=} bool
+*/
+
+
+ContentWrapPlugin.prototype._wrapContent = function (colIndex, bool) {
+  this._hosts[0].enableColumnClass(colIndex, "wrap", bool, "content");
+
+  this._setReCalculationTimer();
+};
+/** @public
+* @param {number} colIndex
+* @param {boolean=} bool
+*/
+
+
+ContentWrapPlugin.prototype.enableContentWrapping = function (colIndex, bool) {
+  var options = {
+    contentWrap: bool
+  };
+
+  this._setColumnContentWrapping(colIndex, options);
+};
+/** @public
+* @param {number} colIndex
+* @return {boolean}
+*/
+
+
+ContentWrapPlugin.prototype.isWrappingContent = function (colIndex) {
+  return this._getColumnOption(colIndex, "contentWrap") ? true : false;
+};
+/** @private
+* @param {Object} e
+*/
+
+
+ContentWrapPlugin.prototype._onColumnAdded = function (e) {
+  if (e["context"]) {
+    this._setColumnContentWrapping(e["colIndex"], e["context"]);
+  }
+};
+
+export default ContentWrapPlugin;
+export { ContentWrapPlugin, ContentWrapPlugin as ContentWrap, ContentWrapPlugin as ContentWrapExtension };

package/lib/tr-grid-content-wrap/es6/index.d.ts

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

package/lib/tr-grid-content-wrap/es6/index.js

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

package/lib/tr-grid-contextmenu/es6/ContextMenu.d.ts

@@ -0,0 +1,83 @@
+import { GridPlugin } from "../../tr-grid-util/es6/GridPlugin.js";
+import Ext from "../../tr-grid-util/es6/Ext.js";
+import MenuEventAPI from "./MenuEventAPI.js";
+import PopupMenu from "./PopupMenu.js";
+import { injectCss, prettifyCss } from "../../tr-grid-util/es6/Util.js";
+import { ElfUtil } from "../../tr-grid-util/es6/ElfUtil.js";
+import CellPainter from "../../tr-grid-util/es6/CellPainter.js";
+
+declare namespace ContextMenuPlugin {
+
+    type MenuItemEventCallback = (e: ContextMenuPlugin.MenuItemEvent) => void;
+
+    type OnMenuEventCallback = (e: ContextMenuPlugin.OnMenuEvent) => void;
+
+    type Context = "header" | "content" | "footer" | "filterRow";
+
+    type Options = {
+        items: { [key: string]:  ContextMenuPlugin.MenuItem },
+        onMenu?: ContextMenuPlugin.OnMenuEventCallback,
+        contextmenu?: ((...params: any[]) => any)
+    };
+
+    type MenuItem = {
+        text?: string,
+        value?: (string|number),
+        isDisabled?: boolean,
+        isVisible?: boolean,
+        isSeparator?: boolean,
+        items?: (ContextMenuPlugin.MenuItem)[],
+        renderer?: ((...params: any[]) => any),
+        callback?: ContextMenuPlugin.MenuItemEventCallback
+    };
+
+    type MenuItemEvent = {
+        altKey: boolean,
+        cell: any,
+        colIndex: number,
+        columnDef: object,
+        context: ContextMenuPlugin.Context,
+        ctrlKey: boolean,
+        item: ContextMenuPlugin.MenuItem,
+        items: { [key: string]:  ContextMenuPlugin.MenuItem },
+        menu: MenuEventAPI,
+        rowIndex: number,
+        section: any,
+        shiftKey: boolean
+    };
+
+    type OnMenuEvent = {
+        cell: any,
+        colIndex: number,
+        columnDef: object,
+        context: ContextMenuPlugin.Context,
+        items: object,
+        menu: MenuEventAPI,
+        rowIndex: number,
+        section: any,
+        selectedColumns: (number)[],
+        selectedRows: (number)[]
+    };
+
+}
+
+declare class ContextMenuPlugin extends GridPlugin {
+
+    constructor(options?: (ContextMenuPlugin.Options|ContextMenuPlugin.OnMenuEvent));
+
+    public getName(): string;
+
+    public initialize(host: any, options?: any): void;
+
+    public unload(host: any): void;
+
+    public config(options?: ContextMenuPlugin.Options): void;
+
+    public getConfigObject(gridOptions?: any): any;
+
+    public getMenuModel(): any;
+
+}
+
+export default ContextMenuPlugin;
+export { ContextMenuPlugin, ContextMenuPlugin as ContextMenu, ContextMenuPlugin as ContextMenuExtension };