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

package/lib/core/es6/grid/util/CellBoundPainter.d.ts

@@ -0,0 +1,16 @@
+
+
+declare class CellBoundPainter {
+
+    constructor(ctx: any);
+
+    public dispose(): void;
+
+    public setCellBounds(colIndex: number, rowIndex: number, width: number, height: number, colCount: number): void;
+
+    public updateCellBounds(): void;
+
+}
+
+export default CellBoundPainter;
+export { CellBoundPainter };

package/lib/core/es6/grid/util/CellBoundPainter.js

@@ -0,0 +1,171 @@
+/** @private
+* @function
+* @param {number} idx
+* @param {number} limit
+* @return {number}
+*/
+let _validateIndex = function(idx, limit) {
+	if(idx > limit) {
+		return limit;
+	} else if(idx < 0) {
+		return 0;
+	}
+	return idx;
+};
+
+/** @constructor
+* @param {Object} ctx
+*/
+let CellBoundPainter = function (ctx) {
+	this._boundLayer = ctx.boundLayer;
+	this._layoutX = ctx.layoutX;
+	this._layoutY = ctx.layoutY;
+	this._hscrollbar = ctx.hscrollbar;
+	this._calculateColumnBounds = ctx.calculateColumnBounds;
+};
+
+/** @type {Element}
+* @private
+*/
+CellBoundPainter.prototype._boundLayer = null;
+/** @type {!TrackLayout}
+* @private
+*/
+CellBoundPainter.prototype._layoutX;
+/** @type {!TrackLayout}
+* @private
+*/
+CellBoundPainter.prototype._layoutY;
+/** @type {HScrollbar}
+* @private
+*/
+CellBoundPainter.prototype._hscrollbar;
+/** @type {Function}
+* @private
+*/
+CellBoundPainter.prototype._calculateColumnBounds;
+/** @type {Element}
+* @private
+*/
+CellBoundPainter.prototype._cellBound = null;
+/** @type {number}
+* @private
+*/
+CellBoundPainter.prototype._cbLftIdx = 0;
+/** @type {number}
+* @private
+*/
+CellBoundPainter.prototype._cbRgtIdx = 0;
+/** @type {number}
+* @private
+*/
+CellBoundPainter.prototype._cbTopIdx = 0;
+/** @type {number}
+* @private
+*/
+CellBoundPainter.prototype._cbBtmIdx = 0;
+
+/** @public
+*/
+CellBoundPainter.prototype.dispose = function () {
+	let cellBound = this._cellBound;
+	if(cellBound) {
+		let pn = cellBound.parentNode;
+		if(pn) {
+			pn.removeChild(cellBound);
+		}
+		this._cellBound = null;
+	}
+	this._boundLayer = null;
+	this._layoutX = null;
+	this._layoutY = null;
+	this._hscrollbar = null;
+	this._calculateColumnBounds = null;
+};
+
+/** @public
+* @param {number} colIndex
+* @param {number} rowIndex
+* @param {number} width
+* @param {number} height
+* @param {number} colCount
+*/
+CellBoundPainter.prototype.setCellBounds = function (colIndex, rowIndex, width, height, colCount) {
+	let cellBound = this._cellBound;
+	if(!cellBound) {
+		cellBound = this._cellBound = document.createElement("div");
+		cellBound.className = "selection-bound";
+	}
+
+	// Validate inputs
+	let rgtIndex = colIndex + width; // Exclusive
+	let btmIndex = rowIndex + height; // Exclusive
+
+	let rowCount = this._layoutY.getLaneCount();
+
+	this._cbLftIdx = _validateIndex(colIndex, colCount);
+	this._cbRgtIdx = _validateIndex(rgtIndex, colCount);
+	this._cbTopIdx = _validateIndex(rowIndex, rowCount);
+	this._cbBtmIdx = _validateIndex(btmIndex, rowCount);
+
+	this.updateCellBounds();
+};
+
+/** @public
+*/
+CellBoundPainter.prototype.updateCellBounds = function() {
+	let cellBound = this._cellBound;
+	if(!cellBound) {
+		return;
+	}
+
+	let layoutX = this._layoutX;
+	let layoutY = this._layoutY;
+	let lftIdx = this._cbLftIdx;
+	let rgtIdx = this._cbRgtIdx; // Exclusive
+	let topIdx = this._cbTopIdx;
+	let btmIdx = this._cbBtmIdx; // Exclusive
+	let lftPx, rgtPx, topPx, btmPx;
+	lftPx = rgtPx = topPx = btmPx = 0;
+	if(lftIdx < rgtIdx && topIdx < btmIdx) {
+		lftPx = layoutX.getLaneStart(lftIdx);
+		rgtPx = layoutX.getLaneEnd(rgtIdx - 1);
+		topPx = layoutY.getLaneStart(topIdx);
+		btmPx = layoutY.getLaneEnd(btmIdx - 1);
+	}
+
+	let width = rgtPx - lftPx;
+	let height = btmPx - topPx;
+	let noBorders = [false, false];
+	if(width > 0 && height > 0 && this._hscrollbar) {
+		let positions = [0, 0];
+		this._calculateColumnBounds(lftIdx, rgtIdx - 1, positions, noBorders);
+		lftPx = positions[0];
+		rgtPx = positions[1];
+		width = rgtPx - lftPx;
+	}
+
+	if(width > 0) {
+		cellBound.style.left = lftPx + "px";
+		cellBound.style.top = topPx + "px";
+		cellBound.style.width = width + "px";
+		cellBound.style.height = height + "px";
+
+		cellBound.classList.toggle("no-left-bound", noBorders[0]);
+		cellBound.classList.toggle("no-right-bound", noBorders[1]);
+
+		if(this._boundLayer) {
+			this._boundLayer.appendChild(cellBound);
+		}
+	} else {
+		let pn = cellBound.parentNode;
+		if(pn) {
+			pn.removeChild(cellBound);
+		}
+	}
+};
+
+CellBoundPainter._proto = CellBoundPainter.prototype;
+
+export default CellBoundPainter;
+export { CellBoundPainter };

package/lib/core/es6/grid/util/Conflator.d.ts

@@ -0,0 +1,32 @@
+
+
+declare class Conflator {
+
+    constructor(opt_func?: ((...params: any[]) => any)|number|null, opt_ms?: number|((...params: any[]) => any)|null, opt_thisObj?: any);
+
+    public reset(): any[]|null;
+
+    public popAllData(): any[]|null;
+
+    public dispose(): void;
+
+    public conflate(opt_data?: any): boolean;
+
+    public isConflating(): boolean;
+
+    public getData(): any[];
+
+    public setFunction(func: ((...params: any[]) => any)|null, opt_thisObj?: any): void;
+
+    public setConflatingTime(ms: number): void;
+
+    public disable(opt_disabled?: boolean|null): void;
+
+    public isEnabled(): boolean;
+
+    public enable(opt_enabled?: boolean|null): void;
+
+}
+
+export default Conflator;
+export { Conflator };

package/lib/core/es6/grid/util/Conflator.js

@@ -0,0 +1,191 @@
+
+/** @description Conflator is used to stop multiple executions of a function in the specified period of time by merging multiple calls into one single call.
+* Conflator guarantees that only one single call will be executed.
+* @constructor
+* @param {Function|number=} opt_func Bound function that will use this conflator
+* @param {number|Function=} opt_ms The delay time in millisecond before executing the function
+* @param {*=} opt_thisObj "this" object to be bound with the given function. If the function is already bound, there is no need to provide thisObj parameter
+* @example
+* let c = new Conflator(function() { console.log("Executed"); }, 1000);
+* for(let i = 10; --i >= 0;) {
+*   c.conflate(i); // Only one "Executed" text will be logged to console after one second
+* }
+*/
+let Conflator = function (opt_func, opt_ms, opt_thisObj) {
+	this._onConflated = this._onConflated.bind(this);
+
+	this._data = [];
+
+	if(typeof opt_func == "function") {
+		this.setFunction(opt_func, opt_thisObj);
+	} else if (typeof opt_ms == "function") { // Parameter can be swapped places
+		this.setFunction(opt_ms, opt_thisObj);
+	}
+
+	if(typeof opt_ms == "number") {
+		this.setConflatingTime(opt_ms);
+	} else if (typeof opt_func == "number") { // Parameter can be swapped places
+		this.setConflatingTime(opt_func);
+	}
+};
+
+/** @type {!Array}
+* @private
+*/
+Conflator.prototype._data; // Array to store all conflated data
+/** @type {Function}
+* @private
+*/
+Conflator.prototype._func = null;
+/** @type {number}
+* @private
+*/
+Conflator.prototype._delay = 0;
+/** @type {number}
+* @private
+*/
+Conflator.prototype._timerId = 0;
+/** @type {boolean}
+* @private
+*/
+Conflator.prototype._conflated = false;
+/** @type {boolean}
+* @private
+*/
+Conflator.prototype._disabled = false;
+
+
+/** @description Any existing timer and stored data will be cleared.
+* @public
+* @return {Array} All stored data. Return null if there is no data
+*/
+Conflator.prototype.reset = function () {
+	if(this._timerId) {
+		clearTimeout(this._timerId);
+		this._timerId = 0;
+	}
+
+	return this.popAllData();
+};
+/** All stored data will be cleared
+* @public
+* @return {Array} All stored data. Return null if there is no data
+*/
+Conflator.prototype.popAllData = function() {
+	if(this._data.length) {
+		let data = this._data;
+		this._data = [];
+		return data;
+	}
+	return null;
+};
+/** @public
+*/
+Conflator.prototype.dispose = function () {
+	if(this._timerId) {
+		clearTimeout(this._timerId);
+		this._timerId = 0;
+	}
+	if(this._data.length) {
+		this._data.length = 0;
+	}
+	this._func = null; // Release user bound function
+};
+
+/** @public
+* @param {*=} opt_data
+* @return {boolean}
+*/
+Conflator.prototype.conflate = function (opt_data) {
+	if(this._disabled) {
+		return false;
+	}
+	if(opt_data != null) {
+		this._data.push(opt_data);
+	}
+	if(this._conflated) {
+		return false; // Conflating operation is already completed
+	}
+	if(!this._timerId) {
+		this._timerId = setTimeout(this._onConflated, this._delay);
+	}
+	return true;
+};
+/** @public
+* @return {boolean}
+*/
+Conflator.prototype.isConflating = function () {
+	return (this._timerId > 0 && !this._conflated && !this._disabled);
+};
+
+/** @private
+*/
+Conflator.prototype._onConflated = function () {
+	this._conflated = true;
+
+	try {
+		this._func();
+	} catch (err) {
+		console.error(err.message || err);
+	}
+
+	this._timerId = 0;
+	this._data.length = 0;
+	this._conflated = false;
+};
+
+/** @public
+* @return {!Array}
+*/
+Conflator.prototype.getData = function () {
+	return this._data;
+};
+/** @public
+* @param {Function} func Bound function that will use this conflator
+* @param {*=} opt_thisObj "this" object to be bound with the given function. If the function is already bound, there is no need to provide thisObj parameter
+*/
+Conflator.prototype.setFunction = function (func, opt_thisObj) {
+	this._func = func;
+	if(func) {
+		if(opt_thisObj) {
+			this._func = func.bind(opt_thisObj);
+		} else {
+			this._func = func;
+		}
+	} else {
+		this._func = null;
+	}
+};
+/** @public
+* @param {number} ms The delay time in millisecond before executing the function
+*/
+Conflator.prototype.setConflatingTime = function (ms) {
+	this._delay = ms || 0;
+	if(this._delay < 0) {
+		this._delay = 0;
+	}
+};
+
+/** @public
+* @param {boolean=} opt_disabled
+*/
+Conflator.prototype.disable = function (opt_disabled) {
+	this._disabled = opt_disabled !== false;
+};
+/** @public
+* @return {boolean}
+*/
+Conflator.prototype.isEnabled = function () {
+	return !this._disabled;
+};
+/** @public
+* @param {boolean=} opt_enabled
+*/
+Conflator.prototype.enable = function (opt_enabled) {
+	this._disabled = opt_enabled === false;
+};
+
+Conflator._proto = Conflator.prototype;
+
+export default Conflator;
+export { Conflator };

package/lib/core/es6/grid/util/Reverter.d.ts

@@ -0,0 +1,14 @@
+
+
+declare class Reverter {
+
+    constructor(opt_func?: ((...params: any[]) => any)|number|null, opt_ms?: number|((...params: any[]) => any)|null);
+
+    public start(): void;
+
+    public dispose(): void;
+
+}
+
+export default Reverter;
+export { Reverter };

package/lib/core/es6/grid/util/Reverter.js

@@ -0,0 +1,79 @@
+
+/** @description Reverter is used executed the given method after the specified delay. If Reverter is activated the second time within the delay, the delay time will be extended.
+* @constructor
+* @param {Function|number=} opt_func
+* @param {number|Function=} opt_ms The delay time in millisecond before executing the function
+*/
+let Reverter = function (opt_func, opt_ms) {
+	this._onInterval = this._onInterval.bind(this);
+
+	if(typeof opt_func == "function") {
+		this._func = opt_func;
+	} else if (typeof opt_ms == "function") { // Parameter can be swapped places
+		this._func = opt_ms;
+	}
+
+	if(typeof opt_ms == "number") {
+		this._delay = opt_ms;
+	} else if (typeof opt_func == "number") { // Parameter can be swapped places
+		this._delay = opt_func;
+	}
+};
+
+/** @type {Function}
+* @private
+*/
+Reverter.prototype._func = null;
+/** @type {number}
+* @private
+*/
+Reverter.prototype._delay = 0;
+/** @type {number}
+* @private
+*/
+Reverter.prototype._timerId = 0;
+/** @type {boolean}
+* @private
+*/
+Reverter.prototype._pending = false;
+
+
+/** @public
+*/
+Reverter.prototype.start = function () {
+	if(this._func) {
+		if(!this._timerId) {
+			this._timerId = setInterval(this._onInterval, this._delay);
+		} else {
+			this._pending = true;
+		}
+	}
+};
+
+/** @public
+*/
+Reverter.prototype.dispose = function () {
+	if(this._timerId) {
+		clearInterval(this._timerId);
+		this._timerId = 0;
+	}
+	this._func = null; // Release user bound function
+};
+
+
+/** @private
+*/
+Reverter.prototype._onInterval = function () {
+	if(this._pending) {
+		this._pending = false;
+	} else {
+		this._func();
+		clearInterval(this._timerId);
+		this._timerId = 0;
+	}
+};
+
+Reverter._proto = Reverter.prototype;
+
+export default Reverter;
+export { Reverter };

package/lib/core/es6/grid/util/SectionSettings.d.ts

@@ -0,0 +1,79 @@
+import Ext from "../../../../tr-grid-util/es6/Ext.js";
+import Util from "../util/util.js";
+import EventDispatcher from "../event/EventDispatcher.js";
+import ILayoutGrid from "../ILayoutGrid.js";
+import LayoutGrid from "../LayoutGrid.js";
+import DataTable from "../../data/DataTable.js";
+import DataView from "../../data/DataView.js";
+import Conflator from "../util/Conflator.js";
+
+declare class SectionSettings extends EventDispatcher {
+
+    constructor(grid: ILayoutGrid);
+
+    public getId(): string;
+
+    public setId(str?: string|null): string;
+
+    public getSection(): ILayoutGrid|null;
+
+    public getSectionName(): string;
+
+    public getIndex(): number;
+
+    public getType(): string;
+
+    public setType(type: string): void;
+
+    public getDataSource(): DataView|null;
+
+    public setDataSource(dataView: DataView|null): void;
+
+    public getRootDataSource(): DataTable|DataView|null;
+
+    public getData(colName: string, rowRef: number|string|null): any;
+
+    public setData(colName: string, rowRef: number|string|null, data: any): boolean;
+
+    public getRowData(rowRef: number|string|null): { [key: string]:  any };
+
+    public removeRowData(rowRef: number|string|null): boolean;
+
+    public activateColumns(activations: (boolean|undefined)[]|null, firstIndex: number, lastIndex: number): void;
+
+    public getChildren(): (SectionSettings)[]|null;
+
+    public getParent(): SectionSettings|null;
+
+    public getDataChangedConflator(): Conflator;
+
+    public disableConflation(opt_disabled: boolean): void;
+
+    public disableDataBinding(opt_disabled?: boolean|null): void;
+
+    public getAutoSyncRowCount(): boolean;
+
+    public setAutoSyncRowCount(bool: boolean): void;
+
+    public extendEventArg(e?: any): any;
+
+    public extendRenderEventArg(e: any, fromR: number, toR: number): any;
+
+    public extendDataEventArg(e?: any, begin?: number|null, end?: number|null): any;
+
+    public enableColumnVirtualization(opt_enabled?: boolean|null): void;
+
+    public isBinding(): boolean;
+
+    public updateRowData(fromRowIndex?: number|null, lastRowIndex?: number|null, e?: any): void;
+
+    public rerender(): void;
+
+    public snapshot(clone: ILayoutGrid|null): void;
+
+}
+
+declare function rowIndex(activations: (boolean|undefined)[]|null, firstIndex: number, lastIndex: number): void;
+
+export default SectionSettings;
+export { SectionSettings };