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

package/lib/tr-grid-titlewrap/es6/TitleWrap.js

@@ -0,0 +1,431 @@
+import { Ext } from '../../tr-grid-util/es6/Ext.js';
+import { GridPlugin } from '../../tr-grid-util/es6/GridPlugin.js';
+/** @constructor
+* @extends {GridPlugin}
+*/
+
+var TitleWrapPlugin = function TitleWrapPlugin() {
+  var _t = this;
+
+  _t._onSectionAdded = _t._onSectionAdded.bind(_t);
+  _t._requestRecalculation = _t._requestRecalculation.bind(_t);
+  _t._onRecalculation = _t._onRecalculation.bind(_t);
+  _t._onPostSectionRender = _t._onPostSectionRender.bind(_t);
+  _t._hosts = [];
+};
+
+Ext.inherits(TitleWrapPlugin, GridPlugin);
+/** @type {boolean}
+* @private
+*/
+
+TitleWrapPlugin.prototype._adjusting = false;
+/** @type {number}
+* @private
+*/
+
+TitleWrapPlugin.prototype._paddingTop = 6;
+/** @type {number}
+* @private
+*/
+
+TitleWrapPlugin.prototype._paddingBottom = 6;
+/** @type {number}
+* @private
+*/
+
+TitleWrapPlugin.prototype._timerId = 0;
+/** @public
+* @return {string}
+*/
+
+TitleWrapPlugin.prototype.getName = function () {
+  return "TitleWrapPlugin"; // Read Only
+};
+/**
+* @override
+* @return {boolean}
+*/
+
+
+TitleWrapPlugin.prototype.hasMultiTableSupport = function () {
+  return true;
+};
+/** @public
+* @param {Object} host core grid instance
+* @param {Object=} options
+*/
+
+
+TitleWrapPlugin.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("sectionAdded", this._onSectionAdded);
+  host.listen("widthChanged", this._requestRecalculation); // updateLayout can also dispatch widthChanged
+
+  host.listen("postSectionRender", this._onPostSectionRender);
+  this.config(options); // In case of lazy loading
+
+  var section = host.getSection("title");
+
+  if (!section) {
+    return;
+  }
+
+  section.enableClass("wrap", true);
+
+  this._adjustRowHeightRefByHost(host, section);
+};
+/** @public
+* @param {Object} host core grid instance
+*/
+
+
+TitleWrapPlugin.prototype.unload = function (host) {
+  var hostPos = this._hosts.indexOf(host);
+
+  if (hostPos < 0) return;
+  host.unlisten("sectionAdded", this._onSectionAdded);
+  host.unlisten("widthChanged", this._requestRecalculation);
+  host.unlisten("postSectionRender", this._onPostSectionRender);
+
+  this._hosts.splice(hostPos, 1);
+
+  if (!this._hosts.length) {
+    if (this._timerId) {
+      clearTimeout(this._timerId);
+      this._timerId = 0;
+    }
+
+    window.removeEventListener("load", this._onCSSLoaded);
+  }
+};
+/** @public
+* @param {Object=} options
+*/
+
+
+TitleWrapPlugin.prototype.config = function (options) {
+  if (!options) {
+    return;
+  }
+
+  var pluginOpt =
+  /** @type{Object} */
+  options["titlewrap"] || options["titleWrap"];
+
+  if (!pluginOpt) {
+    return;
+  }
+
+  var val = pluginOpt["padding"];
+
+  if (typeof val == "number") {
+    this._paddingTop = this._paddingBottom = val / 2;
+  }
+};
+/** @public
+* @param {Object=} gridOptions
+* @return {!Object}
+*/
+
+
+TitleWrapPlugin.prototype.getConfigObject = function (gridOptions) {
+  var obj = gridOptions || {};
+  var extOptions = obj.titleWrap;
+
+  if (!extOptions) {
+    extOptions = obj.titleWrap = {};
+  }
+
+  var padding = this._paddingTop + this._paddingBottom;
+
+  if (padding !== 12) {
+    extOptions.padding = padding;
+  }
+
+  return obj;
+};
+/** @private */
+
+
+TitleWrapPlugin.prototype._requestRecalculation = function () {
+  if (!this._timerId) {
+    this._timerId = setTimeout(this._onRecalculation, 50);
+  }
+};
+/** @private */
+
+
+TitleWrapPlugin.prototype._onRecalculation = function () {
+  this._timerId = 0;
+  this.adjustRowHeight("title");
+};
+/** adjust row height using specific grid at a reference to other grid
+* @private
+* @param {Object} host core grid instance
+* @param {Object} sectionRef grid SectionReference
+* @param {number=} from
+* @param {number=} to
+* @return {boolean}
+*/
+
+
+TitleWrapPlugin.prototype._adjustRowHeightRefByHost = function (host, sectionRef, from, to) {
+  if (this._adjusting || !host) {
+    return false; // Quite if grid has not been registered or in the process of adjusting row height
+  }
+
+  var section = host.getSection(sectionRef);
+  var elem = section ? section.getElement() : null;
+  var p = elem ? elem.offsetParent : null;
+
+  if (!p) {
+    return false;
+  }
+
+  var rowDirtyMap = []; // Collect dirty rows
+
+  this._calculateRowHeight(section, from, to, rowDirtyMap);
+
+  return this._setRowHeight(section.getIndex(), rowDirtyMap);
+};
+/** @public
+* @param {Object} sectionRef grid SectionReference
+* @param {number=} from
+* @param {number=} to
+* @return {boolean}
+*/
+
+
+TitleWrapPlugin.prototype.adjustRowHeight = function (sectionRef, from, to) {
+  return this._adjustRowHeightRefByHost(this._hosts[0], sectionRef, from, to);
+};
+/** @public
+* @param {Object} sectionRef grid SectionReference
+* @param {number} rowIndex
+* @return {boolean} True if the row height changes
+*/
+
+
+TitleWrapPlugin.prototype.adjustRowHeightAt = function (sectionRef, rowIndex) {
+  return this._adjustRowHeightRefByHost(this._hosts[0], sectionRef, rowIndex, rowIndex);
+};
+/** @private
+* @param {Object} sectionRef grid SectionReference
+* @param {number} rowIndex
+* @return {number}
+*/
+
+
+TitleWrapPlugin.prototype.calculateRowHeightAt = function (sectionRef, rowIndex) {
+  var host = this._hosts[0];
+  if (!host) return NaN;
+  var section = host.getSection(sectionRef);
+
+  if (!section) {
+    return NaN;
+  }
+
+  return this._calculateRowHeightAt(section, rowIndex);
+};
+/** set row height at specific row index to all grid instance
+* @private
+* @param {number} sectionIndex
+* @param {Array} rowHeightMap
+* @return {boolean} true if has row height changed
+*/
+
+
+TitleWrapPlugin.prototype._setRowHeight = function (sectionIndex, rowHeightMap) {
+  if (this._adjusting) return false;
+  this._adjusting = true; // Prevent infinite loop
+
+  var mapLen = rowHeightMap.length;
+  var rowUpdateCount = 0,
+      i;
+
+  for (i = 0; i < mapLen; i++) {
+    if (++rowUpdateCount > 1) break; // just need to know rowUpdateCount > 1
+  }
+
+  var hostCount = this._hosts.length;
+
+  for (i = 0; i < hostCount; i++) {
+    var section = this._hosts[i].getSection(sectionIndex);
+
+    var prevState = section.getFrozenLayout();
+
+    if (rowUpdateCount > 1) {
+      section.setFrozenLayout(true);
+    } // Apply new height
+
+
+    for (var j = 0; j < mapLen; j++) {
+      section.setRowHeight(j, rowHeightMap[j]);
+    }
+
+    if (rowUpdateCount > 1) {
+      section.setFrozenLayout(prevState);
+    }
+  }
+
+  this._adjusting = false; // Prevent infinite loop
+
+  return rowUpdateCount > 0; // return - is height has changed?
+};
+/** @private
+* @param {Object} e
+*/
+
+
+TitleWrapPlugin.prototype._onSectionAdded = function (e) {
+  if (e["sectionType"] === "title") {
+    var section = e["section"];
+    section.enableClass("wrap", true);
+  }
+};
+/** @private
+* @param {Object} e
+*/
+
+
+TitleWrapPlugin.prototype._onPostSectionRender = function (e) {
+  // when user edit title name, grid core will rerender
+  // and we need to recalculate hight again in case line of title changed
+  if (e["sectionType"] === "title") {
+    this._requestRecalculation();
+  }
+};
+/** @private
+* @param {number} height
+* @return {number}
+*/
+
+
+TitleWrapPlugin.prototype._getSteppingHeight = function (height) {
+  return Math.floor(height + 1) + this._paddingTop + this._paddingBottom;
+};
+/** @private
+* @param {Object} section ILayoutGrid
+* @param {number} rowIndex
+* @param {Array.<number>} rowHeights
+* @return {number}
+*/
+
+
+TitleWrapPlugin.prototype._calculateRowHeightAt = function (section, rowIndex, rowHeights) {
+  var maxHeight = section.getDefaultRowHeight();
+  var spanMaxHeight = 0;
+  var maxRowSpan = 0;
+  var colCount = section.getColumnCount();
+  var lastRow = rowHeights ? rowHeights.length - 1 : NaN; // Find maximum row height from all monitored columns
+
+  for (var colIndex = 0; colIndex < colCount; ++colIndex) {
+    var rowSpan = section.getCellRowSpan(colIndex, rowIndex);
+
+    if (rowSpan > 1) {
+      continue;
+    } // cell with rowspan will be deferred to the last row
+
+
+    var colSpan = section.getCellColSpan(colIndex, rowIndex);
+
+    if (colSpan < 1) {
+      // colspan overlap
+      if (rowSpan >= 0) {
+        continue;
+      }
+    }
+
+    if (rowSpan !== 1 && rowIndex !== lastRow) {
+      continue;
+    }
+
+    var includeSpan = rowSpan !== 1; // we will include row span into the callculation only for the bottom row.
+
+    var cell = section.getCell(colIndex, rowIndex, includeSpan);
+
+    if (!cell || !cell.isVisible()) {
+      continue;
+    }
+
+    var cellContent = cell.getContent();
+
+    if (!cellContent) {
+      continue;
+    }
+
+    var contentHeight = this._getSteppingHeight(cellContent.offsetHeight);
+
+    if (rowSpan === 1) {
+      // cell with no span
+      if (contentHeight > maxHeight) {
+        maxHeight = contentHeight;
+      }
+    } else {
+      // cell that's spanned over
+      if (contentHeight > spanMaxHeight) {
+        spanMaxHeight = contentHeight;
+        maxRowSpan = -rowSpan;
+      }
+    }
+  }
+
+  if (rowHeights && spanMaxHeight) {
+    var properHeight = 0;
+    var origSpanRow = lastRow - maxRowSpan;
+
+    for (var index = origSpanRow; index < lastRow; index++) {
+      var rowHeight = rowHeights[index];
+      properHeight += rowHeight ? rowHeight : 0;
+    }
+
+    var totalHeight = properHeight + maxHeight;
+
+    if (spanMaxHeight > totalHeight) {
+      maxHeight = spanMaxHeight - properHeight;
+    }
+  }
+
+  return maxHeight;
+};
+/** @private
+* @param {Object} section ILayoutGrid
+* @param {number=} from
+* @param {number=} to
+* @param {Array=} rowDirtyMap
+* @return {!Array.<number>}
+*/
+
+
+TitleWrapPlugin.prototype._calculateRowHeight = function (section, from, to, rowDirtyMap) {
+  if (!from || from < 0) {
+    from = 0;
+  }
+
+  var rowCount = section.getRowCount();
+
+  if (!to || to > rowCount) {
+    to = rowCount;
+  }
+
+  var heights = new Array(to);
+
+  for (var r = from; r < to; ++r) {
+    var h = heights[r] = this._calculateRowHeightAt(section, r, heights);
+
+    if (rowDirtyMap && h !== section.getRowHeight(r)) {
+      rowDirtyMap[r] = h;
+    }
+  }
+
+  return heights;
+};
+
+export default TitleWrapPlugin;
+export { TitleWrapPlugin, TitleWrapPlugin as TitleWrap, TitleWrapPlugin as TitleWrapExtension };

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

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

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

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

package/lib/tr-grid-util/es6/CellPainter.d.ts

@@ -0,0 +1,142 @@
+import { TickCodes, TickFields } from "./TickCodes.js";
+import { rgb2Hex, num2Hex, num2Rgb, hex2Num, hex2Rgb, blendColor, getContrastColor } from "./Color.js";
+import { ElfUtil } from "./ElfUtil.js";
+import { ExpressionParser } from "./ExpressionParser.js";
+
+declare namespace CellPainter {
+
+    type Expression = {
+        name?: string|null,
+        text: string,
+        values?: any[]|null
+    };
+
+    type Condition = {
+        expression: string|((...params: any[]) => any)|null,
+        field?: string|null,
+        backgroundColor?: string|null,
+        color?: string|null,
+        fontSize?: string|null,
+        fontWeight?: string|null,
+        fontStyle?: string|null,
+        textAlign?: string|null,
+        textDecoration?: string|null,
+        cssClass?: string|null
+    };
+
+    type ThemeColors = {
+        baseGrid?: string|null,
+        baseText?: string|null,
+        up?: string|null,
+        down?: string|null,
+        level?: string|null,
+        tickUp?: string|null,
+        tickDown?: string|null
+    };
+
+    enum ColoringTypes {
+        TEXT = 1,
+        HEATMAP = 2,
+        CONDITIONAL = 3
+    }
+
+}
+
+declare class CellPainter {
+
+    constructor();
+
+    public static readonly themeReady: Promise<any>|null;
+
+    public static parse(expression: string|((...params: any[]) => any)|null): ((...params: any[]) => any)|null;
+
+    public dispose(): void;
+
+    public reset(): void;
+
+    public resetColoring(): void;
+
+    public clearBlinking(): void;
+
+    public clearHeatMap(): boolean;
+
+    public applyThemeColor(): void;
+
+    public getConditions(): (any)[]|null;
+
+    public getColoringType(): CellPainter.ColoringTypes|null;
+
+    public setEffectiveStyles(mapping: any): void;
+
+    public getEffectiveStyles(): any;
+
+    public setConditions(conditions: (CellPainter.Condition)[]|null): void;
+
+    public setColumnStats(columnStats: any): void;
+
+    public getColumnStats(): any;
+
+    public addHeatmap(field: string, midPoint: number, upColor: string, downColor: string, baseColor: string, opt_textMode?: (string|boolean)|null): any;
+
+    public addHeatmapWithTheme(field: string, midPoint: number, opt_textMode?: (string|boolean)|null): any;
+
+    public addColorText(field: string, upClass?: string|null, downClass?: string|null, levelClass?: string|null): any;
+
+    public addColorTextWithTheme(field: string): any;
+
+    public addTickColorText(upColor: string, downColor: string, levelColor: string): any;
+
+    public addTickColorTextWithTheme(): any;
+
+    public addTickBlink(upColor: string, downColor: string, levelColor: string, opt_border?: (string|boolean)|null): any;
+
+    public addTickBlinkWithTheme(opt_border?: (string|boolean)|null): any;
+
+    public addBlink(field: string, upColor: string, downColor: string, levelColor: string, opt_border?: (string|boolean)|null): any;
+
+    public addBlinkWithTheme(field: string, opt_border?: (string|boolean)|null): any;
+
+    public renderForPrinting(cell: Element|null, rowData: any, min: number, max: number): void;
+
+    public static blendColor(baseColor: string, maxColor: string, ratio: number): (number)[]|null;
+
+    public static rgb2Hex(rgbCode: string): string;
+
+    public static num2Hex(triplet: (number)[]|null): string;
+
+    public static num2Rgb(triplet: (number)[]|null): string;
+
+    public static hex2Num(hex: string): (number)[]|null;
+
+    public static hex2Rgb(hex: string): string;
+
+    public static setThemeColors(): void;
+
+    public static loadThemeColors(): Promise<any>|null;
+
+    public static reloadThemeColors(): Promise<any>|null;
+
+    public static getOppositeColor(hexCode: string|(number)[]|null): string;
+
+    public render(cell: any, rowData: any, min: number, max: number): void;
+
+    public renderHeatMap(cell: any, rowData: any, min: number, max: number): void;
+
+    public renderColoring(cell: any, rowData: any): void;
+
+    public blink(cell: any, blinkSignal: number, rowData: any): boolean;
+
+    public flash(cell: any, blinkColor: string|null|null, rowData: any): boolean;
+
+    public blinkCell(cell: any, newValue: number, oldValue: number, rowData: any): boolean;
+
+    public verifyBlinking(cell: any, rowData: any): void;
+
+    public disableLevelColor(disabled?: boolean|null): void;
+
+    public setBlinkingDuration(duration: number): void;
+
+}
+
+export default CellPainter;
+export {CellPainter};