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

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

@@ -0,0 +1,272 @@
+import Ext from "../../../../tr-grid-util/es6/Ext.js";
+import Util from "../util/util.js";
+import Core from "../Core.js"; // eslint-disable-line
+import EventDispatcher from "../event/EventDispatcher.js";
+import ElementWrapper from "../components/ElementWrapper.js"; // eslint-disable-line
+
+
+/** Base class for all built-in plugins
+* @constructor
+* @extends {EventDispatcher}
+*/
+var Plugin = function () {
+	/* throw("Plugin is an abstract Class"); */
+};
+Ext.inherits(Plugin, EventDispatcher); // Inherits() will replace prototype of the derived object
+
+//#region Public Methods
+/**The name must be readonly and unique among all other plugins
+* @public
+* @return {string}
+*/
+Plugin.prototype.getName = function () {
+	return "Plugin";
+};
+
+/** @public
+* @param {!Core} owner
+*/
+Plugin.prototype.initialize = function (owner) {
+	this._host = owner;
+};
+/**For disposing any resource
+* @public
+* @param {!Core} owner
+*/
+Plugin.prototype.unload = function (owner) {
+	this._host = null;
+	this.unlistenAll();
+};
+
+/** @public
+* @param {Event|Element|ElementWrapper} e
+* @return {Core}
+*/
+Plugin.prototype.getRelativeGrid = function (e) {
+	var targetEl;
+	if(e.target) { // The Given object is an Event
+		targetEl = /** @type{Element} */(e.target);
+		var gridAPI = targetEl["api"];
+		if(gridAPI && gridAPI["getCoreGrid"]) {
+			return /** @type{Core} */(gridAPI["getCoreGrid"]());
+		}
+	} else if(e["getElement"]) { // The Given object is implementing ElementWrapper
+		targetEl = e["getElement"]();
+	} else if(Util.isElement(e)){ // The Given object is just an element
+		targetEl = /** @type{Element} */(e);
+	}
+
+	var gridEl = (targetEl) ? Util.closestElement(targetEl, "tr-grid") : null;
+	if(gridEl) {
+		if(this._host) {
+			if(this._host.getElement() === gridEl) {
+				return this._host;
+			}
+		} else {
+			var hostLength = this._hosts ? this._hosts.length : 0;
+			for (var i = 0; i < hostLength; i++) {
+				var host = this._hosts[i];
+				if (host.getElement() === gridEl) {
+					return host;
+				}
+			}
+		}
+	}
+
+	return null;
+};
+/** Use in case of there is an overlay over the top of the grid (target element cannot be used).
+* @public
+* @param {number} x
+* @param {number} y
+* @return {Element}
+*/
+Plugin.prototype.getGridElementFromPoint = function (x, y) {
+	var elem = document.elementFromPoint(x, y);
+	var grid = Util.closestElement(elem, "tr-grid");
+
+	// Some elements are over grid element, hide them all by setting the visibility to hidden
+	var skipElem = [];
+	var skipVisibility = [];
+	while (!grid && elem && elem.tagName != "HTML") {
+		skipElem.push(elem);
+		skipVisibility.push(elem.style.visibility);
+		elem.style.visibility = "hidden";
+		elem = document.elementFromPoint(x, y);
+
+		grid = Util.closestElement(elem, "tr-grid");
+	}
+	for (var i = 0; i < skipElem.length; i++) {
+		skipElem[i].style.visibility = skipVisibility[i];
+	}
+	return grid;
+};
+
+//#endregion Public Methods
+
+//#region Protected Methods
+/** @protected
+* @ignore
+* @return {Array.<string>}
+*/
+Plugin.prototype._getDataColumnMap = function () {
+	if (this._dataMap) { return this._dataMap; }
+
+	if (this._host) {
+		return this._host.getDataColumnMap();
+	}
+	if (this._hosts && this._hosts[0]) {
+		return this._hosts[0].getDataColumnMap();
+	}
+	return null;
+};
+/** @protected
+ * @ignore
+ * @param {number} colIndex
+ * @return {string}
+ */
+Plugin.prototype._getDataColumnName = function (colIndex) {
+	var dataMap = this._getDataColumnMap();
+	if(dataMap){
+		return dataMap[colIndex] || "";
+	}
+	return "";
+};
+
+/** @protected
+* @ignore
+* @param {Object} e
+* @return {boolean}
+*/
+Plugin.prototype._isNotFirstHost = function(e) {
+	if (this._hosts) {
+		return e["sender"] !== this._hosts[0];
+	}
+	return false;
+};
+/** @protected
+* @ignore
+* @param {Object} e
+*/
+Plugin.prototype._onColumnAdded = function (e) {
+	if (this._isNotFirstHost(e)) {
+		return;
+	}
+	if (!e["atTheMiddle"]) { return; }
+	var colIndex = /** @type{number} */(e["colIndex"]);
+	Util.insertArrayItem(this._colData, colIndex, null);
+	Util.insertArrayItem(this._dataMap, colIndex, null);
+};
+/** @protected
+* @ignore
+* @param {Object} e
+*/
+Plugin.prototype._onColumnMoved = function (e) {
+	if (this._isNotFirstHost(e)) {
+		return;
+	}
+	var from = /** @type{number} */(e["fromColIndex"]);
+	var to = /** @type{number} */(e["toColIndex"]);
+
+	Util.moveArrayItem(this._colData, from, to);
+	Util.moveArrayItem(this._dataMap, from, to);
+};
+/** @protected
+* @ignore
+* @param {Object} e
+*/
+Plugin.prototype._onColumnRemoved = function (e) {
+	if (this._isNotFirstHost(e)) {
+		return;
+	}
+	if (!e["atTheMiddle"]) { return; }
+	var colIndex = /** @type{number} */(e["colIndex"]);
+	if(this._colData) {
+		this._colData.splice(colIndex, 1);
+	}
+	if(this._dataMap) {
+		this._dataMap.splice(colIndex, 1);
+	}
+};
+
+
+/** @protected
+* @ignore
+* @return {number}
+ */
+Plugin.prototype._getColumnCount = function() {
+	var host = this._host || this._hosts[0];
+	return (host) ? host.getColumnCount() : 0;
+};
+/** @protected
+* @ignore
+* @param {string} pluginName
+* @return {*|null}
+ */
+Plugin.prototype._getPlugin = function(pluginName) {
+	var host = this._host || this._hosts[0];
+	return (host) ? host.getPlugin(pluginName) : null;
+};
+
+/** @protected
+* @ignore
+* @param {number} scrollVal
+*/
+Plugin.prototype._scrollDown = function (scrollVal) {
+	var host = this._host || this._hosts[0];
+	host.scrollDown(scrollVal);
+};
+/** @protected
+* @ignore
+* @param {number} rowIndex
+*/
+Plugin.prototype._scrollToRow = function (rowIndex) {
+	var host = this._host || this._hosts[0];
+	host.scrollToRow(null, rowIndex);
+};
+/** @protected
+* @ignore
+* @param {number} scrollVal
+*/
+Plugin.prototype._scrollRight = function (scrollVal) {
+	if(this._host) {
+		this._host.scrollRight(scrollVal);
+	} else if(this._hosts) {
+		var len = this._hosts.length;
+		for(var i = 0; i < len; ++i) {
+			var host = this._hosts[i];
+			host.scrollRight(scrollVal);
+		}
+	}
+};
+
+//#endregion Protected Methods
+
+//#region Protected Fields
+/** @protected
+* @ignore
+* @type {Core}
+*/
+Plugin.prototype._host = null;
+/** @protected
+* @ignore
+* @type {Array.<Core>}
+*/
+Plugin.prototype._hosts = null; // For a plug-in that support multi-table
+
+/** @protected
+* @ignore
+* @type {Array.<string|null>}
+*/
+Plugin.prototype._dataMap = null;
+/** @protected
+* @ignore
+* @type {Array.<Object>}
+*/
+Plugin.prototype._colData = null;
+//#endregion Protected Fields
+
+Plugin._proto = Plugin.prototype;
+
+export default Plugin;
+export { Plugin };

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

@@ -0,0 +1,127 @@
+import Ext from "../../../../tr-grid-util/es6/Ext.js";
+import Plugin from "./Plugin.js";
+import Core from "../Core.js";
+import ILayoutGrid from "../ILayoutGrid.js";
+import ElementWrapper from "../components/ElementWrapper.js";
+import DataTable from "../../data/DataTable.js";
+
+declare namespace SortableTitlePlugin {
+
+    type SortOrder = "a" | "ascending" | "d" | "descending" | "n" | null;
+
+    type InitialSort = {
+        colIndex: number,
+        sortOrder?: SortableTitlePlugin.SortOrder,
+        order?: SortableTitlePlugin.SortOrder
+    };
+
+    type ColumnOptions = {
+        sortable?: boolean,
+        sortBy?: string,
+        sortLogic?: DataTable.SortLogic,
+        sortingLogic?: DataTable.SortLogic,
+        sorter?: DataTable.SortLogic,
+        sortingSequence?: (SortableTitlePlugin.SortOrder)[]
+    };
+
+    type Options = {
+        initialSort?: (SortableTitlePlugin.InitialSort|(SortableTitlePlugin.InitialSort)[]),
+        multicolumn?: (boolean|number),
+        multiColumn?: (boolean|number),
+        threeStatesSorting?: boolean,
+        sortLogic?: { [key: string]:  DataTable.SortLogic },
+        disableDoubleClickToSort?: boolean,
+        sortableColumns?: boolean,
+        sortableIndicator?: boolean,
+        indicatorOnly?: boolean,
+        mode?: string,
+        disabled?: boolean,
+        columnSorted?: ((...params: any[]) => any),
+        preClicked?: ((...params: any[]) => any),
+        clicked?: ((...params: any[]) => any),
+        preDataSorting?: ((...params: any[]) => any),
+        sortingSequence?: (SortableTitlePlugin.SortOrder)[]
+    };
+
+}
+
+declare class SortableTitlePlugin extends Plugin {
+
+    constructor(options?: SortableTitlePlugin.Options);
+
+    public afterInit(): void;
+
+    public config(options?: any): void;
+
+    public getConfigObject(gridOptions?: any): any;
+
+    public getColumnMenu(colIndex: number, config: any): any;
+
+    public getIcons(): { [key: string]:  string };
+
+    public setSortLogics(sortLogic: { [key: string]:  ((...params: any[]) => any) }): void;
+
+    public setSortLogic(field: string, func: ((...params: any[]) => any)): void;
+
+    public getSortOrder(colIndex?: number): string;
+
+    public getSortedColumnIndex(priority?: number): number;
+
+    public getSortPriority(colIndex: number): number;
+
+    public isColumnSorted(colIndex: number): boolean;
+
+    public getSortedColumns(): (any)[] | null;
+
+    public sortColumn(colIndex: number, sortOrder?: string, opt_arg?: any): void;
+
+    public sortColumns(sortOptions: (SortableTitlePlugin.InitialSort)[], opt_arg?: any): void;
+
+    public clearSortState(opt_arg?: any): void;
+
+    public refresh(): void;
+
+    public restoreUserActions(): void;
+
+    public setSortableColumnCount(count: number): void;
+
+    public getSortingStates(): (any)[];
+
+    public updateSortSymbols(): void;
+
+    public getDataColumnMap(): (string)[];
+
+    public setDataColumnMap(dataMap: (string|null)[]): void;
+
+    public getColumnSortingField(colIndex: number): string;
+
+    public setColumnSortingField(colIndex: number, field: string|null, sortLogic?: ((...params: any[]) => any)): void;
+
+    public getColumnSortingFields(): (string)[];
+
+    public disableTwoStateSorting(disabled?: boolean): void;
+
+    public disableSortSymbols(disabled?: boolean): void;
+
+    public disableDataSorting(disabled?: boolean): void;
+
+    public disableDoubleClickToSort(disabled?: boolean): void;
+
+    public disableCellClick(cell: ElementWrapper, disabled?: boolean): void;
+
+    public disableColumnSorting(columns: number|(number)[], disabled?: boolean): void;
+
+    public setClickDelayInterval(opt_ms?: number): void;
+
+    public getSortingSequence(colRef?: (number|string)): (string)[];
+
+    public setSortingSequence(sequence: (string)[], colRef?: (number|string)): void;
+
+    public clearAllColumnSortingSequences(): void;
+
+}
+
+declare function len(disabled?: boolean): void;
+
+export default SortableTitlePlugin;
+export { SortableTitlePlugin };