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

package/lib/core/es6/grid/event/EventDispatcher.js

@@ -0,0 +1,138 @@
+import EventListeners from "./EventListeners.js";
+
+/** Abstract base class that provides event management methods for derived class
+ * @constructor
+ */
+let EventDispatcher = function () {
+	/* throw("Cannot instantiate an abstract class"); */
+	/*
+	this._addEvent("customEvent"); // Add this line in your derived class, if you want to add custom event to your class object
+	*/
+};
+/** @protected
+* @ignore
+* @type {Object.<string, !EventListeners>}
+*/
+EventDispatcher.prototype._customEvents = null;
+
+//#region Public
+/**
+* @public
+* @param {string} type Any event provided by derived class
+* @param {Function} handler Callback method
+* @param {number=} opt_priority The higher the priority, the sooner the listener get executed. Undefined priority listener will be executed last
+* @example
+* let grid = new Core();
+* grid.listen("click", function(e) { console.log("Grid is clicked"); });
+*/
+EventDispatcher.prototype.listen = function (type, handler, opt_priority) {
+	if (this._customEvents && this._customEvents[type]) {
+		this._customEvents[type].listen(handler, opt_priority);
+	}
+};
+/** Removes an event listener which was added with listen(). The same function handler must be sent in, or else it will not be removed
+* @public
+* @param {string} type The name of the event without the 'on' prefix.
+* @param {Function} handler The listener function to remove.
+*/
+EventDispatcher.prototype.unlisten = function (type, handler) {
+	if(this._customEvents && this._customEvents[type]) {
+		this._customEvents[type].unlisten(handler);
+	}
+};
+/** Removes all listeners from an object. If no type is specified, it will remove all listeners that have been registered. <br>
+* You can also optionally remove listeners of a particular type.
+* @public
+* @param {string=} type Type of event to, default is all types.
+*/
+EventDispatcher.prototype.unlistenAll = function (type) {
+	if(!type) {
+		for (let key in this._customEvents) {
+			this._customEvents[key].unlistenAll();
+		}
+	} else if(this._customEvents && this._customEvents[type]) {
+		this._customEvents[type].unlistenAll();
+	}
+};
+//#endregion Public
+
+//#region Protected
+/** Adds custom event
+* @protected
+* @ignore
+* @param {string} type
+*/
+EventDispatcher.prototype._addEvent = function (type) {
+	if(!type) { return; }
+
+	if(!this._customEvents) {
+		this._customEvents = {};
+	}
+	let e = this._customEvents[type];
+	if(!e) {
+		this._customEvents[type] = new EventListeners(this);
+	}
+};
+/** Adds multiple events at once
+* @protected
+* @ignore
+* @param {...string} types
+*/
+EventDispatcher.prototype._addEvents = function (types) {
+	let ary = Array.isArray(types) ? types : arguments;
+	let len = ary.length;
+	for(let i = 0; i < len; ++i) {
+		this._addEvent(ary[i]);
+	}
+};
+/** Check if the custom event is disptaching as dispatching for custom event is syncronous operations. Native events will always return false. This is useful to stop infinite loop.
+* @protected
+* @ignore
+* @param {string} type
+* @return {boolean} Returns false if the event is not dispatching
+*/
+EventDispatcher.prototype._isEventDispatching = function (type) {
+	let evt = this._customEvents[type];
+	if(evt) {
+		return evt.isDispatching();
+	}
+	return false;
+};
+/** Disable custom event from operating. This does NOT work with native events.
+* @protected
+* @ignore
+* @param {string} type
+* @param {boolean=} disabled
+*/
+EventDispatcher.prototype._disableEvent = function (type, disabled) {
+	let evt = this._customEvents[type];
+	if(evt) {
+		evt.disable(disabled);
+	}
+};
+/** This is used in conjunction with _dispatch to avoid creating event argument without actual listener
+* @protected
+* @ignore
+* @param {string} type
+* @return {boolean}
+*/
+EventDispatcher.prototype._hasListener = function (type) {
+	if(this._customEvents && this._customEvents[type]) {
+		return this._customEvents[type].hasListener();
+	}
+	return false;
+};
+/** Only custom event that is added by _addEvent() can be dispatched
+* @protected
+* @ignore
+* @param {string} type
+* @param {!Object} eventArg
+*/
+EventDispatcher.prototype._dispatch = function (type, eventArg) {
+	this._customEvents[type].dispatch(eventArg); // Intentional no error checking. You must add custom event first
+};
+
+EventDispatcher._proto = EventDispatcher.prototype;
+
+export default EventDispatcher;
+export { EventDispatcher };

package/lib/core/es6/grid/event/EventListeners.d.ts

@@ -0,0 +1,34 @@
+import Util from "../util/util.js";
+
+declare class EventListeners {
+
+    constructor(opt_sender?: any|null);
+
+    public listen(listener: ((...params: any[]) => any)|null, opt_priority?: number|null): void;
+
+    public unlisten(listener: ((...params: any[]) => any)|null): void;
+
+    public unlistenAll(): void;
+
+    public getListenerCount(): number;
+
+    public hasListener(): boolean;
+
+    public dispatch(eventArg: any): void;
+
+    public isDispatching(): boolean;
+
+    public isEnabled(): boolean;
+
+    public enable(opt_enabled?: boolean|null): void;
+
+    public disable(opt_disabled?: boolean|null): void;
+
+    public setSender(sender: any|null): void;
+
+    public setEventArgExtender(extender?: ((...params: any[]) => any)|null): void;
+
+}
+
+export default EventListeners;
+export { EventListeners };

package/lib/core/es6/grid/event/EventListeners.js

@@ -0,0 +1,166 @@
+import Util from "../util/util.js";
+
+/** @constructor
+* @param {*|null=} opt_sender The "sender" reference added automatically to event argument when dispatching event
+*/
+let EventListeners = function (opt_sender) {
+	this.dispatch = this.dispatch.bind(this);
+
+	this._listeners = [];
+	this.setSender(opt_sender);
+};
+
+//#region Public methods
+/** @public
+* @param {Function} listener should be already bound by the bind method
+* @param {number=} opt_priority The higher the priority, the sooner the listener get executed. Undefined priority listener will be executed last
+*/
+EventListeners.prototype.listen = function (listener, opt_priority) {
+	if (listener && Util.isFunction(listener)) {
+		if(this._listeners.indexOf(listener) < 0) {
+			if(opt_priority == null) {
+				this._listeners.push(listener);
+			} else {
+				listener._priority = opt_priority;
+				let at = Util.lowerBound(this._listeners, listener, 0, this._listeners.length, EventListeners.listenerComparer);
+				this._listeners.splice(at, 0, listener);
+			}
+		}
+	}
+};
+/** @public
+* @param {Function} listener
+*/
+EventListeners.prototype.unlisten = function (listener) {
+	if (listener) {
+		let index = this._listeners.indexOf(listener);
+		if (index >= 0) {
+			this._listeners.splice(index, 1);
+		}
+	}
+};
+/** @public
+*/
+EventListeners.prototype.unlistenAll = function () {
+	this._listeners.length = 0;
+};
+
+/** @public
+* @return {number}
+*/
+EventListeners.prototype.getListenerCount = function () {
+	return this._listeners.length;
+};
+/** @public
+* @return {boolean}
+*/
+EventListeners.prototype.hasListener = function () {
+	return this._listeners.length > 0;
+};
+
+/** @public
+* @param {*} eventArg
+*/
+EventListeners.prototype.dispatch = function (eventArg) {
+	if (!this._enabled || this._listeners.length <= 0) { return; }
+
+	if (this._dispatching) {
+		window.console.log("WARNING: There is an error in one of your binding methods.");
+	}
+	this._dispatching = true;
+
+	if (eventArg == null) { eventArg = {}; }
+
+	if (this._sender !== null) {
+		eventArg["sender"] = this._sender;
+	}
+
+	if (this._extender !== null) {
+		this._extender(/** @type{Object} */(eventArg));
+	}
+
+	for (let i = 0; i < this._listeners.length; i++) {
+		this._listeners[i](eventArg);
+	}
+
+	if(this._sender !== null) {
+		eventArg["sender"] = null; // Clear ref variable to prevent memory leak
+	}
+	this._dispatching = false;
+};
+/** @public
+* @return {boolean}
+*/
+EventListeners.prototype.isDispatching = function () {
+	return this._dispatching;
+};
+
+/** @public
+* @return {boolean}
+*/
+EventListeners.prototype.isEnabled = function () {
+	return this._enabled;
+};
+/** @public
+* @param {boolean=} opt_enabled
+*/
+EventListeners.prototype.enable = function (opt_enabled) {
+	this._enabled = (opt_enabled !== false);
+};
+/** @public
+* @param {boolean=} opt_disabled
+*/
+EventListeners.prototype.disable = function (opt_disabled) {
+	this._enabled = (opt_disabled === false);
+};
+
+/** Specifies "sender" reference to be added to the given event argument
+* @public
+* @param {*|null} sender
+*/
+EventListeners.prototype.setSender = function (sender) {
+	this._sender = sender || null;
+};
+/** Specifies a handler to be executed before every dispatching
+* @public
+* @param {Function=} extender
+*/
+EventListeners.prototype.setEventArgExtender = function (extender) {
+	this._extender = (extender != null) ? extender : null;
+};
+//#endregion Public methods
+
+//#region Private
+EventListeners.listenerComparer = function(a, b) {
+	if(b._priority == null) { return true; }
+	return a._priority >= b._priority; // Descending order
+};
+
+/** @private
+ * @type {Array.<function(*)>}
+ */
+EventListeners.prototype._listeners = null;
+
+/** @private
+ * @type {*|null}
+ */
+EventListeners.prototype._sender = null;
+/** @private
+ * @type {function(Object)|null}
+ */
+EventListeners.prototype._extender = null;
+
+/** @private
+ * @type {boolean}
+ */
+EventListeners.prototype._enabled = true;
+/** @private
+ * @type {boolean}
+ */
+EventListeners.prototype._dispatching = false;
+//#endregion  Private
+
+EventListeners._proto = EventListeners.prototype; // To allow compression of prototype keyword
+
+export default EventListeners;
+export { EventListeners };

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

@@ -0,0 +1,155 @@
+import Ext from "../../../../tr-grid-util/es6/Ext.js";
+import EventDispatcher from "../event/EventDispatcher.js";
+import Core from "../Core.js";
+import ILayoutGrid from "../ILayoutGrid.js";
+import ElementWrapper from "../components/ElementWrapper.js";
+import DataTable from "../../data/DataTable.js";
+import { isEmptyObject } from "../../../../tr-grid-util/es6/Util.js";
+
+declare namespace SortableTitlePlugin {
+
+    type SortOrder = "a" | "ascending" | "d" | "descending" | "n" | null|null;
+
+    type InitialSort = {
+        colIndex?: number|null,
+        colId?: string|null,
+        field?: string|null,
+        sortOrder?: SortableTitlePlugin.SortOrder|null,
+        order?: SortableTitlePlugin.SortOrder|null
+    };
+
+    type SortingDefinition = {
+        colIndex?: number|null,
+        colId?: string|null,
+        field?: string|null,
+        sortOrder?: SortableTitlePlugin.SortOrder|null,
+        order?: SortableTitlePlugin.SortOrder|null
+    };
+
+    type ColumnOptions = {
+        sortable?: boolean|null,
+        sortBy?: string|null,
+        sort?: string|null,
+        sortOrder?: string|null,
+        sortLogic?: DataTable.SortLogic|null,
+        sortingLogic?: DataTable.SortLogic|null,
+        sorter?: DataTable.SortLogic|null,
+        sortingSequence?: (SortableTitlePlugin.SortOrder)[]|null
+    };
+
+    type Options = {
+        initialSort?: (SortableTitlePlugin.InitialSort|(SortableTitlePlugin.SortingDefinition)[])|null,
+        multicolumn?: (boolean|number)|null,
+        multiColumn?: (boolean|number)|null,
+        threeStatesSorting?: boolean|null,
+        sortLogic?: { [key: string]:  DataTable.SortLogic }|null,
+        disableDoubleClickToSort?: boolean|null,
+        sortableColumns?: boolean|null,
+        sortableIndicator?: boolean|null,
+        indicatorOnly?: boolean|null,
+        mode?: string|null,
+        disabled?: boolean|null,
+        columnSorted?: ((...params: any[]) => any)|null,
+        preClicked?: ((...params: any[]) => any)|null,
+        clicked?: ((...params: any[]) => any)|null,
+        preDataSorting?: ((...params: any[]) => any)|null,
+        sortingSequence?: (SortableTitlePlugin.SortOrder)[]|null,
+        rowSorting?: boolean|null
+    };
+
+}
+
+declare class SortableTitlePlugin extends EventDispatcher {
+
+    constructor(options?: SortableTitlePlugin.Options|null);
+
+    public getName(): string;
+
+    public initialize(host: Core, options?: any): void;
+
+    public unload(host: Core): void;
+
+    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 }|null;
+
+    public setSortLogics(sortLogic: { [key: string]:  ((...params: any[]) => any) }|null): void;
+
+    public setSortLogic(field: string, func: ((...params: any[]) => any)|null): void;
+
+    public getSortOrder(colIndex?: number|null): string;
+
+    public getSortedColumnIndex(priority?: number|null): number;
+
+    public getSortPriority(colIndex: number, colRef?: string|null): number;
+
+    public isColumnSorted(colIndex: number): boolean;
+
+    public getSortedColumns(): (any)[]|null;
+
+    public isSorting(): boolean;
+
+    public sortColumn(colRef: number|string|null, sortOrder?: string|null, opt_arg?: any): void;
+
+    public sortColumns(sortOptions: (SortableTitlePlugin.SortingDefinition)[]|null, opt_arg?: any): void;
+
+    public clearSortState(opt_arg?: any): void;
+
+    public refresh(): void;
+
+    public restoreUserActions(): void;
+
+    public setSortableColumnCount(count: number): void;
+
+    public getSortingStates(): (any)[]|null;
+
+    public updateSortSymbols(): void;
+
+    public getDataColumnMap(): (string)[];
+
+    public setDataColumnMap(dataMap: (string|null)[]|null): void;
+
+    public getColumnSortingField(colIndex: number): string;
+
+    public setColumnSortingField(colIndex: number, field: string|null|null, sortLogic?: ((...params: any[]) => any)|null, rowSorting?: boolean|null): void;
+
+    public getColumnSortingFields(): (string)[];
+
+    public setFirstSortOrder(colIdentifier: string|number|(string|number)[]|null, sortOrder?: string|null): void;
+
+    public disableTwoStateSorting(disabled?: boolean|null): void;
+
+    public freezeIndicator(bool?: boolean|null): void;
+
+    public disableSortSymbols(disabled?: boolean|null): void;
+
+    public disableDataSorting(disabled?: boolean|null): void;
+
+    public disableDoubleClickToSort(disabled?: boolean|null): void;
+
+    public disableCellClick(cell: ElementWrapper|null, disabled?: boolean|null): void;
+
+    public disableColumnSorting(columns: number|(number)[]|null, disabled?: boolean|null): void;
+
+    public setClickDelayInterval(opt_ms?: number|null): void;
+
+    public getSortingSequence(colRef?: (number|string)|null): (string)[];
+
+    public setSortingSequence(sequence: (string)[]|null, colRef?: (number|string)|null): void;
+
+    public clearAllColumnSortingSequences(): void;
+
+    public sortSeparators(comparer: ((...params: any[]) => any)|null): void;
+
+}
+
+declare function len(disabled?: boolean|null): void;
+
+export default SortableTitlePlugin;
+export { SortableTitlePlugin };