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

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

@@ -0,0 +1,54 @@
+
+
+declare class SelectionList {
+
+    constructor();
+
+    public clone(): SelectionList;
+
+    public toString(): string;
+
+    public select(at: number): boolean;
+
+    public deselect(at: number): boolean;
+
+    public deselectFrom(at: number): boolean;
+
+    public toggleSelection(at: number): void;
+
+    public singularlySelect(at: number): boolean;
+
+    public selectRange(anchor: number, length: number): void;
+
+    public deselectRange(at: number, length: number): void;
+
+    public hasSelection(at: number, length: number): boolean;
+
+    public getSelection(at: number): boolean;
+
+    public setSelection(at: number, opt_selected?: boolean|null): boolean;
+
+    public getSelectionAnchor(): number;
+
+    public setSelectionAnchor(at: number): void;
+
+    public getSelectionCount(): number;
+
+    public getFirstSelectedIndex(): number;
+
+    public getLastSelectedIndex(): number;
+
+    public getAllSelections(): (number)[];
+
+    public getConnectedRanges(from?: number|null, to?: number|null): (number)[][];
+
+    public getSelectionMap(): (boolean)[]|null;
+
+    public clearAllSelections(): number;
+
+    public copyFrom(srcSelections: SelectionList|null, fromSrcIndex: number, offset: number, forLength: number): void;
+
+}
+
+export default SelectionList;
+export { SelectionList };

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

@@ -0,0 +1,491 @@
+
+/** @constructor
+* @ignore
+*/
+let SelectionList = function () {
+	this._selections = [];
+};
+/** Clone all members
+* @public
+* @return {!SelectionList}
+*/
+SelectionList.prototype.clone = function () {
+	// IMPORTANT NOTE: If you add any field or member to this class, clone it over here too.
+	let newObj = new SelectionList();
+	newObj._selections = this._selections.concat();
+	newObj._count = this._count;
+	newObj._anchor = this._anchor;
+	newObj._firstIndex = this._firstIndex;
+	newObj._lastIndex = this._lastIndex;
+	return newObj;
+};
+
+//#region ======  Public Methods ======//
+/** @public
+* @return {string}
+*/
+SelectionList.prototype.toString = function() {
+	return this._selections.join(", ");
+};
+/** If selection count reach its limit, new selection will not be set
+* @public
+* @param {number} at Negative index is not allowed
+* @return {boolean} True new selection is added. False otherwise (i.e. selecting the selected index)
+*/
+SelectionList.prototype.select = function(at) {
+	if(at < 0) {
+		return false;
+	}
+
+	if(this._select(at)) {
+		this._anchor = at;
+		if(this._firstIndex < 0 || at < this._firstIndex) {
+			this._firstIndex = at;
+		}
+		if(this._lastIndex < 0 || at > this._lastIndex) {
+			this._lastIndex = at;
+		}
+		return true;
+	}
+	return false;
+};
+/** WARNING: Prefer clearAllSelections() to this method
+* @public
+* @param {number} at
+* @return {boolean}
+*/
+SelectionList.prototype.deselect = function (at) {
+	if (this._selections[at]) {
+		this._selections[at] = false;
+		--this._count;
+		if (this._anchor === at) {
+			this._anchor = -1; // No anchor
+		}
+
+		if (this._firstIndex === at) {
+			this._firstIndex = this._findNextSelection(at);
+		}
+		if (this._lastIndex === at) {
+			this._lastIndex = this._findPrevSelection(at);
+		}
+		return true;
+	}
+	return false;
+};
+/** Deselect all selections starting from the specified index
+* @public
+* @param {number} at
+* @return {boolean}
+*/
+SelectionList.prototype.deselectFrom = function (at) {
+	if(this._lastIndex < at) {
+		return false;
+	}
+	if(this._firstIndex >= at) {
+		this.clearAllSelections();
+		return true;
+	}
+
+	let lastIndex = this._lastIndex;
+	let sels = this._selections;
+	for(let i = at; i <= lastIndex; ++i) {
+		if (sels[i]) {
+			sels[at] = false;
+			--this._count;
+		}
+	}
+	if (this._anchor >= at) {
+		this._anchor = -1; // No anchor
+	}
+	this._lastIndex = this._findPrevSelection(at);
+	return true;
+};
+/** @public
+* @param {number} at
+*/
+SelectionList.prototype.toggleSelection = function(at) {
+	if(this._selections[at]) {
+		this.deselect(at);
+	} else {
+		this.select(at);
+	}
+};
+/** Force selection to be left only the selected one, in case of containing multiple selections
+* Additionally, move the previous selection to the new one, if one selection has been selected
+* Anchor is also moved.
+* @public
+* @param {number} at Negative index will clear all selections
+* @return {boolean} True new selection is added. False otherwise (i.e. selecting the selected index)
+*/
+SelectionList.prototype.singularlySelect = function (at) {
+	if (this._count !== 1 || at < 0) {
+		this.clearAllSelections();
+		this.select(at);
+		return true;
+	}
+	if (this._firstIndex === at) {
+		return false;
+	}
+	// Move the old selection to the new place
+	this._selections[this._anchor] = false;
+	this._selections[at] = true;
+	this._anchor = at;
+	this._firstIndex = at;
+	this._lastIndex = at;
+	return true;
+};
+
+/** Superior performance than calling select multiple times
+* Use this method to immitate selectAll() behavior
+* Negative length is allowed. It will be inverse selectRange
+* @public
+* @param {number} anchor Negative value is allowed and will be adjusted to zero
+* @param {number} length This will be adjusted according to max selection index
+*/
+SelectionList.prototype.selectRange = function (anchor, length) {
+	if(length === 0) { return; }
+	if (anchor < 0) { anchor = 0; }
+	if (length === 1 || length === -1) {
+		this.select(anchor);
+		return;
+	}
+
+	let at = anchor;
+	let endIndex = at + length;
+	if (length < 0) {
+		endIndex = at + 1;
+		at = endIndex + length;
+	}
+
+	if (at >= endIndex) {
+		return;
+	}
+	this._anchor = anchor;
+
+	if (this._firstIndex < 0 || at < this._firstIndex) {
+		this._firstIndex = at;
+	}
+	if (this._lastIndex < 0 || endIndex >= this._lastIndex) {
+		this._lastIndex = endIndex - 1;
+	}
+
+	for (let i = at; i < endIndex; ++i) {
+		this._select(i);
+	}
+};
+
+/** Superior performance than calling deselect multiple times
+* Negative length is allowed. It will be inverse selectRange
+* @public
+* @param {number} at Negative value is allowed and will be adjusted to zero
+* @param {number} length This will be adjusted according to max selection index
+*/
+SelectionList.prototype.deselectRange = function (at, length) {
+	if (this._count <= 0) { return; }
+	if (at < 0) { at = 0; }
+	if (length === 1 || length === -1) {
+		this.deselect(at);
+		return;
+	}
+
+	let endIndex = at + length;
+	if (length < 0) {
+		endIndex = at + 1;
+		at = endIndex + length;
+	}
+
+	if (this._firstIndex >= at && this._lastIndex < endIndex) {
+		this.clearAllSelections();
+		return;
+	}
+
+	if (this._anchor >= at && this._anchor < endIndex) {
+		this._anchor = -1;
+	}
+	if (this._firstIndex >= at && this._firstIndex < endIndex) {
+		this._firstIndex = this._findNextSelection(endIndex - 1);
+	}
+	if (this._lastIndex >= at && this._lastIndex < endIndex) {
+		this._lastIndex = this._findPrevSelection(at);
+	}
+
+	let i = 0;
+	for (i = at; i < endIndex; ++i) {
+		if (this._selections[i]) {
+			this._selections[i] = false;
+			--this._count;
+		}
+	}
+};
+/** @public
+* @param {number} at
+* @param {number} length
+* @return {boolean}
+*/
+SelectionList.prototype.hasSelection = function(at, length) {
+	if(this._count <= 0) {
+		return false;
+	}
+	let endIndex = at + length;
+	if (length < 0) {
+		endIndex = at + 1;
+		at = endIndex + length;
+	}
+	if(endIndex < this._firstIndex || at > this._lastIndex) {
+		return false;
+	}
+
+	for(let i = at; i < endIndex; ++i) {
+		if(this._selections[i]) {
+			return true;
+		}
+	}
+	return false;
+};
+
+/** @public
+ * @param {number} at
+* @return {boolean} True, if the specified index is the selected one, otherwise false.
+*/
+SelectionList.prototype.getSelection = function(at) {
+	return (this._selections[at] === true);
+};
+/** @public
+* @param {number} at
+* @param {boolean=} opt_selected Select if this is true or undefined
+* @return {boolean} True, if there is any change
+*/
+SelectionList.prototype.setSelection = function(at, opt_selected) {
+	return (opt_selected !== false) ? this.select(at) : this.deselect(at);
+};
+/** Selection anchor is set when a selection is set to true only by select() and toggleSelection()
+* @public
+* @return {number} Negative index is returned if there is no anchor
+*/
+SelectionList.prototype.getSelectionAnchor = function() {
+	return this._anchor;
+};
+/** Sometimes anchor doesn't have to be where selection happens, exp shift + select
+ * @public
+ * @param {number} at
+ */
+SelectionList.prototype.setSelectionAnchor = function(at) {
+	this._anchor = at;
+};
+/** @public
+* @return {number}
+*/
+SelectionList.prototype.getSelectionCount = function() {
+	return this._count;
+};
+
+/** This is for optimization purpose, in case of one has to loop through selected index
+* @public
+* @return {number} Negative index is returned, if there is no selection
+*/
+SelectionList.prototype.getFirstSelectedIndex = function() {
+	return this._firstIndex;
+};
+/** This is for optimization purpose, in case of one has to loop through selected index
+* @public
+* @return {number} Negative index is returned, if there is no selection
+*/
+SelectionList.prototype.getLastSelectedIndex = function() {
+	return this._lastIndex;
+};
+
+/** WARNING: It will creates a new(EXPENSIVE) defragmented array of selected Index. The selected indices will always be sorted in ascending order
+* @public
+* @return {!Array.<number>}
+*/
+SelectionList.prototype.getAllSelections = function() {
+	if(this._count > 0) {
+		let ary = new Array(this._count); // Fastest way to create an array
+		let count = 0;
+		let sels = this._selections;
+		let lastIdx = this._lastIndex;
+		for(let i = this._firstIndex; i <= lastIdx; ++i) {
+			if(sels[i]) {
+				ary[count++] = i;
+			}
+		}
+		return ary;
+	}
+	return [];
+};
+/** Get array of connected selection ranges. For intances, if indices 1, 2, 5, and 5 are selected, array of [1, 2] and [5, 5] are returned.
+* @public
+* @param {number=} from
+* @param {number=} to EXCLUSIVE
+* @return {!Array.<Array.<number>>}
+*/
+SelectionList.prototype.getConnectedRanges = function(from, to) {
+	if(this._count > 0) {
+		let ary = [];
+		if(from == null || from < this._firstIndex) {
+			from = this._firstIndex;
+		}
+		if(to == null || to > this._lastIndex) {
+			to = this._lastIndex + 1;
+		}
+
+		let pair = null;
+		for(let i = from; i < to; ++i) {
+			if(this._selections[i]) {
+				if(!pair) {
+					pair = [i, -1];
+				}
+			} else if(pair) {
+				pair[1] = i - 1;
+				ary.push(pair);
+				pair = null;
+			}
+		}
+
+		if(pair) {
+			pair[1] = this._lastIndex;
+			ary.push(pair);
+			pair = null;
+		}
+		return ary;
+	}
+	return [];
+};
+
+/**
+* @public
+* @return {Array.<boolean>}
+*/
+SelectionList.prototype.getSelectionMap = function () {
+	return this._selections;
+};
+/** @public
+* @return {number}
+*/
+SelectionList.prototype.clearAllSelections = function() {
+	if(this._count > 0) {
+		let count = 0;
+		this._selections.length = 0;
+		this._count = 0;
+		this._anchor = -1;
+		this._firstIndex = -1;
+		this._lastIndex = -1;
+		return count;
+	}
+	return 0;
+};
+
+/** Copy selections from the source selection list for the specified length at the specified index. Note that selection anchor won't be changed
+* @public
+* @param {SelectionList} srcSelections
+* @param {number} fromSrcIndex
+* @param {number} offset Offset from the source index to map to destination index of this SelectionList. Use 0 if there is no shifting.
+* @param {number} forLength Positive value only. negative valie is not allowed
+*/
+SelectionList.prototype.copyFrom = function (srcSelections, fromSrcIndex, offset, forLength) {
+	if (forLength <= 0) { return; }
+
+	let toThisIndex = fromSrcIndex + offset;
+	if (srcSelections == null) {
+		this.deselectRange(toThisIndex, forLength);
+		return;
+	}
+	if (srcSelections.hasSelection(fromSrcIndex, forLength) === false) {
+		this.deselectRange(toThisIndex, forLength);
+		return;
+	}
+
+
+	for (let i = 0; i < forLength; ++i) {
+		if (srcSelections._selections[fromSrcIndex + i]) {
+			this.select(toThisIndex + i);
+		} else {
+			this.deselect(toThisIndex + i);
+		}
+	}
+	this._anchor = -1;
+	if (srcSelections._anchor >= 0) {
+		if (srcSelections._anchor >= fromSrcIndex && srcSelections._anchor < (fromSrcIndex + forLength)) {
+			this._anchor = srcSelections._anchor + offset;
+		}
+	}
+};
+//#endregion
+
+//#region ====== Private Methods ======//
+/** @private
+* @param {number} at
+* @returns {boolean}
+*/
+SelectionList.prototype._select = function (at) {
+	if(this._selections[at]) { return false; }
+
+	this._selections[at] = true;
+	++this._count;
+
+	return true;
+};
+/** WARNING: Perform LINEAR SEARCH
+* @private
+* @param {number} exclusiveStart
+* @return {number} Negative if not found
+*/
+SelectionList.prototype._findNextSelection = function(exclusiveStart) {
+	if(this._lastIndex >= 0) {
+		while(++exclusiveStart <= this._lastIndex) {
+			if(this._selections[exclusiveStart]) {
+				return exclusiveStart;
+			}
+		}
+	}
+	return -1;
+};
+/** WARNING: Perform LINEAR SEARCH
+* @private
+* @param {number} exclusiveStart
+* @return {number} Negative if not found
+*/
+SelectionList.prototype._findPrevSelection = function(exclusiveStart) {
+	if(this._firstIndex >= 0) {
+		while(--exclusiveStart >= this._firstIndex) {
+			if(this._selections[exclusiveStart]) {
+				return exclusiveStart;
+			}
+		}
+	}
+	return -1;
+};
+//#endregion
+
+//#region ====== Private Fields ======//
+/** Non-nullable array of selected index
+* @private
+* @type {Array.<boolean>}
+*/
+SelectionList.prototype._selections = null;
+
+/**
+* @private
+* @type {number}
+*/
+SelectionList.prototype._count = 0;
+/** Anchor is set (>= 0) only when select is successfully processed.
+* Anchor is cleared (-1) when the selection at the anchor index is set to false
+* @private
+* @type {number}
+*/
+SelectionList.prototype._anchor = -1; // No anchor
+/**
+* @private
+* @type {number}
+*/
+SelectionList.prototype._firstIndex = -1;
+/** Inclusive last selected index
+* @private
+* @type {number}
+*/
+SelectionList.prototype._lastIndex = -1;
+//#endregion
+
+export default SelectionList;
+export { SelectionList };

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

@@ -0,0 +1,92 @@
+import Util from "../util/util.js";
+
+declare class TrackLayout {
+
+    constructor();
+
+    public hitTest(val: number): number;
+
+    public dispose(): void;
+
+    public isAtDefaultSize(opt_index?: number|null): boolean;
+
+    public isHomogeneous(): boolean;
+
+    public isAtMinimumSize(opt_index?: number|null): boolean;
+
+    public isFixedSize(): boolean;
+
+    public clearLaneCustomizations(): void;
+
+    public getLaneCount(): number;
+
+    public setLaneCount(val: number): void;
+
+    public getDefaultLaneSize(): number;
+
+    public setDefaultLaneSize(val: number): boolean;
+
+    public getLaneDefaultSize(index: number): number;
+
+    public setLaneDefaultSize(index: number, val: number): void;
+
+    public resetLaneToDefaultSize(): boolean;
+
+    public getDefaultScalability(): boolean;
+
+    public setDefaultScalability(val: boolean): boolean;
+
+    public getTrackSize(): number;
+
+    public setTrackSize(targetSize: number): (number)[]|null|null;
+
+    public getLaneStart(index: number): number;
+
+    public getLaneEnd(index: number): number;
+
+    public getLaneSize(index: number): number;
+
+    public getCustomLaneSize(index: number): number;
+
+    public setLaneSize(index: number, val: number): boolean;
+
+    public setLaneProperty(index: number, propName: string, val: any): boolean;
+
+    public getLaneProperty(index: number, propName: string): any;
+
+    public getMinimumLaneSize(index: number): number;
+
+    public setMinimumLaneSize(index: number, val: number, proportion?: boolean|null): boolean;
+
+    public isLaneVisible(index: number): boolean;
+
+    public showLane(index: number, opt_val?: boolean|null): boolean;
+
+    public hideLane(index: number, hidden?: boolean|null, bitIndex?: number|null): boolean;
+
+    public getLaneVisibilityBit(index: number, bitIndex?: number|null): boolean;
+
+    public show(opt_shown?: boolean|null): void;
+
+    public getLaneScalability(index: number): boolean;
+
+    public setLaneScalability(index: number, val: boolean): boolean;
+
+    public removeLaneAt(index: number, opt_count?: number|null): any|null|null;
+
+    public insertLane(index: number, opt_json?: number|any|null): void;
+
+    public moveLane(from: number, to: number): void;
+
+    public serializeLane(index: number): any|null|null;
+
+    public deserializeLane(index: number, opt_json?: any): void;
+
+    public copyFrom(src: TrackLayout|null, offset?: number|null): void;
+
+}
+
+declare function toIndex(from: number, to: number): void;
+
+export default TrackLayout;
+export { TrackLayout };