@refinitiv-ui/efx-grid 6.0.45 → 6.0.47

package/lib/core/es6/data/DataTable.d.ts

@@ -112,6 +112,8 @@ declare class DataTable extends DataCache {
 
     public getSegmentChildIds(segmentId: string): (string)[]|null;
 
+    public sortSeparators(sortLogics: ((...params: any[]) => any)|(((...params: any[]) => any))[]|null, sortOrders: (number)[]|null, cids: (string)[]|null): boolean;
+
     public sortSegments(compare: ((...params: any[]) => any)|null): boolean;
 
     public setClassificationSource(dc: DataCache|null): void;

package/lib/core/es6/data/DataTable.js

@@ -76,6 +76,14 @@ DataTable.prototype._removedRows = null;
 */
 DataTable.prototype._userSegmentComparer = null;
 /** @private
+* @type {number}
+*/
+DataTable.prototype._segmentSortOrder = 0;
+/** @private
+* @type {*}
+*/
+DataTable.prototype._segmentSortContext = null;
+/** @private
 * @type {Object.<string, Object>}
 */
 DataTable.prototype._clsSource = null;
@@ -1248,6 +1256,51 @@ DataTable.prototype.getSegmentChildIds = function(segmentId) {
 	}
 	return null;
 };
+/** Sort all of existing segments by multiple sort logics
+* @public
+* @param {Function|Array.<Function>} sortLogics
+* @param {Array.<number>} sortOrders
+* @param {Array.<string>} cids
+* @return {boolean}
+*/
+DataTable.prototype.sortSeparators = function (sortLogics, sortOrders, cids) {
+	var dirty = false;
+	if(!this._segments){
+		return false;
+	}
+	if(typeof sortLogics === "function"){
+		return this.sortSegments(sortLogics);
+	}
+	var sortingDefs = DataTable._buildSortContext(
+		[],
+		cids,
+		sortOrders,
+		sortLogics
+	);
+	var defCount = sortingDefs ? sortingDefs.length : 0;
+	if(!defCount){
+		return dirty;
+	}
+
+	var sortOrder = 0;
+	var sortLogic, sortContext;
+	if(defCount > 1) {
+		sortLogic = DataTable._multiColumnSeparatorCompareLogic;
+		sortContext = sortingDefs;
+		sortOrder = 1; // sortOrder is not used by _multiColumnSeparatorCompareLogic
+	} else { // Single level sorting
+		sortLogic = DataTable._singleColumnSeparatorCompareLogic;
+		sortContext = sortingDefs[0];
+		sortOrder = /** @type{number} */(sortContext[3]);
+	}
+	this._segmentSortOrder = sortOrder;
+	this._segmentSortContext = sortContext;
+	dirty = this.sortSegments(sortLogic);
+	this._segmentSortOrder = 0;
+	this._segmentSortContext = null;
+
+	return dirty;
+};
 /** Sort all of existing segments by given compare function
 * @public
 * @param {Function} compare
@@ -1316,7 +1369,9 @@ DataTable.prototype.sortSegments = function (compare) {
 DataTable.prototype._bySegmentSeparator = function (segmentA, segmentB) {
 	return /** @type{number} */(this._userSegmentComparer(
 		this.getRowData(segmentA.getId()),
-		this.getRowData(segmentB.getId())
+		this.getRowData(segmentB.getId()),
+		this._segmentSortOrder,
+		this._segmentSortContext
 	));
 };
 
@@ -1657,6 +1712,47 @@ DataTable._singleColumnCompareLogic = function(a, b, order, sortingDef) {
 		sortingDef[4] // Context object
 	));
 };
+/** Performance is extremely vital in this method
+* @public
+* @ignore
+* @function
+* @param {*} a
+* @param {*} b
+* @param {number} order Not used by in this method
+* @param {Array.<Array>} sortingDefs
+* @return {number}
+*/
+DataTable._multiColumnSeparatorCompareLogic = function(a, b, order, sortingDefs) {
+	var count = sortingDefs.length;
+	var result = 0;
+	for(var c = 0; c < count; ++c) {
+		var sortingDef = sortingDefs[c];
+		result = DataTable._singleColumnSeparatorCompareLogic(a, b, sortingDef[3], sortingDef);
+		if(result) {
+			return result;
+		}
+	}
+	return result;
+};
+/** Performance is extremely vital in this method
+* @public
+* @ignore
+* @function
+* @param {*} a
+* @param {*} b
+* @param {number} order
+* @param {Array} sortingDef
+* @return {number}
+*/
+DataTable._singleColumnSeparatorCompareLogic = function(a, b, order, sortingDef) {
+	var key = /** @type{string} */(sortingDef[0]);
+	return /** @type{number} */(sortingDef[2](
+		a[key], // Value1
+		b[key], // Value2
+		order, // Sort order (3)
+		sortingDef[4] // Context object
+	));
+};
 /** @public
 * @function
 * @ignore

package/lib/core/es6/data/DataView.d.ts

@@ -272,6 +272,8 @@ declare class DataView extends EventDispatcher {
 
     public getSegmentChildIds(segmentRef: string|number|null): (string)[]|null;
 
+    public sortSeparators(sortLogics: (((...params: any[]) => any))[]|null, sortOrders: (number)[]|null, cids: (string)[]|null): void;
+
     public sortSegments(compare: ((...params: any[]) => any)|null): void;
 
     public enableEmptySegmentFiltering(enabled?: boolean|null): void;

package/lib/core/es6/data/DataView.js

@@ -2548,6 +2548,15 @@ DataView.prototype.getSegmentIds = function() {
 DataView.prototype.getSegmentChildIds = function(segmentRef) {
 	return this._dt.getSegmentChildIds(this._toRowId(segmentRef));
 };
+/** Sort all of existing segments by multiple sort logics
+* @public
+* @param {Array.<Function>} sortLogics
+* @param {Array.<number>} sortOrders
+* @param {Array.<string>} cids
+*/
+DataView.prototype.sortSeparators = function (sortLogics, sortOrders, cids) {
+	this._dt.sortSeparators(sortLogics, sortOrders, cids);
+};
 /** Sort all of existing segments by given compare function
 * @public
 * @param {Function} compare

package/lib/core/es6/grid/Core.js

@@ -554,7 +554,7 @@ Core.prototype._batches = null;
 * @return {string}
 */
 Core.getVersion = function () {
-	return "5.1.65";
+	return "5.1.66";
 };
 /** {@link ElementWrapper#dispose}
 * @override

package/lib/core/es6/grid/plugins/SortableTitlePlugin.d.ts

@@ -135,6 +135,8 @@ declare class SortableTitlePlugin extends EventDispatcher {
 
     public clearAllColumnSortingSequences(): void;
 
+    public sortSeparators(comparer: ((...params: any[]) => any)|null): void;
+
 }
 
 declare function len(disabled?: boolean|null): void;

package/lib/core/es6/grid/plugins/SortableTitlePlugin.js

@@ -1358,6 +1358,28 @@ SortableTitlePlugin.prototype.setSortingSequence = function (sequence, colRef) {
 SortableTitlePlugin.prototype.clearAllColumnSortingSequences = function () {
 	this._sortingSequenceMap = null;
 };
+/** @public
+* @description Sorting all separators according to compare function. If compare function is not specified, separators will will be sort by current sorting states.
+* @param {Function} comparer Compare function
+*/
+SortableTitlePlugin.prototype.sortSeparators = function (comparer) {
+	var host = this._hosts[0];
+	var dv = host.getDataSource();
+	if(comparer){
+		dv.sortSeparators(comparer);
+	} else {
+		var sortLogics = dv.getSortingLogics();
+		var sortOrders = [];
+		var sortFields = [];
+		var sortStateCount = this._sortStates.length;
+		for(var i = 0; i < sortStateCount; i++){
+			var sortState =  this._sortStates[i];
+			sortOrders.push(sortState["sortOrder"]);
+			sortFields.push(sortState["field"]);
+		}
+		dv.sortSeparators(sortLogics, sortOrders, sortFields);
+	}
+};
 
 
 /** @private

package/lib/grid/index.js

@@ -1,3 +1,3 @@
 import {Grid} from "./lib/efx-grid.js";
 export {Grid}
-window.EFX_GRID = { version: "6.0.45" };
+window.EFX_GRID = { version: "6.0.47" };

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

@@ -0,0 +1,49 @@
+import { Ext } from "../../tr-grid-util/es6/Ext.js";
+import { ElementWrapper } from "../../tr-grid-util/es6/ElementWrapper.js"; // ElementWrapper doesnot have setStyle and etc.
+import { Dom } from "../../tr-grid-util/es6/Dom.js";
+
+declare class CellWriter extends ElementWrapper {
+
+    constructor();
+
+    public getContent(): Node|null|null;
+
+    public setContent(content: any, opt_tooltip?: boolean): Element|null;
+
+    public setTooltip(str: string): void;
+
+    public setTextContent(str: string): void;
+
+    public addContent(n: any): Element|null;
+
+    public setStyle(str: string, val: any): void;
+
+    public removeIcon(n: any): void;
+
+    public updateIcon(elem: Element): void;
+
+    public unlisten(): void;
+
+    public listen(): void;
+
+    public setTooltip(): void;
+
+    public addClass(str: string): void;
+
+    public hasClass(str: string): void;
+
+    public removeClass(str: string): void;
+
+    public enableClass(str: string, bool: boolean): void;
+
+    public insertFloatingIcon(elem: Element, order: number): void;
+
+    public removeFloatingIcon(elemRef: string|Element, order: number): void;
+
+    public getSection(): null;
+
+    public cloak(elem: Element): void;
+
+}
+
+export { CellWriter };

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

@@ -0,0 +1,226 @@
+import { Ext } from "../../tr-grid-util/es6/Ext.js";
+import { ElementWrapper } from "../../tr-grid-util/es6/ElementWrapper.js"; // ElementWrapper doesnot have setStyle and etc.
+import { Dom } from "../../tr-grid-util/es6/Dom.js";
+
+/**
+* @constructor
+* @extends {ElementWrapper}
+*/
+var CellWriter = function () {
+};
+Ext.inherits(CellWriter, ElementWrapper);
+
+/** @type
+* @private
+*/
+CellWriter.prototype._flexRow = null;
+/** @type
+* @private
+*/
+CellWriter.prototype._floatingPanel = null;
+/** @type
+* @private
+*/
+CellWriter.prototype._frontPanel = null;
+
+
+/** @public
+* @return {Node|null} content
+*/
+CellWriter.prototype.getContent = function () {
+	return this._elem.children[0] || null;
+};
+/** @public
+* @param {*} content
+* @param {boolean=} opt_tooltip
+* @return {Element}
+*/
+CellWriter.prototype.setContent = function (content, opt_tooltip) {
+	if(content == null) {
+		return null;
+	}
+	if(content["getElement"]) {
+		content = /** @type{Element} */(content["getElement"]());
+	} else if(content.nodeType !== 1) {
+		content = this._createTextContent(content);
+	}
+	Dom.removeChildren(this._elem);
+	this._elem.appendChild(/** @type{Node} */(content));
+	return /** @type{Element} */(content);
+};
+
+/**
+ * Set value to title. If value is absent then a title will be removed
+ * @public
+ * @param {string} str
+ */
+CellWriter.prototype.setTooltip = function (str) {
+	if(str) {
+		this._elem.setAttribute("title", str);
+	} else {
+		this._elem.removeAttribute("title");
+	}
+};
+
+/** @public
+* @param {string} str
+*/
+CellWriter.prototype.setTextContent = function (str) {
+	Dom.removeChildren(this._elem);
+	this._elem.appendChild(this._createTextContent(str));
+};
+/** @public
+* @param {*} n
+* @return {Element}
+*/
+CellWriter.prototype.addContent = function (n) {
+	this._elem.appendChild(/** @type{Node} */(n));
+	return /** @type{Element} */(n);
+};
+/** @private
+* @param {string} str
+* @return {Element}
+*/
+CellWriter.prototype._createTextContent = function (str) {
+	var div = Dom.div("text");
+	if(str != null) {
+		div.textContent = str;
+		this["percentText"] = str; // HACK
+	}
+	return div;
+};
+
+/** @public
+* @param {string} str
+* @param {*} val
+*/
+CellWriter.prototype.setStyle = function (str, val) {
+	this._elem.style[str] = val;
+};
+/** @public
+* @param {*} n
+*/
+CellWriter.prototype.removeIcon = function (n) {};
+/** @public
+* @param {Element} elem
+*/
+CellWriter.prototype.updateIcon = function (elem) {
+	if(elem && elem.nodeType === 1) {
+		var fp = this._frontPanel;
+		if(!fp) {
+			this._flexRow = document.createElement("div");
+			this._flexRow.className = "tr-printing-flex-row";
+
+			fp = this._floatingPanel = document.createElement("div");
+			fp.className = "tr-printing-float-right";
+			this._flexRow.appendChild(fp);
+			var chdr = this._elem.children;
+			var childCount = chdr.length;
+			if(childCount) {
+				var ary = new Array(childCount);
+				for(var i = 0; i < childCount; ++i) {
+					ary[i] = chdr[i];
+				}
+				Dom.appendChild(this._flexRow, ary);
+			}
+			this._elem.appendChild(this._flexRow);
+		}
+		fp.appendChild(elem.cloneNode(true));
+	}
+};
+/** @public
+*/
+CellWriter.prototype.unlisten = function () {};
+/** @public
+*/
+CellWriter.prototype.listen = function () {};
+
+/** @public
+*/
+CellWriter.prototype.setTooltip = function () {};
+
+/** @public
+* @param {string} str
+*/
+CellWriter.prototype.addClass = function (str) {
+	this._elem.classList.add(str);
+};
+/** @public
+* @param {string} str
+*/
+CellWriter.prototype.hasClass = function (str) {
+	this._elem.classList.contains(str);
+};
+/** @public
+* @param {string} str
+*/
+CellWriter.prototype.removeClass = function (str) {
+	this._elem.classList.remove(str);
+};
+/** @public
+* @param {string} str
+* @param {boolean} bool
+*/
+CellWriter.prototype.enableClass = function (str, bool) {
+	if(bool || bool == null) {
+		this.addClass(str);
+	} else {
+		this.removeClass(str);
+	}
+};
+
+/** @public
+* @param {Element} elem
+* @param {number} order
+*/
+CellWriter.prototype.insertFloatingIcon = function (elem, order) {
+	if(elem && elem.nodeType === 1) {
+		var fp = this._floatingPanel;
+		if(!fp) {
+			this._flexRow = document.createElement("div");
+			this._flexRow.className = "tr-printing-flex-row";
+
+			var chdr = this._elem.children;
+			var childCount = chdr.length;
+			if(childCount) {
+				var ary = new Array(childCount);
+				for(var i = 0; i < childCount; ++i) {
+					ary[i] = chdr[i];
+				}
+				Dom.appendChild(this._flexRow, ary);
+			}
+			fp = this._floatingPanel = document.createElement("div");
+			fp.className = "tr-printing-float-right";
+			this._flexRow.appendChild(fp);
+			this._elem.appendChild(this._flexRow);
+		}
+		fp.appendChild(elem.cloneNode(true));
+	}
+};
+/** @public
+* @param {string|Element} elemRef
+* @param {number} order
+*/
+CellWriter.prototype.removeFloatingIcon = function (elemRef, order) {};
+/** @public
+* @return {null}
+*/
+CellWriter.prototype.getSection = function () {
+	return null;
+};
+
+/**
+* @public
+* @param {Element} elem
+*/
+CellWriter.prototype.cloak = function (elem) {
+	delete this.percentText;
+	delete this._flexRow;
+	delete this._floatingPanel;
+	delete this._frontPanel;
+	elem.className = "cell";
+	this._elem = elem;
+};
+
+
+export { CellWriter };

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

@@ -0,0 +1,12 @@
+import { Ext } from "../../tr-grid-util/es6/Ext.js";
+import { ElementWrapper } from "../../tr-grid-util/es6/ElementWrapper.js";
+
+declare class ColumnWriter extends ElementWrapper {
+
+    constructor();
+
+    public isActive(): number;
+
+}
+
+export { ColumnWriter };

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

@@ -0,0 +1,21 @@
+import { Ext } from "../../tr-grid-util/es6/Ext.js";
+import { ElementWrapper } from "../../tr-grid-util/es6/ElementWrapper.js";
+
+/**
+* @constructor
+* @extends {ElementWrapper}
+*/
+var ColumnWriter = function () {
+};
+Ext.inherits(ColumnWriter, ElementWrapper);
+
+
+/** @public
+* @return {number}
+*/
+ColumnWriter.prototype.isActive = function () {
+	return true;
+};
+
+
+export { ColumnWriter };

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

@@ -0,0 +1,32 @@
+import { Dom } from "../../tr-grid-util/es6/Dom.js";
+import { injectCss, prettifyCss } from "../../tr-grid-util/es6/Util.js";
+import { Table } from "../../tr-grid-util/es6/Table.js";
+
+import { PrintTrait } from "./PrintTrait.js";
+import { SectionWriter } from "./SectionWriter.js";
+
+declare namespace GridPrinter {
+
+    function setPrintOptions(options: GridPrinter.Options): void;
+
+    function observe(iFrameElement?: HTMLIFrameElement): void;
+
+    function unobserve(): void;
+
+    function enableDebugMode(bool?: boolean): void;
+
+    function getPreFlightInfo(grid: any, options?: any): any;
+
+    function createPrintElement(grid: any, options?: any): Element|null;
+
+    function print(grid: any): void;
+
+    type Options = {
+        pageWidth?: number,
+        pageHeight?: number,
+        primaryColumn?: number
+    };
+
+}
+
+export { GridPrinter };