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

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

@@ -0,0 +1,40 @@
+import Ext from "../../../../tr-grid-util/es6/Ext.js";
+import EventDispatcher from "../event/EventDispatcher.js";
+import TrackLayout from "./TrackLayout.js"; // eslint-disable-line
+
+declare class Virtualizer extends EventDispatcher {
+
+    constructor(trackLayout: TrackLayout);
+
+    public getContentStart(index: number): number;
+
+    public getContentInViewCount(): number;
+
+    public getViewSize(): number;
+
+    public getViewOffset(): number;
+
+    public getIndexOffset(): number;
+
+    public isVirtualizable(): boolean;
+
+    public getFirstIndexInView(): number;
+
+    public getLastIndexInView(): number;
+
+    public getPrevFirstIndexInView(): number;
+
+    public getPrevLastIndexInView(): number;
+
+    public update(opt_force?: boolean): boolean;
+
+    public isEnabled(): boolean;
+
+    public enable(opt_enabled?: boolean): void;
+
+    public disable(opt_disabled?: boolean): void;
+
+}
+
+export default Virtualizer;
+export { Virtualizer };

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

@@ -0,0 +1,340 @@
+import Ext from "../../../../tr-grid-util/es6/Ext.js";
+import EventDispatcher from "../event/EventDispatcher.js";
+import TrackLayout from "./TrackLayout.js"; // eslint-disable-line
+
+/** @constructor
+* @param {!TrackLayout} trackLayout
+* @extends {EventDispatcher}
+*/
+var Virtualizer = function (trackLayout) {
+	this._layout = trackLayout;
+	this._arg = {};
+	this._addEvent("indexChanged");
+};
+Ext.inherits(Virtualizer, EventDispatcher); // Inherits() will replace prototype of the derived object
+
+/** @private
+* @type {!TrackLayout}
+*/
+Virtualizer.prototype._layout;
+/** @private
+* @type {number}
+*/
+Virtualizer.prototype._viewSize = 0;
+/** @private
+* @type {number}
+*/
+Virtualizer.prototype._viewOffset = 0;
+/** @private
+* @type {number}
+*/
+Virtualizer.prototype._startOffsetCount = 0;
+/** @private
+* @type {number}
+*/
+Virtualizer.prototype._endOffsetCount = 0;
+/** @private
+* @type {number}
+*/
+Virtualizer.prototype._bufferSize = 0;
+
+/** @private
+* @type {Object}
+*/
+Virtualizer.prototype._arg = null; // a cache to event argument
+
+/** @private
+* @type {boolean}
+*/
+Virtualizer.prototype._enabled = true;
+/** @private
+* @type {boolean}
+*/
+Virtualizer.prototype._active = true;
+/** @private
+* @type {boolean}
+*/
+Virtualizer.prototype._virtualizable = false;
+
+/** @private
+* @return {number}
+*/
+Virtualizer.prototype._getMinIndex = function () {
+	return this._startOffsetCount;
+};
+/** @private
+* @return {number}
+*/
+Virtualizer.prototype._getMaxIndex = function () {
+	var index = this._layout.getLaneCount() - this._endOffsetCount;
+	return index > this._startOffsetCount ? index : this._startOffsetCount;
+};
+
+/** @public
+* @param {number} index
+* @return {number}
+*/
+Virtualizer.prototype.getContentStart = function (index) {
+	return this._layout.getLaneStart(index);
+};
+/** @public
+* @return {number}
+*/
+Virtualizer.prototype.getContentInViewCount = function () {
+	var first = this.getFirstIndexInView();
+	var last = this.getLastIndexInView();
+	if (first >= 0 && first < last) {
+		return last - first + 1;
+	}
+	return 0;
+};
+
+/** @private
+ * @returns {number}
+*/
+Virtualizer.prototype._getContentSizeInBounds = function () {
+	var minIndex = this._getMinIndex();
+	var maxIndex = this._getMaxIndex();
+	return this._layout.getLaneStart(maxIndex) - this._layout.getLaneStart(minIndex);
+};
+
+/** @public
+* @return {number}
+*/
+Virtualizer.prototype.getViewSize = function () {
+	return this._viewSize;
+};
+
+
+/** @public
+* @return {number}
+*/
+Virtualizer.prototype.getViewOffset = function () {
+	var minIndex = this._getMinIndex();
+	return this._viewOffset + this._layout.getLaneStart(minIndex);
+};
+/** @public
+* @return {number}
+*/
+Virtualizer.prototype.getIndexOffset = function () {
+	return this._startOffsetCount;
+};
+
+/** @public
+* @return {boolean}
+*/
+Virtualizer.prototype.isVirtualizable = function () {
+	return this._virtualizable;
+};
+
+/** @public
+* @return {number}
+*/
+Virtualizer.prototype.getFirstIndexInView = function () {
+	if (!this._virtualizable) {
+		return 0;
+	}
+	var vo = this.getViewOffset();
+	var trackSize = this._layout.getTrackSize();
+	if(vo >= trackSize) {
+		vo = trackSize - this._viewSize;  // WARNING: View offset already includes minIndex and this will override that
+	}
+	if(vo < 0) {
+		return 0;
+	}
+
+	return this._layout.hitTest(vo);
+};
+/** @public
+* @return {number} INCLUSIVE last index in view
+*/
+Virtualizer.prototype.getLastIndexInView = function () {
+	if (!this._virtualizable) {
+		return this._layout.getLaneCount() - 1;
+	} else {
+		var viewEnd = this.getViewOffset() + this._viewSize;
+
+		// prevent from invalid-index because of verical buffering
+		var maxIndex = this._getMaxIndex();
+		var endBound = this._layout.getLaneStart(maxIndex);
+		if (viewEnd >= endBound) {
+			return maxIndex - 1; // maxIndex is exclusive
+		}
+
+		return this._layout.hitTest(viewEnd);
+	}
+};
+
+/** @public
+* @return {number}
+*/
+Virtualizer.prototype.getPrevFirstIndexInView = function () {
+	return (this._arg["prevFirstIndex"] != null) ? this._arg["prevFirstIndex"] : -1;
+};
+/** @public
+* @return {number}
+*/
+Virtualizer.prototype.getPrevLastIndexInView = function () {
+	return (this._arg["prevLastIndex"] != null) ? this._arg["prevLastIndex"] : -1;
+};
+
+/** @public
+* @param {boolean=} opt_force
+* @return {boolean}
+*/
+Virtualizer.prototype.update = function (opt_force) {
+	if (opt_force !== true) {
+		if (!(this._enabled && this._active)) {
+			return false;
+		}
+	}
+
+	if (this._isEventDispatching("indexChanged")) { return false; }
+
+	var fi = this.getFirstIndexInView();
+	var li = this.getLastIndexInView(); // INCLUSIVE
+	var changed = (this._arg["prevFirstIndex"] !== fi) || (this._arg["prevLastIndex"] !== li);
+
+	if (opt_force || changed) {
+		this._arg["firstIndex"] = fi;
+		this._arg["lastIndex"] = li;
+
+		this._dispatch("indexChanged", this._arg);
+
+		this._arg["prevFirstIndex"] = fi;
+		this._arg["prevLastIndex"] = li;
+	}
+	return changed;
+};
+
+/** @public
+* @return {boolean}
+*/
+Virtualizer.prototype.isEnabled = function () {
+	return this._enabled;
+};
+/** @public
+* @param {boolean=} opt_enabled
+*/
+Virtualizer.prototype.enable = function (opt_enabled) {
+	opt_enabled = (opt_enabled !== false);
+	if (this._enabled !== opt_enabled) {
+		this._enabled = opt_enabled;
+		this.validateVirtualization();
+		this.update(true);
+	}
+};
+/** @public
+* @param {boolean=} opt_disabled
+*/
+Virtualizer.prototype.disable = function (opt_disabled) {
+	this.enable(opt_disabled === false);
+};
+
+/** @public
+* @ignore
+* @return {boolean}
+*/
+Virtualizer.prototype.isActive = function () {
+	return this._active;
+};
+/**
+* @public
+* @ignore
+* @param {boolean=} opt_enabled
+*/
+Virtualizer.prototype.activate = function (opt_enabled) {
+	opt_enabled = (opt_enabled !== false);
+	if (this._active !== opt_enabled) {
+		this._active = opt_enabled;
+		this.validateVirtualization();
+		this.update(true);
+	}
+};
+/**
+* @public
+* @ignore
+* @param {boolean=} opt_disabled
+*/
+Virtualizer.prototype.deactivate = function (opt_disabled) {
+	this.activate(opt_disabled === false);
+};
+/** @public
+* @ignore
+* @return {number}
+*/
+Virtualizer.prototype.getBufferSize = function () {
+	return this._bufferSize;
+};
+
+/** @public
+* @param {!TrackLayout} trackLayout
+* @ignore
+*/
+Virtualizer.prototype.setContentLayout = function (trackLayout) {
+	if (this._layout !== trackLayout) {
+		this._layout = trackLayout;
+		this.validateVirtualization();
+	}
+};
+/** @public
+* @ignore
+* @param {number} px
+*/
+Virtualizer.prototype.setViewSize = function (px) {
+	if (px < 0) { px = 0; }
+
+	if (this._viewSize !== px) {
+		this._viewSize = px;
+		this.validateVirtualization();
+	}
+};
+/** @public
+* @ignore
+* @param {number} px
+*/
+Virtualizer.prototype.setViewOffset = function (px) {
+	this._viewOffset = px > 0 ? px : 0;
+	this.update();
+};
+/** @public
+* @ignore
+* @param {number} start
+* @param {number} end
+*/
+Virtualizer.prototype.setViewBounds = function (start, end) {
+	this._startOffsetCount = start > 0 ? start : 0;
+	this._endOffsetCount = end > 0 ? end : 0;
+	this.validateVirtualization(); // Everytime row height is changed
+};
+/** @public
+* @ignore
+* @param {number} px
+*/
+Virtualizer.prototype.setBufferSize = function (px) {
+	if (px < 0) { px = 0; }
+	if (this._bufferSize !== px) {
+		this._bufferSize = px;
+		this.validateVirtualization();
+	}
+};
+
+/** @public
+* @ignore
+*/
+Virtualizer.prototype.validateVirtualization = function () {
+	this._virtualizable = false;
+	if (this._enabled && this._active) {
+		// If either content or view have no size, or content is smaller than view, entire content is contained within view
+		if (this._viewSize > 0) {
+			if (this._getContentSizeInBounds() > this._viewSize) {
+				this._virtualizable = true;
+			}
+		}
+	}
+};
+
+Virtualizer._proto = Virtualizer.prototype;
+
+export default Virtualizer;
+export { Virtualizer };

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

@@ -0,0 +1,18 @@
+
+
+declare namespace Util {
+
+    const isMobile: boolean;
+
+    function pushArrayItems(ary: any[], items: any[]): any[];
+
+    function insertEmptyItems(ary: any[], at: number, chunkSize: number): void;
+
+    function cycleArray(ary: any[], numItems: number): any[];
+
+}
+
+declare function item(ary: any[]|any, at: number, item: any): void;
+
+export default Util;
+export { Util };