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

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

@@ -0,0 +1,14 @@
+
+
+declare namespace Icon {
+
+    function create(iconName?: string, className?: string): Element;
+
+    function box(iconName?: string, className?: string, boxRef?: (string|Element)): Element;
+
+    function change(iconElem: Element, iconName?: string): void;
+
+}
+
+export default Icon;
+export {Icon};

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

@@ -0,0 +1,61 @@
+/** @namespace */
+var Icon = {};
+
+/** @public
+* @function
+* @param {string=} iconName
+* @param {string=} className
+* @return {!Element} ef-icon element
+*/
+Icon.create = function(iconName, className) {
+	var icon = document.createElement("ef-icon");
+	if(className) {
+		icon.className = className;
+	}
+	if(iconName) {
+		icon.setAttribute("icon", iconName);
+	}
+	return icon;
+};
+
+/** @public
+* @function
+* @param {string=} iconName
+* @param {string=} className Class name for the containing box
+* @param {(string|Element)=} boxRef
+* @return {!Element} Element that contains the newly created icon
+*/
+Icon.box = function(iconName, className, boxRef) {
+	var boxElem = null;
+	if(boxRef) {
+		if(typeof boxRef == "string") {
+			boxElem = document.createElement(boxRef);
+		} else if(boxRef.nodeType === 1) {
+			boxElem = /** @type{Element} */(boxRef);
+		}
+	}
+	if(!boxElem) {
+		boxElem = document.createElement("div");
+	}
+	if(className) {
+		boxElem.className = className;
+	}
+
+	boxElem.appendChild(Icon.create(iconName));
+	return boxElem;
+};
+
+/** @public
+* @function
+* @param {Element} iconElem ef-icon element
+* @param {string=} iconName
+*/
+Icon.change = function(iconElem, iconName) {
+	var curIcon = iconElem.getAttribute("icon");
+	if(curIcon !== iconName) {
+		iconElem.setAttribute("icon", iconName);
+	}
+};
+
+export default Icon;
+export {Icon};

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

@@ -0,0 +1,42 @@
+import {Ext} from "./Ext.js";
+import {EventDispatcher} from "./EventDispatcher.js";
+import {TouchProxy} from "./TouchProxy.js";
+
+declare namespace MouseDownTrait {
+
+    type Options = {
+        useDragStart?: boolean,
+        useTouchMove?: boolean,
+        preventDefault?: boolean
+    };
+
+}
+
+declare class MouseDownTrait extends EventDispatcher {
+
+    constructor(elem?: Element, options?: (string|MouseDownTrait.Options));
+
+    public dispose(): void;
+
+    public disable(opt_bool?: boolean): void;
+
+    public enable(opt_bool?: boolean): void;
+
+    public getElement(): Element;
+
+    public setElement(elem?: Element): void;
+
+    public reset(): void;
+
+    public getMouseDown(): any;
+
+    public isMouseDown(): boolean;
+
+    public isMouseUp(): boolean;
+
+    public getDuration(dateObj?: Date): number;
+
+}
+
+export {MouseDownTrait};
+export default MouseDownTrait;

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

@@ -0,0 +1,237 @@
+import {Ext} from "./Ext.js";
+import {EventDispatcher} from "./EventDispatcher.js";
+import {TouchProxy} from "./TouchProxy.js";
+
+/** @typedef {Object} MouseDownTrait~Options
+* @description MouseDownTrait options
+* @property {boolean=} useDragStart=false If enabled, native drarstart event will be used to trigger mouseDown event instead of native mousedown event
+* @property {boolean=} useTouchMove=false If enabled, touch events are added to the element
+* @property {boolean=} preventDefault=false If enabled, event default behaviors are prevented
+*/
+
+/** @event MouseDownTrait#mouseMove
+* @description Fired on each mousemove state, but only when mouse is holding down. WARNING: preventDefault in this event will also prevent mouseup when releasing mouse outside of window boundary.
+* @type {Object}
+* @see {@link MouseDownTrait#getMouseDown}
+*/
+/** @event MouseDownTrait#mouseDown
+* @description Fired on each mouse down on the element. For touch device, touchstart is treated as mousedown, and thus this event is fired twice in succession. Use {@link MouseDownTrait#change} event for more common use cases
+* @type {Object}
+*/
+/** @event MouseDownTrait#mouseUp
+* @description Mouseup is always fired regardless of area of element. For touch device, touchend will be fired as mouseup, and thus this event is fired twice in succession. This event is intended for clearing resource. Use {@link MouseDownTrait#change} event for more common use cases
+* @type {Object}
+* @property {number} duration - Indicates how long the mouse is holding down
+*/
+/** @event MouseDownTrait#change
+* @description Fired when mouse state has changed before both mousedown and mouseup events.
+* @type {Object}
+* @property {boolean} up - Indicates whether the mouse is down
+*/
+
+/** By default MouseDownTrait supports only left mouse button (0)
+* @constructor
+* @extends {EventDispatcher}
+* @param {Element=} elem
+* @param {(string|MouseDownTrait~Options)=} options String is treated as mouse mode (eg. left|middle|right), or Option object
+* @see {@link https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/button}
+* @example
+* var mdt = new MouseDownTrait(window);
+*/
+var MouseDownTrait = function(elem, options) {
+	this._onMouseDown = this._onMouseDown.bind(this);
+	this._onMouseUp = this._onMouseUp.bind(this);
+	this._onMouseMove = this._dispatch.bind(this, "mouseMove");
+
+	var obj;
+	if(options) {
+		if(typeof options == "string") {
+			var ch = options.charAt(0).toLowerCase();
+			if(ch === "m") { // Middle mouse
+				this._whichBtn = 1;
+			} else if(ch === "r") { // Right mouse
+				this._whichBtn = 2;
+			}
+		} else {
+			obj = options;
+			if(options["useDragStart"]) {
+				this._useDrag = true;
+			}
+		}
+	}
+
+	this._tchProxy = new TouchProxy(null, obj);
+	this._tchProxy.addTouchListeners(this._onMouseDown, this._onMouseUp, this._onMouseMove);
+	this.setElement(elem);
+};
+Ext.inherits(MouseDownTrait, EventDispatcher);
+
+/** @type {!TouchProxy}
+* @protected
+* @ignore
+*/
+MouseDownTrait.prototype._tchProxy;
+/** MousePosition of the mouse down
+* @type {Object}
+* @private
+*/
+MouseDownTrait.prototype._down = null;
+/** @type {number}
+* @private
+*/
+MouseDownTrait.prototype._whichBtn = 0;
+/** @type {boolean}
+* @private
+*/
+MouseDownTrait.prototype._useDrag = false;
+/** @type {boolean}
+* @private
+*/
+MouseDownTrait.prototype._disabled = false;
+/** @type {!Function}
+* @private
+*/
+MouseDownTrait.prototype._onMouseMove;
+
+
+/** @public */
+MouseDownTrait.prototype.dispose = function() {
+	this.unlistenAll();
+	this._tchProxy.dispose();
+	window.removeEventListener("mouseup", this._onMouseUp, false);
+};
+
+/** @public
+* @param {boolean=} opt_bool
+*/
+MouseDownTrait.prototype.disable = function(opt_bool) {
+	this._disabled = opt_bool !== false;
+	if(!this._disabled) {
+		this.reset();
+	}
+};
+/** @public
+* @param {boolean=} opt_bool
+*/
+MouseDownTrait.prototype.enable = function(opt_bool) {
+	this.disable(opt_bool === false);
+};
+
+/** @public
+* @return {Element}
+*/
+MouseDownTrait.prototype.getElement = function() {
+	return this._tchProxy.getElement();
+};
+/** @public
+* @param {Element=} elem
+*/
+MouseDownTrait.prototype.setElement = function(elem) {
+	var curElem = this._tchProxy.getElement();
+	if(curElem) {
+		curElem.removeEventListener("dragstart", EventDispatcher.preventDefault, false);
+		if(this._useDrag) {
+			curElem.removeEventListener("dragstart", this._onMouseDown, false);
+			curElem.removeAttribute("draggable");
+		} else {
+			curElem.removeEventListener("mousedown", this._onMouseDown, false);
+		}
+	}
+	this._tchProxy.setElement(elem);
+	curElem = this._tchProxy.getElement();
+	if(curElem) {
+		curElem.addEventListener("dragstart", EventDispatcher.preventDefault, false);
+		if(this._useDrag) {
+			curElem.addEventListener("dragstart", this._onMouseDown, false);
+			curElem.setAttribute("draggable", "true");
+		} else {
+			curElem.addEventListener("mousedown", this._onMouseDown, false);
+		}
+	}
+};
+/** @public */
+MouseDownTrait.prototype.reset = function() {
+	this._down = null;
+};
+
+/** @public
+* @return {Object}
+*/
+MouseDownTrait.prototype.getMouseDown = function() {
+	return this._down;
+};
+/** @public
+* @return {boolean}
+*/
+MouseDownTrait.prototype.isMouseDown = function() {
+	return this._down ? true : false;
+};
+/** @public
+* @return {boolean}
+*/
+MouseDownTrait.prototype.isMouseUp = function() {
+	return this._down ? false : true;
+};
+/** @public
+* @param {Date=} dateObj Date.now() is used if omitted
+* @return {number} Return milliseconds. Return 0 if the mouse is not hold down. Negative number can be returned
+*/
+MouseDownTrait.prototype.getDuration = function(dateObj) {
+	if(this._down) {
+		var timeInMs = dateObj ? dateObj.getTime() : Date.now();
+		return timeInMs - this._down["timeStamp"];
+	}
+	return 0;
+};
+
+/** @private
+* @param {Event} e
+*/
+MouseDownTrait.prototype._onMouseDown = function(e) {
+	if(this._disabled) { return; }
+	if(!this._isValidButton(e)) { return; }
+
+	window.addEventListener("mouseup", this._onMouseUp, false);
+	if(this.hasListener("mouseMove")) {
+		window.addEventListener("mousemove", this._onMouseMove, false);
+		this._tchProxy.attachTouchMoveEvent();
+	}
+
+	if(!this._down) {
+		this._down = TouchProxy.getPosition(e);
+		this._dispatch("change", e);
+	}
+	this._dispatch("mouseDown", e);
+};
+/** @private
+* @param {Event} e
+*/
+MouseDownTrait.prototype._onMouseUp = function(e) { // WARNING: Mouse Up at the window level
+	if(this._disabled) { return; }
+	if(!this._isValidButton(e)) { return; }
+
+	window.removeEventListener("mousemove", this._onMouseMove, false);
+	window.removeEventListener("mouseup", this._onMouseUp, false);
+	if(this.hasListener("mouseMove")) {
+		this._tchProxy.detachTouchMoveEvent();
+	}
+
+	if(this._down) {
+		e["duration"] = e.timeStamp - this._down["timeStamp"];
+		e["up"] = true; // Due to multiple event type
+		this._dispatch("change", e);
+	}
+
+	this._down = null;
+	this._dispatch("mouseUp", e);
+};
+/** @private
+* @param {Event} e
+* @return {boolean}
+*/
+MouseDownTrait.prototype._isValidButton = function(e) {
+	return TouchProxy.getButtonType(e) === this._whichBtn;
+};
+
+export {MouseDownTrait};
+export default MouseDownTrait;

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

@@ -0,0 +1,32 @@
+import { Ext } from "./Ext.js";
+import { EventDispatcher } from "./EventDispatcher.js";
+import { cloneObject } from "./Util.js";
+import { Deferred } from "./Deferred.js";
+import { Dom } from "./Dom.js";
+
+declare class MultiTableManager {
+
+    constructor(gridElem: Element);
+
+    public static synchronizeVScrollbar(vScrollbarHost: Element, hScrollbarHost: Element, gridElems: (Element)[]): Promise<any[]>;
+
+    public setGridConfig(configObj?: any): void;
+
+    public dispose(): void;
+
+    public getTableCount(): number;
+
+    public setTableCount(num: number): void;
+
+    public getTable(at?: number): Element;
+
+    public insertRow(rowOption?: any, at?: number): void;
+
+    public removeRow(at?: number): void;
+
+    public getRowCount(): number;
+
+}
+
+export default MultiTableManager;
+export { MultiTableManager };