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

package/lib/tr-grid-column-fitter/es6/index.d.ts

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

package/lib/tr-grid-column-fitter/es6/index.js

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

package/lib/tr-grid-column-formatting/es6/ColumnFormatting.d.ts

@@ -0,0 +1,91 @@
+import {Ext} from '../../tr-grid-util/es6/Ext.js';
+import {GridPlugin} from '../../tr-grid-util/es6/GridPlugin.js';
+import {ElfUtil} from '../../tr-grid-util/es6/ElfUtil.js';
+
+declare namespace ColumnFormattingPlugin {
+
+    type HeatmapOption = {
+        midPoint?: string|null,
+        mode?: string|null
+    };
+
+    type ConditionalColorOption = {
+        conditions?: (any)[]|null,
+        field?: string|null
+    };
+
+    type BarOption = {
+        useMovementColor?: boolean|null,
+        showValues?: boolean|null,
+        alignment?: string|null,
+        field?: string|null,
+        textHidden?: boolean|null,
+        textWidth?: (number|string)|null,
+        barColor?: string|null,
+        padding?: number|null,
+        percentageLabel?: boolean|null,
+        autoTextSizing?: boolean|null,
+        autoFitting?: boolean|null,
+        zeroValueHidden?: boolean|null
+    };
+
+    type DisplayStyleOption = {
+        alignment?: string|null,
+        mode?: string|null,
+        bar?: ColumnFormattingPlugin.BarOption|null,
+        conditionalColor?: ColumnFormattingPlugin.ConditionalColorOption|null,
+        heatmap?: ColumnFormattingPlugin.HeatmapOption|null,
+        general?: any
+    };
+
+    type ColumnFormatOptions = {
+        valueFormatTab?: any,
+        displayStyleTab?: ColumnFormattingPlugin.DisplayStyleOption|null,
+        colorTextTab?: any,
+        fieldDataType?: string|null
+    };
+
+    type ColumnOptions = {
+        fieldDataType?: string|null
+    };
+
+}
+
+declare class ColumnFormattingPlugin extends GridPlugin {
+
+    constructor();
+
+    public config(options?: any): void;
+
+    public getConfigObject(gridOptions?: any): any;
+
+    public getField(colIndex: number): string;
+
+    public getFieldList(): (string)[]|null;
+
+    public getColumnCount(): number;
+
+    public openDialog(colIndex: number, options?: any): void;
+
+    public getColumnFormatOptions(colIndex: number): ColumnFormattingPlugin.ColumnFormatOptions;
+
+    public setColumnFormatOptions(colIndex: number, options?: ColumnFormattingPlugin.ColumnFormatOptions|null): void;
+
+    public setColumnAlignment(colIndex: number, align: string): void;
+
+    public getColumnAlignment(colIndex: number): string;
+
+    public hasHiddenColumn(): boolean;
+
+    public isColumnHidden(colIndex: number): boolean;
+
+    public hideColumn(colIndex: number, opt_bool?: boolean|null): void;
+
+    public showAllColumns(): void;
+
+    public setFieldDataType(colIndex: number, type: string): void;
+
+}
+
+export default ColumnFormattingPlugin;
+export { ColumnFormattingPlugin, ColumnFormattingPlugin as ColumnFormatting, ColumnFormattingPlugin as ColumnFormattingExtension };

package/lib/tr-grid-column-formatting/es6/ColumnFormatting.js

@@ -0,0 +1,617 @@
+import {Ext} from '../../tr-grid-util/es6/Ext.js';
+import {GridPlugin} from '../../tr-grid-util/es6/GridPlugin.js';
+import {ElfUtil} from '../../tr-grid-util/es6/ElfUtil.js';
+
+/**
+* @typedef {Object} ColumnFormattingPlugin~HeatmapOption
+* @property {string=} midPoint
+* @property {string=} mode "text" or "cell"
+*/
+
+/**
+* @typedef {Object} ColumnFormattingPlugin~ConditionalColorOption
+* @property {Array.<Object>=} conditions
+* @property {string=} field
+*/
+
+/**
+* @typedef {Object} ColumnFormattingPlugin~BarOption
+* @property {boolean=} useMovementColor
+* @property {boolean=} showValues
+* @property {string=} alignment="" Fixate percent bar alignment. By default, percent bar alignment will be changed according to grid column alignment.
+* @property {string=} field=THIS_COLUMN Data field
+* @property {boolean=} textHidden=false If enabled, displays percent bar only
+* @property {(number|string)=} textWidth If specified, percent bar text will have fixed width
+* @property {string=} barColor="" Custom color for bar element. This will override the useMovementColor
+* @property {number=} padding=8 Extra space added to max width from autoTextSizing calculation
+* @property {boolean=} percentageLabel=true If disabled, the value will not convert into percent format
+* @property {boolean=} autoTextSizing=true If disabled, text space will be fixed
+* @property {boolean=} autoFitting=false If enabled, text space will be auto adjusted.<br> Otherwise, text space will stay extended to the longest length
+* @property {boolean=} zeroValueHidden=false If this option is enabled and the percentage value is zero, percent bar and its label will be hidden
+*/
+
+/**
+* @typedef {Object} ColumnFormattingPlugin~DisplayStyleOption
+* @property {string=} alignment "default" "left" "right" or "center"
+* @property {string=} mode Available options are "general", "bar", "heatmap", or "conditionalColor"
+* @property {ColumnFormattingPlugin~BarOption=} bar
+* @property {ColumnFormattingPlugin~ConditionalColorOption=} conditionalColor
+* @property {ColumnFormattingPlugin~HeatmapOption=} heatmap
+* @property {Object=} general
+*/
+
+/**
+* @typedef {Object} ColumnFormattingPlugin~ColumnFormatOptions
+* @property {Object=} valueFormatTab
+* @property {ColumnFormattingPlugin~DisplayStyleOption=} displayStyleTab
+* @property {Object=} colorTextTab
+* @property {string=} fieldDataType
+*/
+
+/**
+* The column options can be specified on each individual grid's column option:
+* {Object=} formatType=null Options for value formatting
+* {Object=} condition=null Options for specifying conditional coloring
+* {(string|boolean)=} colorText="" A shorthand for specifying default condition based on the field.
+* {Object=} heatMap=null Options for specifying heat map
+* @typedef {Object} ColumnFormattingPlugin~ColumnOptions
+* @property {string=} fieldDataType="" Change UIs based on the value. Available values are general, number, dateTime and FX.
+*/
+
+/** @event ColumnFormattingPlugin#formatChanged
+* @description Fired only when a user click OK from the format dialog, that is generated from this extension
+* @type {Object}
+* @property {number} colIndex
+* @property {string} field Field defined in the column
+*/
+
+/** @constructor
+* @extends {GridPlugin}
+*/
+var ColumnFormattingPlugin = function () {
+	// TODO: Handle a case where column is removed dynamically
+	this._onFormatDialogDataChange = this._onFormatDialogDataChange.bind(this);
+
+	this._hosts = [];
+};
+Ext.inherits(ColumnFormattingPlugin, GridPlugin);
+
+/** @type {Element}
+* @private
+*/
+ColumnFormattingPlugin.prototype._formatDialog = null;
+/** @type {tr.grid.TextFormattingPlugin}
+* @private
+*/
+ColumnFormattingPlugin.prototype._tfp = null;
+/** @type {tr.grid.ConditionalColoringPlugin}
+* @private
+*/
+ColumnFormattingPlugin.prototype._ccp = null;
+/** @type {tr.grid.HeatMapPlugin}
+* @private
+*/
+ColumnFormattingPlugin.prototype._hmp = null;
+/** @type {tr.grid.PercentBarPlugin}
+* @private
+*/
+ColumnFormattingPlugin.prototype._pcbp = null;
+/** @type {boolean}
+* @private
+*/
+ColumnFormattingPlugin.prototype._fromApi = true;
+
+/** Variable for self-definition
+* @type {string}
+* @private
+*/
+ColumnFormattingPlugin.prototype._constSelfColumn = 'THIS_COLUMN';
+
+
+/** @override
+* @return {string}
+*/
+ColumnFormattingPlugin.prototype.getName = function () {
+	return "ColumnFormattingPlugin"; // Readonly
+};
+
+/** Plugin that has multi-table support means that it can have multiple hosts/tables and share its states across those hosts/tables.
+* @public
+* @return {boolean}
+*/
+GridPlugin.prototype.hasMultiTableSupport = function () {
+	return true;
+};
+
+/** @override */
+ColumnFormattingPlugin.prototype.initialize = function (host, options) {
+	if(this._hosts.indexOf(host) >= 0) {
+		return;
+	}
+	this._hosts.push(host);
+	this._gridConfig = options;
+};
+/** @override */
+ColumnFormattingPlugin.prototype.unload = function (host) {
+	var at = this._hosts.indexOf(host);
+	if(at < 0) { return; }
+
+	this._hosts.splice(at, 1);
+	if(!this._hosts.length) {
+		this._formatDialog = this._compositeGrid = null;
+		this._tfp = this._ccp = this._hmp = null;
+	}
+};
+
+/**
+ * @private
+ * @param {*} e
+ * @return {null} null
+ */
+ColumnFormattingPlugin._empty = function (e) {
+	return null;
+};
+
+/** This method guarantees that grid (host) and config have been set. <br>
+* It should be used to update any setting that requires different implementation between <br>
+* Composite grid and Real-time grid
+* @protected
+* @ignore
+*/
+ColumnFormattingPlugin.prototype._afterInit = function () {
+	Promise.all([
+		this._requestPlugin(this._hosts[0], "TextFormatting", this._gridConfig).catch(ColumnFormattingPlugin._empty), // TODO: this is redundant
+		this._requestPlugin(this._hosts[0], "ConditionalColoring", this._gridConfig).catch(ColumnFormattingPlugin._empty),
+		this._requestPlugin(this._hosts[0], "HeatMap", this._gridConfig).catch(ColumnFormattingPlugin._empty),
+		this._requestPlugin(this._hosts[0], "PercentBar", this._gridConfig).catch(ColumnFormattingPlugin._empty)
+	]).then(function(plugins){
+		this._tfp = plugins[0];
+		this._ccp = plugins[1];
+		this._hmp = plugins[2];
+		this._pcbp = plugins[3];
+		this.config(this._gridConfig);
+	}.bind(this)).catch(ColumnFormattingPlugin._empty);
+
+};
+
+/** @public
+* @param {Object=} options Grid configuration object
+*/
+ColumnFormattingPlugin.prototype.config = function (options) {
+	if(!options) { return; }
+
+	var columns = options["columns"];
+	if(columns) {
+		var len = columns.length;
+		for(var c = 0; c < len; ++c) {
+			var column = columns[c];
+			var colData = this._newColumnData(c);
+
+			if (!colData["field"] && column["field"]) {
+				colData["field"] = column["field"];
+			}
+
+			if (!colData['fieldDataType'] && column["fieldDataType"]){
+				colData['fieldDataType'] = column["fieldDataType"];
+			}
+		}
+	}
+};
+
+/** @public
+* @param {Object=} gridOptions
+* @return {!Object}
+*/
+ColumnFormattingPlugin.prototype.getConfigObject = function (gridOptions) {
+	var obj = gridOptions || {};
+
+	if(this._tfp && this._tfp.getConfigObject) {
+		this._tfp.getConfigObject(obj);
+	}
+	if(this._ccp && this._ccp.getConfigObject) {
+		this._ccp.getConfigObject(obj);
+	}
+	if(this._hmp && this._hmp.getConfigObject) {
+		this._hmp.getConfigObject(obj);
+	}
+	if(this._pcbp && this._pcbp.getConfigObject) {
+		this._pcbp.getConfigObject(obj);
+	}
+
+	return obj;
+};
+
+/** @public
+* @function
+* @param {number} colIndex
+* @return {string}
+*/
+ColumnFormattingPlugin.prototype.getField = ColumnFormattingPlugin.prototype._getField;
+/** @public
+* @return {Array.<string>}
+*/
+ColumnFormattingPlugin.prototype.getFieldList = function() {
+	var colCount = this.getColumnCount();
+	var fields = new Array(colCount);
+	for(var i = 0; i < colCount; ++i) {
+		fields[i] = this._getField(i); // Slow
+	}
+	return fields;
+};
+/** @public
+* @return {number}
+*/
+ColumnFormattingPlugin.prototype.getColumnCount = function() {
+	var grid = this._hosts[0];
+	return grid ? grid.getColumnCount() : 0;
+};
+
+/** @public
+* @param {number} colIndex
+* @param {Object=} options user's column format dialog config
+*/
+ColumnFormattingPlugin.prototype.openDialog = function (colIndex, options) {
+	options = options || {};
+	var dialogVersion = ElfUtil.hasComponent('column-format-dialog');
+
+	if(!this._formatDialog) {
+		if(dialogVersion >= 3) {
+			this._formatDialog = document.createElement('column-format-dialog');
+			document.body.appendChild(this._formatDialog);
+			this._formatDialog.addEventListener('confirm', this._onFormatDialogDataChange);
+		} else if(dialogVersion < 2) {
+			this._formatDialog = document.createElement('tr-grid-format-dialog');
+			this._formatDialog.addEventListener('data-change', this._onFormatDialogDataChange);
+		}
+	}
+
+	if(!options.supportDisplayStyleOptions) {
+		options.supportDisplayStyleOptions = {};
+	}
+
+	if(this._pcbp) {
+		if(options.supportDisplayStyleOptions.bar == null) {
+			options.supportDisplayStyleOptions.bar = true;
+		}
+	}
+
+	if(this._hmp) {
+		if(options.supportDisplayStyleOptions.heatmap == null) {
+			options.supportDisplayStyleOptions.heatmap = true;
+		}
+	}
+
+	if(this._ccp) {
+		if(options.supportDisplayStyleOptions.conditionalColor == null) {
+			options.supportDisplayStyleOptions.conditionalColor = true;
+		}
+	}
+
+	var colData = options.data || this.getColumnFormatOptions(colIndex);
+	if (this._formatDialog.init) {
+		options.data = colData;
+		options.fields = options.fields || this.getFieldList();
+		this._formatDialog.init(options);
+	} else {
+		this._formatDialog.data = colData;
+	}
+
+	this._formatDialog.colIndex = colIndex;
+	this._formatDialog.show();
+};
+/** @public
+* @param {number} colIndex
+* @return {!ColumnFormattingPlugin~ColumnFormatOptions}
+*/
+ColumnFormattingPlugin.prototype.getColumnFormatOptions = function (colIndex) {
+	var opts = {};
+
+	if (this._tfp) {
+		opts.valueFormatTab = this._tfp.getColumnFormatOptions(colIndex);
+		if (!opts.valueFormatTab.formatType) {
+			opts.valueFormatTab.formatType = this._getColumnData(colIndex)["fieldDataType"];
+		}
+	}
+
+	var dsTabName = "general";
+	var dsTabObj = {};
+
+	if (this._hmp) {
+		this._hmp.getColumnHeatMapOptions(colIndex, dsTabObj);
+		if (dsTabObj["midPoint"] != null) {
+			dsTabName = "heatmap";
+		}
+	}
+
+	if (this._ccp && dsTabName != "heatmap") { // heatmap coloring conflicts conditional coloring
+		var painter = this._ccp.getColumnPainter(colIndex);
+		if (painter) {
+			var conditions = painter.getConditions();
+			if (conditions) {
+				var coloringType = painter.getColoringType();
+				var inputField = painter["inputField"] || this._constSelfColumn;
+
+				opts.colorTextTab = {};
+				if (painter._blinkCondition) {
+					opts.colorTextTab.highlight = {
+						field: painter._blinkCondition.field,
+						mode: painter._blinkCondition.border ? 'border' : 'cell'
+					};
+				}
+
+				var cond;
+				if (coloringType === 1) { // Text coloring type
+					cond = conditions[0];
+					if (cond) {
+						opts.colorTextTab.colorText = {
+							"field": inputField
+						};
+					}
+				} else if (coloringType === 3) { // Conditional Coloring
+					dsTabName = "conditionalColor";
+					dsTabObj.conditions = [];
+					dsTabObj.field = inputField;
+					var len = conditions.length;
+					for (var i = 0; i < len; ++i) {
+						cond = conditions[i];
+						var obj = {};
+						obj["condition"] = cond["condition"] || "";
+						obj["expression"] = cond["expression"];
+
+						var val = cond["value1"];
+						if (val == null) {
+							val = "";
+						}
+						obj["value1"] = val;
+
+						val = cond["value2"];
+						if (val == null) {
+							val = "";
+						}
+						obj["value2"] = val;
+						obj["color"] = cond["color"];
+						obj["backgroundColor"] = cond["backgroundColor"];
+						dsTabObj.conditions.push(obj);
+					}
+				}
+			}
+		}
+	}
+
+	if(this._pcbp) {
+		var pcbOptions = this._pcbp.getColumnConfigObject(colIndex, dsTabObj);
+		if(pcbOptions.percentBar) {
+			dsTabObj = pcbOptions.percentBar;
+			dsTabName = "bar"; // TODO: Make column format dialog support mode "percentBar"
+			// TODO : Make column format dialog support textHidden
+			dsTabObj["showValues"] = !dsTabObj["textHidden"];
+			if(dsTabObj["textHidden"] != null) {
+				delete dsTabObj["textHidden"];
+			}
+		}
+	}
+
+	var dsTab = opts.displayStyleTab = {};
+	dsTab[dsTabName] = dsTabObj;
+	dsTab.alignment = this.getColumnAlignment(colIndex);
+	dsTab.mode = dsTabName;
+
+	// Get field data type
+	opts.fieldDataType = this._getColumnData(colIndex)["fieldDataType"];
+
+	return opts;
+};
+/** @public
+* @param {number} colIndex
+* @param {ColumnFormattingPlugin~ColumnFormatOptions=} options Option object in JSON format
+*/
+ColumnFormattingPlugin.prototype.setColumnFormatOptions = function(colIndex, options) {
+	if (!options) {
+		return;
+	}
+	var field = this._getField(colIndex);
+
+	if (this._tfp) {
+		var vft = options.valueFormatTab;
+		if (vft) {
+			var fot = vft.formatType;
+			if (fot === "percent") {
+				// The dialog always provides values, so we need to take care of that here
+				vft.percentSign = true;
+			}
+			this._tfp.setColumnFormat(colIndex, vft);
+		}
+	}
+	if (this._ccp) { // THIS_COLUMN
+		var colorTextTab = options.colorTextTab;
+		if (colorTextTab) {
+			colorTextTab["field"] = field; // To support THIS_COLUMN field
+			// TODO: colorTextTab should be merged with the conditional coloring logic (displayStyleTab)
+			this._ccp.setColumnColoring(colIndex, colorTextTab); // Clear all coloring, including conditional coloring
+		}
+	}
+
+	var dsTab = options.displayStyleTab;
+	if (dsTab) {
+		var genStyle = dsTab.general; // User select general display style
+		var condStyle = dsTab.conditionalColor;
+		var hmStyle = dsTab.heatmap;
+		var pcbStyle = dsTab.bar || dsTab.percentBar; // Support property percentBar and bar in column format dialog
+
+		var alignment = null;
+		if (genStyle) {
+			alignment = genStyle.alignment;
+		} else if (hmStyle) {
+			alignment = hmStyle.alignment;
+		} else if (condStyle) {
+			alignment = condStyle.alignment;
+		} else if (pcbStyle) {
+			alignment = pcbStyle.alignment;
+		}
+
+		if (this._ccp && condStyle) {
+			if(this._pcbp) { // Reset percentBar
+				this._pcbp.setColumnPercentBar(colIndex, null);
+			}
+			if (this._tfp) {
+				// TODO: Make this support coloring of formatted texts
+				var ff = this._tfp.getFormatter(colIndex);
+				if (ff) {
+					condStyle.textFormatter = ff.format;
+				}
+			}
+			if(!hmStyle) { // only set condStyle
+				// support THIS_COLUMN
+				condStyle.conditions.forEach(function(condition){
+					if(typeof condition.expression === 'string') {
+						condition.expression = condition.expression.replace(this._constSelfColumn, field);
+					}
+				}.bind(this));
+
+				this._ccp.setColumnColoring(colIndex, condStyle);
+			} else { // If set heatMap and conditionalColoring at once clear conditionalColoring
+				this._ccp.setColumnColoring(colIndex, {});
+			}
+
+		}
+		if (this._hmp && hmStyle) {
+			if(this._pcbp) { // Reset percentBar
+				this._pcbp.setColumnPercentBar(colIndex, null);
+			}
+
+			if(!condStyle) { // Only set heatmap is there is no conditional style
+				this._hmp.setColumnHeatMap(colIndex, {
+					"field": field,
+					"heatmap": hmStyle
+				});
+			} else { // If set heatMap and conditionalColoring at once clear heatmap
+				this._hmp.setColumnHeatMap(colIndex, null); // Clear heatmap if send cc and ht at once.
+			}
+		}
+
+		if(this._pcbp && pcbStyle) {
+			// rename property before send to percent bar extension
+			if(pcbStyle["showValues"] != null) {
+				pcbStyle["textHidden"] = !pcbStyle["showValues"];
+			}
+
+			if(this._hmp) {
+				this._hmp.setColumnHeatMap(colIndex, null);
+			}
+			if(this._ccp) {
+				this._ccp.setColumnColoring(colIndex, {});
+			}
+
+			this._pcbp.setColumnPercentBar(colIndex, {
+				"field": field,
+				"percentBar": pcbStyle
+			});
+		}
+
+		this.setColumnAlignment(colIndex, alignment);
+
+		if (this._fromApi) {
+			if (options && options["fieldDataType"]) {
+				this.setFieldDataType(colIndex, options["fieldDataType"]);
+			}
+		}
+	}
+};
+/** @private
+* @param {Object} e
+*/
+ColumnFormattingPlugin.prototype._onFormatDialogDataChange = function(e) {
+	var rootData = e.detail.data;
+	var colIndex = this._formatDialog.colIndex;
+
+	this._fromApi = false;
+	this.setColumnFormatOptions(colIndex, rootData);
+	this._fromApi = true;
+
+	if(this.hasListener("formatChanged")) {
+		rootData.colIndex = colIndex;
+		rootData.field = this._getField(colIndex);
+		if(this._compositeGrid && this._compositeGrid["getColumnId"]) {
+			rootData.colId = rootData.columnId = this._compositeGrid["getColumnId"](colIndex);
+		}
+		this._dispatch("formatChanged", rootData);
+	}
+};
+/** @public
+* @param {number} colIndex
+* @param {string} align
+*/
+ColumnFormattingPlugin.prototype.setColumnAlignment = function(colIndex, align) {
+	for(var i = this._hosts.length; --i >= 0;) {
+		this._hosts[i].setColumnAlignment(colIndex, align);
+	}
+};
+/** @public
+* @param {number} colIndex
+* @return {string}
+*/
+ColumnFormattingPlugin.prototype.getColumnAlignment = function(colIndex) {
+	var grid = this._hosts[0];
+	if(grid) {
+		return grid.getColumnAlignment(colIndex);
+	}
+	return "default";
+};
+/** Return true if at lease one column is hidden. If grid contains only columns hidden by stacking this will return false
+* @public
+* @return {boolean}
+*/
+ColumnFormattingPlugin.prototype.hasHiddenColumn = function() {
+	var colCount = this.getColumnCount();
+	for(var i = 0; i < colCount; ++i) {
+		if(this.isColumnHidden(i)) {
+			return true;
+		}
+	}
+	return false;
+};
+/** Check if the specified column is hidden. Column hidden by stacking is not considered as hidden column.
+* @public
+* @param {number} colIndex
+* @return {boolean}
+*/
+ColumnFormattingPlugin.prototype.isColumnHidden = function(colIndex) {
+	var grid = this._hosts[0];
+	if(grid) {
+		var visible = grid.getColumnVisibility(colIndex, 0);
+		return !visible;
+	}
+	return false;
+};
+/** Hide or show the specified column
+* @public
+* @param {number} colIndex
+* @param {boolean=} opt_bool
+*/
+ColumnFormattingPlugin.prototype.hideColumn = function(colIndex, opt_bool) {
+	var len = this._hosts.length;
+	for(var i = 0; i < len; ++i) {
+		this._hosts[i].hideColumn(colIndex, opt_bool);
+	}
+};
+/** @public */
+ColumnFormattingPlugin.prototype.showAllColumns = function() {
+	var colCount = this.getColumnCount();
+	for(var i = 0; i < colCount; ++i) {
+		this.hideColumn(i, false);
+	}
+};
+
+/** @public
+* @param {number} colIndex
+* @param {string} type
+*/
+ColumnFormattingPlugin.prototype.setFieldDataType = function(colIndex, type) {
+	var colData = this._newColumnData(colIndex);
+	colData['fieldDataType'] = type;
+};
+
+
+
+export default ColumnFormattingPlugin;
+export { ColumnFormattingPlugin, ColumnFormattingPlugin as ColumnFormatting, ColumnFormattingPlugin as ColumnFormattingExtension };

package/lib/tr-grid-column-formatting/es6/index.d.ts

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