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

package/lib/tr-grid-util/es6/EventDispatcher.js

@@ -0,0 +1,161 @@
+/** Abstract base class that provides event management methods for derived class
+* @constructor
+*/
+var EventDispatcher = function () {};
+
+/** @type {Object.<string, Function>}
+* @protected
+* @ignore
+*/
+EventDispatcher.prototype._events = null;
+/** @type {number}
+* @protected
+* @ignore
+*/
+EventDispatcher.prototype._listenerCount = 0;
+
+//#region public function of event
+/** Add the function handler into the specific event.
+* @public
+* @param {string} type Event name
+* @param {Function} handler Event handler
+*/
+EventDispatcher.prototype.addEventListener = function(type, handler) {
+	if(!type || !handler) { return; }
+	if(!this._events) {
+		this._events = {};
+	}
+
+	var listeners = this._events[type];
+	if(listeners) {
+		if(listeners.indexOf(handler) < 0) {
+			listeners.push(handler);
+			++this._listenerCount;
+		}
+	} else {
+		this._events[type] = [handler];
+		++this._listenerCount;
+	}
+};
+/** Remove the function handler from the specific event.
+* @public
+* @param {string} type Event name
+* @param {Function} handler Event handler
+*/
+EventDispatcher.prototype.removeEventListener = function(type, handler) {
+	var listeners = (this._events) ? this._events[type] : null;
+	if(listeners) {
+		var at = listeners.indexOf(handler);
+		if(at >= 0) {
+			listeners.splice(at, 1);
+			--this._listenerCount;
+		}
+	}
+};
+/** Remove all function handlers from all events.
+* @public
+*/
+EventDispatcher.prototype.removeAllEventListeners = function() {
+	this._events = null;
+	this._listenerCount = 0;
+};
+
+/** Check whether the specified event has a function handler.
+* @public
+* @param {string} type Event name
+* @return {boolean}
+*/
+EventDispatcher.prototype.hasListener = function(type) {
+	if(this._listenerCount) {
+		if(type) {
+			var listeners = this._events ? this._events[type] : null;
+			return listeners ? (listeners.length > 0) : false;
+		} else {
+			return true;
+		}
+	} else {
+		return false;
+	}
+};
+/** Get event listener (function handler) from the specified event.
+* @public
+* @param {string} type Event name
+* @param {number=} idx=0 Index of the listener to be retrieved. This is used when there are multiple event listeners
+* @return {Function}
+*/
+EventDispatcher.prototype.getListener = function(type, idx) {
+	if(type) {
+		var listeners = this._events ? this._events[type] : null;
+		if(listeners) {
+			if(!idx) {
+				idx = 0;
+			}
+			return listeners[idx] || null;
+		}
+	}
+	return null;
+};
+/** A shorthand to retrieve function from an object and add it as an Eventlistener
+* @public
+* @function
+* @param {Object} obj Object that contains a handler with the same name as the given `type`
+* @param {string} type Event name
+* @example
+* var obj = {"mouseUp": function(e) { console.log(e); }};
+* plugin.addListener(obj, "mouseUp");
+* plugin.addListener(obj, "mouseDown");
+*/
+EventDispatcher.prototype.addListener = function(obj, type) {
+	var func = obj ? obj[type] : null;
+	if(typeof func === "function") {
+		this.addEventListener(type, func);
+	}
+};
+
+/** Executed before dispatching, allowing modification of user's event argument object
+* @protected
+* @ignore
+* @param {string} type Event name
+* @param {Object} eventArg User's event argument object
+* @return {Object} New event argument object
+*/
+EventDispatcher.prototype._prepareEventArguments = function(type, eventArg) {
+	return eventArg;
+};
+
+/** Publish the data to the listener.
+* @protected
+* @ignore
+* @param {string} type Event name
+* @param {Object} eventArg Event arguments
+*/
+EventDispatcher.prototype._dispatch = function(type, eventArg) {
+	var listeners = this._events ? this._events[type] : null;
+	if(listeners) {
+		eventArg = this._prepareEventArguments(type, eventArg);
+		var len = listeners.length;
+		for(var i = 0; i < len; ++i) {
+			listeners[i](eventArg);
+		}
+	}
+};
+
+/** @public
+* @function
+* @param {Event} e
+*/
+var preventDefault = function(e) {
+	if(e && e.preventDefault) {
+		e.preventDefault();
+		e.stopPropagation();
+	}
+};
+
+/** @public
+* @function
+* @param {Event} e
+*/
+EventDispatcher.preventDefault = preventDefault;
+
+export default EventDispatcher;
+export {EventDispatcher, preventDefault};

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

@@ -0,0 +1,27 @@
+import { Ext } from "./Ext.js";
+import { injectCss, prettifyCss } from "./Util.js";
+import { ElementWrapper } from "./ElementWrapper.js";
+import { ElfUtil } from "./ElfUtil.js";
+
+declare class ExpanderIcon extends ElementWrapper {
+
+    constructor();
+
+    public static loadExpanderStyles(): void;
+
+    public static injectExpanderStyles(elem: Element): void;
+
+    public expand(): void;
+
+    public collapse(): void;
+
+    public isExpanded(): boolean;
+
+    public isCollapsed(): boolean;
+
+    public toggle(collapsed?: boolean): void;
+
+}
+
+export default ExpanderIcon;
+export { ExpanderIcon };

package/lib/tr-grid-util/es6/ExpanderIcon.js

@@ -0,0 +1,169 @@
+import { Ext } from "./Ext.js";
+import { injectCss, prettifyCss } from "./Util.js";
+import { ElementWrapper } from "./ElementWrapper.js";
+import { ElfUtil } from "./ElfUtil.js";
+
+
+/**
+* @constructor
+* @extends {ElementWrapper}
+*/
+var ExpanderIcon = function () {
+	var elem;
+	if (ExpanderIcon._iconName) {
+		elem = document.createElement("ef-icon");
+		elem.setAttribute("icon", ExpanderIcon._iconName);
+	} else {
+		elem = document.createElement("span");
+		var fallback = document.createElement("span");
+		fallback.className = "fallback-arrow";
+		fallback.textContent = "\u25bc";
+		elem.appendChild(fallback);
+	}
+	this._elem = elem;
+	elem.classList.add("expander");
+
+	elem.addEventListener("mousedown", ExpanderIcon._stopPropagation, false);
+	elem.addEventListener("click", ExpanderIcon._stopPropagation, false);
+};
+Ext.inherits(ExpanderIcon, ElementWrapper);
+
+/** @type {string}
+* @private
+*/
+ExpanderIcon._iconName = ""; // static variable
+
+/** @description .expander is the actual arrow <br>
+* .folder is an element hosting .expander arrow
+* @type {string}
+* @private
+*/
+ExpanderIcon._styles = prettifyCss([
+	".tr-grid .expander-disabled .expander", [
+		"cursor: default;"
+	],
+	".tr-grid .folder-disabled .column .cell.folder", [
+		"cursor: default;"
+	],
+	".tr-grid .expander", [
+		"cursor: pointer;",
+		"display: inline-block;" // For transformation
+	],
+	".tr-grid .folder .expander:before", [
+		"content: none !important;" // Prevent deprecated styling
+	],
+	".tr-grid .fallback-arrow", [
+		"vertical-align: middle;",
+		"font-size: 7px;",
+		"line-height: 1;",
+		"display: inline-block;", // For transformation
+		"transform: scaleX(1.5);",
+		"font-family: Arial;"
+	],
+	".tr-grid .expander.closed", [
+		"transform: translate(0px, -1px) rotate(-90deg);"
+	],
+	".tr-grid .cell.closed .expander", [
+		"transform: translate(0px, -1px) rotate(-90deg);"
+	],
+	".tr-grid .tr-lg .cell.folder.content-header", [ // Used for header row in contentAsHeader mode, espectially with solar theme
+	  "background-color: inherit;"
+	]
+]);
+
+/** @private
+* @param {Event} e
+*/
+ExpanderIcon._stopPropagation = function(e) {
+	e.stopPropagation();
+};
+/** @private
+*/
+ExpanderIcon._onThemeLoaded = function() {
+	if(ElfUtil.isHaloTheme()) {
+		ExpanderIcon._iconName = "down";
+	}
+};
+
+/** @public
+*/
+ExpanderIcon.loadExpanderStyles = function() {
+	if(!ExpanderIcon._iconName) {
+		var themeName = ElfUtil.getThemeName();
+
+		if(themeName) {
+			ExpanderIcon._onThemeLoaded(); // synchronous
+		} else {
+			ElfUtil.getThemeColors().then(ExpanderIcon._onThemeLoaded); // asynchronous
+		}
+	}
+};
+/** @public
+* @param {Element} elem
+*/
+ExpanderIcon.injectExpanderStyles = function(elem) {
+	if(elem && elem.nodeType === 1 && !elem._expanderStyles) {
+		elem._expanderStyles = true; // Prevent loading the same style twice
+		injectCss(ExpanderIcon._styles, elem);
+	}
+};
+
+/** @private
+* @param {Object} cell
+* @param {boolean=} removal
+* @return {ExpanderIcon} Return ExpanderIcon object only if Expander is newly created
+*/
+ExpanderIcon.renderOn = function (cell, removal) {
+	var newExpander = null;
+	if (removal) {
+		cell.removeIcon();
+	} else {
+		var expander = cell._expanderIcon;
+		if (!expander) {
+			expander = cell._expanderIcon = newExpander = new ExpanderIcon();
+		}
+
+		cell.updateIcon(expander.getElement());
+	}
+	return newExpander;
+};
+
+/** @public
+*/
+ExpanderIcon.prototype.expand = function () {
+	this._elem.classList.remove("closed");
+};
+/** @public
+*/
+ExpanderIcon.prototype.collapse = function () {
+	this._elem.classList.add("closed");
+};
+/** @public
+* @return {boolean}
+*/
+ExpanderIcon.prototype.isExpanded = function () {
+	return !this._elem.classList.contains("closed");
+};
+/** @public
+* @return {boolean}
+*/
+ExpanderIcon.prototype.isCollapsed = function () {
+	return this._elem.classList.contains("closed");
+};
+/** @public
+* @param {boolean=} collapsed Set to true to force collapsing state. Set to false to force expanding state
+*/
+ExpanderIcon.prototype.toggle = function (collapsed) {
+	if(collapsed == null) {
+		collapsed = !this.isCollapsed();
+	}
+	if(collapsed) {
+		this.collapse();
+	} else {
+		this.expand();
+	}
+};
+
+
+export default ExpanderIcon;
+export { ExpanderIcon };

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

@@ -0,0 +1,10 @@
+
+
+declare namespace Ext {
+
+    function inherits(childCtor: ((...params: any[]) => any), parentCtor: ((...params: any[]) => any)): void;
+
+}
+
+export default Ext;
+export {Ext};

package/lib/tr-grid-util/es6/Ext.js

@@ -0,0 +1,52 @@
+/** Provide ability for prototype based Class to inherits another class
+* @namespace
+* @example
+* var BaseClass = function() {};
+* BaseClass.prototype.method = function() {};
+* BaseClass.prototype._member = 1;
+* var DerivedClass = function() {};
+* Ext.inherits(DerivedClass, BaseClass); // Derived class will have methods and members of the base class
+* // To call base class method
+* DeriveClass["base"](this, "methodName", ...params);
+*/
+var Ext = {};
+
+/** @public
+* @function
+* @param {Function} childCtor
+* @param {Function} parentCtor
+*/
+Ext.inherits = function (childCtor, parentCtor) {
+	/** @constructor
+* @ignore
+*/
+	function tempCtor() { }
+	tempCtor.prototype = parentCtor.prototype;
+	childCtor.prototype = new tempCtor();
+	childCtor.prototype.constructor = childCtor;
+
+	/** Calls superclass constructor/method. <br>
+* This function is only available if you use goog.inherits to <br>
+* express inheritance relationships between classes. <br>
+* NOTE: This is a replacement for goog.base and for superClass_ <br>
+* property defined in childCtor.
+* @param {!Object} me Should always be "this".
+* @param {(string|null)=} methodName The method name to call. Calling superclass constructor can be done with the special string 'constructor'.
+* @param {...*} var_args The arguments to pass to superclass <br>
+* method/constructor.
+* @return {*} The return value of the superclass method/constructor.
+*/
+	childCtor["base"] = function(me, methodName, var_args) {
+		if(!methodName) { methodName = 'constructor'; }
+		// Copying using loop to avoid deop due to passing arguments object to function. This is faster in many JS engines as of late 2014.
+		var len = arguments.length;
+		var args = new Array(len); // http://jsperf.com/creating-an-array
+		for (var i = 2; i < len; i++) {
+			args[i - 2] = arguments[i];
+		}
+		return parentCtor.prototype[methodName].apply(me, args);
+	};
+};
+
+export default Ext;
+export {Ext};

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

@@ -0,0 +1,55 @@
+import { NumberFormatter } from "./NumberFormatter.js"; // eslint-disable-line
+import { DateTime } from "./DateTime.js";
+
+declare namespace FieldFormatter {
+
+    type Options = {
+        formatType?: string,
+        type: string,
+        field?: string,
+        fieldDataType?: string,
+        dateTimeFormat?: string,
+        useUTCTime?: boolean,
+        idnSource?: string
+    };
+
+}
+
+declare class FieldFormatter {
+
+    constructor(options?: FieldFormatter.Options);
+
+    public init(options?: FieldFormatter.Options): void;
+
+    public getOptions(options?: any): any;
+
+    public getField(): string;
+
+    public clone(): FieldFormatter;
+
+    public setFormatType(type: string): void;
+
+    public setField(field: string, combinedField?: string, formattedField?: string): void;
+
+    public setDateTimeMeta(format: string, gmtTimeZone?: boolean, inputSource?: string, lang?: string): void;
+
+    public setDateFormatter(func: ((...params: any[]) => any)): void;
+
+    public setNumberFormatter(formatter: ((...params: any[]) => any)|NumberFormatter): void;
+
+    public format(data: any): string;
+
+    public formatRowData(rowData: any): string;
+
+    public formatValue(val: any): string;
+
+}
+
+declare const DATE_TIME: string;
+
+declare function toDateTimeType(formatType: string): string;
+
+declare function fieldDataType(options?: any): any;
+
+export default FieldFormatter;
+export {FieldFormatter, DATE_TIME, toDateTimeType};