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

package/lib/core/es6/grid/components/CellFloatingPanel.d.ts

@@ -0,0 +1,21 @@
+import Ext from "../../../../tr-grid-util/es6/Ext.js";
+import ElementWrapper from "./ElementWrapper.js";
+
+declare class CellFloatingPanel extends ElementWrapper {
+
+    constructor();
+
+    public hasItem(): boolean;
+
+    public containItem(icon: Element|null): boolean;
+
+    public insertItem(item: Element|null, opt_order?: number|null): void;
+
+    public removeItem(elemRef?: (Element|string)|null): Element|null|null;
+
+    public clearItems(): void;
+
+}
+
+export default CellFloatingPanel;
+export { CellFloatingPanel };

package/lib/core/es6/grid/components/CellFloatingPanel.js

@@ -0,0 +1,130 @@
+/* eslint-disable */
+import Ext from "../../../../tr-grid-util/es6/Ext.js";
+import ElementWrapper from "./ElementWrapper.js";
+/* eslint-enable */
+
+/** @constructor
+* @extends {ElementWrapper}
+*/
+let CellFloatingPanel = function () {
+	this._items = [];
+	this._element = null;
+};
+Ext.inherits(CellFloatingPanel, ElementWrapper);
+
+/** @public
+* @type {Array.<Element>}
+*/
+CellFloatingPanel.prototype._items = [];
+
+/** @public
+ * @returns {boolean}
+*/
+CellFloatingPanel.prototype.hasItem = function () {
+	return !!this._items.length;
+};
+/** @public
+ * @param {Element} icon Element of item
+ * @returns {boolean}
+*/
+CellFloatingPanel.prototype.containItem = function (icon) {
+	return this._items.indexOf(icon) > -1;
+};
+/** @public
+* @param {Element} item
+* @param {number=} opt_order The greater the order, the farther the position to the right
+*/
+CellFloatingPanel.prototype.insertItem = function (item, opt_order) {
+	let items = this._items;
+	if(items.indexOf(item) > -1) {
+		return; // There is no need to insert the same icon
+	}
+	items.push(item);
+
+	// Ordering icons
+	if(opt_order) {
+		item._order = opt_order;
+	}
+	if (items.length) {
+		items.sort(CellFloatingPanel._iconComparer);
+	}
+	this._updatePanelItems();
+};
+/** @public
+* @param {(Element|string)=} elemRef This can be the element or className (string) of the icon. If not specified, the last item will be remove.
+* @return {Element|null} removed element
+*/
+CellFloatingPanel.prototype.removeItem = function (elemRef) {
+	let items = this._items;
+	let targetIndex = -1;
+	if (!elemRef) {
+		targetIndex = items.length - 1;
+	} else {
+		for(let i = items.length; --i >= 0;) {
+			let ch = items[i];
+			if (typeof elemRef === "string") {
+				if(ch.classList.contains(elemRef)) {
+					targetIndex = i;
+					break;
+				}
+			} else {
+				if (ch === elemRef) {
+					targetIndex = i;
+					break;
+				}
+			}
+		}
+	}
+	let removedItem = null;
+	if (targetIndex > -1) {
+		removedItem = items.splice(targetIndex, 1)[0];
+	}
+	this._updatePanelItems();
+	return removedItem;
+};
+/** @public
+*/
+CellFloatingPanel.prototype.clearItems = function () {
+	let items = this._items;
+	if (!items.length) {
+		return;
+	}
+	items.length = 0;
+	this._updatePanelItems();
+};
+
+/** @private
+* @param {Element} elemA
+* @param {Element} elemB
+* @return {number}
+*/
+CellFloatingPanel._iconComparer = function(elemA, elemB) {
+	if(!elemA._order) {
+		return (!elemB._order) ? 0 : -1;
+	} else if(!elemB._order) {
+		return 1;
+	}
+	return (elemA._order - elemB._order);
+};
+
+/** @private
+*/
+CellFloatingPanel.prototype._updatePanelItems = function() {
+	let items = this._items;
+	let elem = this._element;
+	if (!items.length) {
+		return;
+	}
+	if (!this._element) {
+		elem = this._element = document.createElement("div");
+	}
+	while (elem.lastChild) {
+		elem.removeChild(elem.lastChild);
+	}
+	for (let i = 0; i < items.length; i++) {
+		elem.appendChild(items[i]);
+	}
+};
+
+export default CellFloatingPanel;
+export { CellFloatingPanel };

package/lib/core/es6/grid/components/CellSpan.d.ts

@@ -0,0 +1,18 @@
+
+
+declare class CellSpan {
+
+    constructor(x: number, y: number);
+
+    public isSpanIndices(x: number, y: number): boolean;
+
+    public isOccupiedIndices(x: number, y: number): boolean;
+
+    public register(allSpans: (CellSpan)[], occupiedMap: { [key: string]:  CellSpan }): void;
+
+    public unregister(allSpans: (CellSpan)[], occupiedMap: { [key: string]:  CellSpan }): void;
+
+}
+
+export default CellSpan;
+export { CellSpan };

package/lib/core/es6/grid/components/CellSpan.js

@@ -0,0 +1,99 @@
+
+/** @constructor
+* @param {number} x
+* @param {number} y
+*/
+let CellSpan = function (x, y) {
+	this.indexX = x;
+	this.indexY = y;
+};
+
+/** @public
+ * @param {number} x
+ * @param {number} y
+* @return {boolean}
+*/
+CellSpan.prototype.isSpanIndices = function (x, y) {
+	return x === this.indexX && y === this.indexY;
+};
+/** @public
+ * @param {number} x
+ * @param {number} y
+* @return {boolean}
+*/
+CellSpan.prototype.isOccupiedIndices = function (x, y) {
+	return x !== this.indexX || y !== this.indexY;
+};
+
+/** @public
+* @param {!Array.<CellSpan>} allSpans
+* @param {!Object.<string, CellSpan>} occupiedMap
+*/
+CellSpan.prototype.register = function (allSpans, occupiedMap) {
+	this._register(allSpans, occupiedMap, true);
+};
+/** @public
+* @param {!Array.<CellSpan>} allSpans
+* @param {!Object.<string, CellSpan>} occupiedMap
+*/
+CellSpan.prototype.unregister = function (allSpans, occupiedMap) {
+	this._register(allSpans, occupiedMap, false);
+};
+/** @private
+* @param {!Array.<CellSpan>} allSpans
+* @param {!Object.<string, CellSpan>} occupiedMap
+* @param {boolean} bool
+*/
+CellSpan.prototype._register = function (allSpans, occupiedMap, bool) {
+	let at = allSpans.indexOf(this);
+	if(bool) {
+		if(at < 0) {
+			allSpans.push(this);
+		}
+	} else {
+		if(at >= 0) {
+			allSpans.splice(at, 1);
+		}
+	}
+
+	let obj = bool ? this : null;
+	let endCol = this.indexX + this.colSpan;
+	let endRow = this.indexY + this.rowSpan;
+	for (let c = this.indexX; c < endCol; ++c) {
+		for (let r = this.indexY; r < endRow; ++r) {
+			occupiedMap[c + "," + r] = obj;
+		}
+	}
+};
+
+/** @public
+* @type {number}
+*/
+CellSpan.prototype.indexX;
+/** @public
+* @type {number}
+*/
+CellSpan.prototype.indexY;
+/** @public
+* @type {number}
+*/
+CellSpan.prototype.colSpan = 1;
+/** @public
+* @type {number}
+*/
+CellSpan.prototype.rowSpan = 1;
+/** @public
+* @type {number}
+*/
+CellSpan.prototype.prevColSpan = 1;
+/** @public
+* @type {number}
+*/
+CellSpan.prototype.prevRowSpan = 1;
+/** @public
+* @type {number}
+*/
+CellSpan.prototype.retVal = 0;
+
+export default CellSpan;
+export { CellSpan };

package/lib/core/es6/grid/components/CellSpans.d.ts

@@ -0,0 +1,40 @@
+import CellSpan from "./CellSpan.js";
+
+declare class CellSpans {
+
+    constructor();
+
+    public removeColumn(at: number): boolean;
+
+    public freezeMapping(bool?: boolean|null): void;
+
+    public shiftColumn(from: number, amount: number): boolean;
+
+    public removeSpan(indexX: number, indexY: number): CellSpan|null;
+
+    public removeSpanByColIndex(at: number, opt_ary?: (CellSpan)[]|null): (CellSpan)[]|null;
+
+    public removeSpanStartedFromRowIndex(at: number, opt_ary?: (CellSpan)[]|null): (CellSpan)[]|null;
+
+    public clearAllSpans(): (CellSpan)[]|null;
+
+    public hasSpan(): boolean;
+
+    public getSpan(indexX: number, indexY: number): CellSpan|null|null;
+
+    public getOccupyingSpan(indexX: number, indexY: number): CellSpan|null|null;
+
+    public getAllSpans(): (CellSpan)[];
+
+    public getColSpan(indexX: number, indexY: number): number;
+
+    public getRowSpan(indexX: number, indexY: number): number;
+
+    public setColSpan(indexX: number, indexY: number, spanVal: number): CellSpan|null;
+
+    public setRowSpan(indexX: number, indexY: number, spanVal: number): CellSpan|null;
+
+}
+
+export default CellSpans;
+export { CellSpans };

package/lib/core/es6/grid/components/CellSpans.js

@@ -0,0 +1,368 @@
+import CellSpan from "./CellSpan.js";
+
+/** @constructor */
+let CellSpans = function () {
+	this._spans = [];
+	this._occupiedMap = {};
+};
+
+/** @public
+* @param {number} at
+* @return {boolean} Return true if there is any change
+*/
+CellSpans.prototype.removeColumn = function (at) { // Use when a column is removed
+	let dirty = false;
+	if(this.removeSpanByColIndex(at)) {
+		dirty = true;
+	}
+	if(this.shiftColumn(at, -1)) {
+		dirty = true;
+	}
+	return dirty;
+};
+/** @public
+* @param {boolean=} bool
+*/
+CellSpans.prototype.freezeMapping = function (bool) {
+	this._frozenMapping = bool !== false;
+	if(!this._frozenMapping) {
+		this._mapCellSpans();
+	}
+};
+
+
+/** @private
+*/
+CellSpans.prototype._mapCellSpans = function () {
+	let cellSpans = this._spans;
+	this._spans = [];
+	this._occupiedMap = {};
+	let i, cellSpan;
+	for(i = cellSpans.length; --i >= 0;) {
+		cellSpan = cellSpans[i];
+		if(cellSpan.indexX >= 0) {
+			cellSpan.register(this._spans, this._occupiedMap);
+		}
+	}
+};
+
+
+/** @public
+* @param {number} from
+* @param {number} amount This can be negative number
+* @return {boolean} Return true if there is any change
+*/
+CellSpans.prototype.shiftColumn = function (from, amount) { // Use when a column is inserted or removed
+	if(this._spans.length <= 0 || amount === 0) { return false; }
+
+	let dirty = false;
+	for (let i = this._spans.length; --i >= 0;) {
+		let cellSpan = this._spans[i];
+		if(cellSpan.indexX >= from) {
+			dirty = true;
+			cellSpan.indexX += amount;
+		}
+	}
+	if(!dirty || this._frozenMapping) { return false; }
+
+	// Re-registers all cellspans. Some of the cellspans may be lost due to shifting
+	this._mapCellSpans();
+	return true;
+};
+/** @public
+ * @param {number} indexX
+ * @param {number} indexY
+* @return {CellSpan}
+*/
+CellSpans.prototype.removeSpan = function (indexX, indexY) {
+	if(this._spans.length <= 0) { return null; }
+
+	let key = indexX + "," + indexY;
+	let cellSpan = this._occupiedMap[key];
+	if(!cellSpan || cellSpan.isOccupiedIndices(indexX, indexY)) { return null; }
+
+	cellSpan.unregister(this._spans, this._occupiedMap);
+	return cellSpan;
+};
+/** @public
+* @param {number} at
+* @param {Array.<CellSpan>=} opt_ary Array that contains removed CellSpan.
+* @return {Array.<CellSpan>} Return null if no CellSpan is removed
+*/
+CellSpans.prototype.removeSpanByColIndex = function (at, opt_ary) {
+	let len = this._spans.length;
+	if(len <= 0) { return null; }
+
+	let cellSpan;
+	let removedCellSpans = opt_ary || [];
+	let count = 0;
+	let i;
+	for (i = 0; i < len; ++i) {
+		cellSpan = this._spans[i];
+		if(cellSpan && cellSpan.indexX === at) {
+			removedCellSpans.push(cellSpan);
+			count++;
+		}
+	}
+	if(count <= 0) { return null; }
+
+	len = removedCellSpans.length;
+	for(i = 0; i < count; ++i) {
+		removedCellSpans[len - i - 1].unregister(this._spans, this._occupiedMap);
+	}
+	return removedCellSpans;
+};
+/** @public
+* @param {number} at
+* @param {Array.<CellSpan>=} opt_ary Array that contains removed CellSpan.
+* @return {Array.<CellSpan>} Return null if no CellSpan is removed
+*/
+CellSpans.prototype.removeSpanStartedFromRowIndex = function (at, opt_ary) {
+	let len = this._spans.length;
+	if(len <= 0) { return null; }
+
+	let cellSpan;
+	let removedCellSpans = opt_ary || [];
+	let count = 0;
+	let i;
+	for (i = 0; i < len; ++i) {
+		cellSpan = this._spans[i];
+		if(cellSpan && cellSpan.indexY >= at) {
+			removedCellSpans.push(cellSpan);
+			count++;
+		}
+	}
+	if(count <= 0) { return null; }
+
+	len = removedCellSpans.length;
+	for(i = 0; i < count; ++i) {
+		removedCellSpans[len - i - 1].unregister(this._spans, this._occupiedMap);
+	}
+	return removedCellSpans;
+};
+
+/** @public
+* @return {Array.<CellSpan>}
+*/
+CellSpans.prototype.clearAllSpans = function () {
+	if(this._spans.length <= 0) { return null; }
+
+	let allCellSpans = this._spans;
+	this._spans = [];
+	this._occupiedMap = {};
+	return allCellSpans;
+};
+/** @public
+* @return {boolean}
+*/
+CellSpans.prototype.hasSpan = function () {
+	return (this._spans.length  > 0);
+};
+
+/** @public
+* @param {number} indexX
+* @param {number} indexY
+* @return {CellSpan|null}
+*/
+CellSpans.prototype.getSpan = function (indexX, indexY) {
+	let cellSpan = this.getOccupyingSpan(indexX, indexY);
+	if(cellSpan && cellSpan.isSpanIndices(indexX, indexY)) {
+		return cellSpan;
+	}
+	return null;
+};
+/** @public
+* @param {number} indexX
+* @param {number} indexY
+* @return {CellSpan|null}
+*/
+CellSpans.prototype.getOccupyingSpan = function (indexX, indexY) {
+	if(this._spans.length <= 0) { return null; }
+	return this._occupiedMap[indexX + "," + indexY] || null;
+};
+/** Shallow copy is used for better performance. The returned cellspans are still referenced.
+* @public
+* @return {!Array.<CellSpan>}
+*/
+CellSpans.prototype.getAllSpans = function () {
+	return this._spans;
+};
+/** @description Returns zero or negative value, if the cell is spanned over (i.e. occupied by the spanning cell). <br>
+* Negative value is distance from the spanning cell (i.e. -1 means one cell from the spanning cell and -2 means two cells from the spanning cell) <br>
+* Return one, if the cell has no span (normal cell). <br>
+* Return value greater than one, if the cell is spanning (getting expanded)
+* @public
+* @param {number} indexX
+* @param {number} indexY
+* @return {number}
+*/
+CellSpans.prototype.getColSpan = function (indexX, indexY) {
+	let cellSpan = this._occupiedMap[indexX + "," + indexY];
+	if(cellSpan == null) {
+		return 1;
+	}
+	if (cellSpan.isOccupiedIndices(indexX, indexY)) {
+		return cellSpan.indexX - indexX;
+	}
+	return cellSpan.colSpan;
+};
+/** @description Returns zero or negative value, if the cell is spanned over (i.e. occupied by the spanning cell). <br>
+* Negative value is distance from the spanning cell (i.e. -1 means one cell from the spanning cell and -2 means two cells from the spanning cell) <br>
+* Return one, if the cell has no span (normal cell). <br>
+* Return value greater than one, if the cell is spanning (getting expanded)
+* @public
+* @param {number} indexX
+* @param {number} indexY
+* @return {number}
+*/
+CellSpans.prototype.getRowSpan = function (indexX, indexY) {
+	let cellSpan = this._occupiedMap[indexX + "," + indexY];
+	if(cellSpan == null) {
+		return 1;
+	}
+	if (cellSpan.isOccupiedIndices(indexX, indexY)) {
+		return cellSpan.indexY - indexY;
+	}
+	return cellSpan.rowSpan;
+};
+
+/** @public
+* @param {number} indexX
+* @param {number} indexY
+* @param {number} spanVal
+* @return {CellSpan} Return effected CellSpan definition
+*/
+CellSpans.prototype.setColSpan = function (indexX, indexY, spanVal) {
+	return this._updateSpan(indexX, indexY, true, spanVal);
+};
+/** @public
+* @param {number} indexX
+* @param {number} indexY
+* @param {number} spanVal
+* @return {CellSpan} Return effected CellSpan definition
+*/
+CellSpans.prototype.setRowSpan = function (indexX, indexY, spanVal) {
+	return this._updateSpan(indexX, indexY, false, spanVal);
+};
+
+/** @private
+* @param {number} c0
+* @param {number} r0
+* @param {boolean} isColumn
+* @param {number} spanVal
+* @return {CellSpan} Return effected CellSpan definition
+*/
+CellSpans.prototype._updateSpan = function (c0, r0, isColumn, spanVal) {
+	if (spanVal < 1) { spanVal = 1; }
+	let cellSpan = this.getSpan(c0, r0);
+	if(cellSpan) { cellSpan.retVal = 0; }
+
+	let c1 = c0;
+	let r1 = r0;
+	let cs = (cellSpan) ? cellSpan.colSpan : 1;
+	let rs = (cellSpan) ? cellSpan.rowSpan : 1;
+	let c2, r2, target, key;
+	let isExpanding = true;
+	if (isColumn) {
+		if (cs === spanVal) { return cellSpan; }
+		if (cs > spanVal) {
+			c1 = c0 + spanVal;
+			c2 = c0 + cs;
+			isExpanding = false;
+		} else {
+			target = this._occupiedMap[c0 + "," + r0];
+			if (target && target !== cellSpan) {
+				return cellSpan;
+			}
+			c1 = c0 + cs;
+			c2 = c0 + spanVal;
+		}
+		r2 = r0 + rs;
+	} else {
+		if (rs === spanVal) { return cellSpan; }
+		if (rs > spanVal) {
+			r1 = r0 + spanVal;
+			r2 = r0 + rs;
+			isExpanding = false;
+		} else {
+			target = this._occupiedMap[c0 + "," + r0];
+			if (target && target !== cellSpan) {
+				return cellSpan;
+			}
+			r1 = r0 + rs;
+			r2 = r0 + spanVal;
+		}
+		c2 = c0 + cs;
+	}
+
+	// Collecting affected cells
+	let c, r;
+	if (isExpanding) { // Check all affected cells for occupying
+		let keys = [];
+		for (c = c1; c < c2; ++c) {
+			for (r = r1; r < r2; ++r) {
+				key = c + "," + r;
+				if (this._occupiedMap[key]) { //Invalid input is given
+					return cellSpan;
+				}
+				keys.push(key);
+			}
+		}
+
+		if (cellSpan == null) {
+			cellSpan = new CellSpan(c0, r0);
+			key = c0 + "," + r0;
+			this._spans.push(cellSpan);
+			this._occupiedMap[key] = cellSpan;
+		}
+
+		for (c = keys.length; --c >= 0; ) { // Update occupied cell map
+			this._occupiedMap[keys[c]] = cellSpan;
+		}
+	} else {
+		let noLongerSpan = (isColumn) ? (spanVal + rs <= 2) : (spanVal + cs <= 2);
+		if (noLongerSpan) {
+			key = c0 + "," + r0;
+			let at = this._spans.indexOf(cellSpan);
+			this._spans.splice(at, 1);
+			this._occupiedMap[key] = null;
+		}
+
+		for (c = c1; c < c2; ++c) { // Update occupied cell map
+			for (r = r1; r < r2; ++r) {
+				this._occupiedMap[c + "," + r] = null;
+			}
+		}
+	}
+
+	if (isColumn) {
+		cellSpan.prevColSpan = cellSpan.colSpan;
+		cellSpan.colSpan = spanVal;
+	} else {
+		cellSpan.prevRowSpan = cellSpan.rowSpan;
+		cellSpan.rowSpan = spanVal;
+	}
+	cellSpan.retVal = isExpanding ? 1 : -1;
+	return cellSpan;
+};
+
+/** A list contains all CellSpan definitions
+* @private
+* @type {!Array.<CellSpan>}
+*/
+CellSpans.prototype._spans;
+/** Map of occupied cells using string as key : _occupiedMap[colIndex + "," +rowIndex]
+* @private
+* @type {!Object.<string, CellSpan>}
+*/
+CellSpans.prototype._occupiedMap;
+
+/**
+* @private
+* @type {boolean}
+*/
+CellSpans.prototype._frozenMapping = false;
+
+export default CellSpans;
+export { CellSpans };
+

package/lib/core/es6/grid/components/Column.d.ts

@@ -0,0 +1,22 @@
+import Ext from "../../../../tr-grid-util/es6/Ext.js";
+import Util from "../util/util.js";
+import ElementWrapper from "../components/ElementWrapper.js";
+import Cell from "../components/Cell.js";
+import ILayoutGrid from "../ILayoutGrid.js";
+
+declare class Column extends ElementWrapper {
+
+    constructor(section: ILayoutGrid|null);
+
+    public clearContent(): void;
+
+    public setNextSibling(sibling: Column|null): void;
+
+    public isActive(): boolean;
+
+    public getSection(): ILayoutGrid|null;
+
+}
+
+export default Column;
+export { Column };