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

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.js";

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|null
+    };
+
+    type ColumnOptions = {
+        contentWrap?: boolean|null
+    };
+
+}
+
+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|null, to?: number|null): boolean;
+
+    public adjustRowHeightAt(sectionRef: any, rowIndex: number): boolean;
+
+    public enableContentWrapping(colIndex: number, bool?: boolean|null): 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,519 @@
+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._requestRecalculation = this._requestRecalculation.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._requestRecalculation); // Since CSS can impact font, we need adjust accordingly
+
+  host.listen("widthChanged", this._requestRecalculation);
+  host.listen("postSectionDataBinding", this._requestRecalculation); // 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._requestRecalculation);
+  host.unlisten("widthChanged", this._requestRecalculation);
+  host.unlisten("postSectionDataBinding", this._requestRecalculation);
+  host.unlisten("columnAdded", this._onColumnAdded);
+
+  this._dispose();
+
+  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) {
+    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;
+  }
+
+  var sectionElem = section.getElement();
+
+  if (!sectionElem || !sectionElem.offsetParent) {
+    return false;
+  }
+
+  this._adjusting = true; // Prevent infinite loop
+
+  var dirtyRows = []; // Collect dirty rows
+
+  var maxHeight = NaN;
+  var heights = null;
+
+  if (this._evenRowHeight) {
+    maxHeight = this._calcMaxRowHeight(section, dirtyRows, from, to);
+  } else {
+    heights = this._calcRowHeights(section, dirtyRows, from, to);
+  } // Setting row height for multiple rows can cause performance issue
+
+
+  var dirtyCount = dirtyRows.length;
+  var prevFState = false;
+
+  if (dirtyCount > this._freezingThreshold) {
+    if (section.getFrozenLayout) {
+      prevFState = section.getFrozenLayout();
+      section.setFrozenLayout(true);
+    }
+  } // Apply new height
+
+
+  var r, rowIndex;
+
+  if (this._evenRowHeight) {
+    for (r = 0; r < dirtyCount; ++r) {
+      rowIndex = dirtyRows[r];
+      section.setRowHeight(rowIndex, maxHeight);
+    }
+  } else {
+    for (r = 0; r < dirtyCount; ++r) {
+      rowIndex = dirtyRows[r];
+      section.setRowHeight(rowIndex, heights[rowIndex]);
+    }
+  }
+
+  if (dirtyCount > this._freezingThreshold) {
+    if (section.setFrozenLayout) {
+      section.setFrozenLayout(prevFState);
+    }
+  }
+
+  this._adjusting = false;
+  return dirtyCount ? 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._requestRecalculation = function () {
+  if (!this._recalTimer && !this._adjusting) {
+    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.ceil(height) + 14; // 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)) {
+      continue;
+    }
+
+    var cell = section.getCell(c, rowIndex, false); // TODO: Handle cell spanning
+
+    if (!cell || !cell.isVisible()) {
+      continue;
+    }
+
+    var cellContent = cell.getContent();
+
+    if (!cellContent) {
+      continue;
+    }
+
+    if (!cellContent.offsetParent) {
+      // Cell content is not in the document, so the height cannot be calculated
+      continue;
+    }
+
+    var contentHeight = this._getSteppingHeight(cellContent.offsetHeight);
+
+    if (contentHeight > maxHeight) {
+      maxHeight = contentHeight;
+    }
+  }
+
+  return maxHeight;
+};
+/** @private
+* @param {Object} section ILayoutGrid
+* @param {!Array.<number>} dirtyRows
+* @param {number=} from
+* @param {number=} to
+* @return {number}
+*/
+
+
+ContentWrapPlugin.prototype._calcMaxRowHeight = function (section, dirtyRows, from, to) {
+  if (from == null) {
+    from = section.getFirstIndexInView();
+  } else if (!from || from < 0) {
+    from = 0;
+  }
+
+  if (to == null) {
+    to = section.getLastIndexInView() + 1;
+  } else {
+    var rowCount = section.getRowCount();
+
+    if (!to || to > rowCount) {
+      to = rowCount;
+    }
+  }
+
+  var r;
+  var max = 0;
+
+  for (r = from; r < to; ++r) {
+    var h = this._calculateRowHeightAt(section, r);
+
+    if (max < h) {
+      max = h;
+    }
+  }
+
+  if (max) {
+    for (r = from; r < to; ++r) {
+      if (max !== section.getRowHeight(r)) {
+        dirtyRows.push(r);
+      }
+    }
+  }
+
+  return max;
+};
+/** @private
+* @param {Object} section ILayoutGrid
+* @param {!Array.<number>} dirtyRows
+* @param {number=} from
+* @param {number=} to
+* @return {!Array.<number>}
+*/
+
+
+ContentWrapPlugin.prototype._calcRowHeights = function (section, dirtyRows, from, to) {
+  if (from == null) {
+    from = section.getFirstIndexInView();
+  } else if (!from || from < 0) {
+    from = 0;
+  }
+
+  if (to == null) {
+    to = section.getLastIndexInView() + 1;
+  } else {
+    var rowCount = section.getRowCount();
+
+    if (!to || to > rowCount) {
+      to = rowCount;
+    }
+  }
+
+  var heights = new Array(to);
+
+  for (var r = from; r < to; ++r) {
+    var h = this._calculateRowHeightAt(section, r);
+
+    heights[r] = h;
+
+    if (h && h !== section.getRowHeight(r)) {
+      dirtyRows.push(r);
+    }
+  }
+
+  return heights;
+};
+/** @private
+* @param {number} colIndex
+* @param {boolean=} bool
+*/
+
+
+ContentWrapPlugin.prototype._wrapContent = function (colIndex, bool) {
+  this._hosts[0].enableColumnClass(colIndex, "wrap", bool, "content");
+
+  this._requestRecalculation();
+};
+/** @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.js";

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