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

package/lib/rt-grid/es6/DataConnector.d.ts

@@ -0,0 +1,43 @@
+import { Ext } from "../../tr-grid-util/es6/Ext.js";
+import { EventDispatcher } from "../../tr-grid-util/es6/EventDispatcher.js";
+import { Conflator } from "../../tr-grid-util/es6/Conflator.js";
+import ReferenceCounter from "./ReferenceCounter.js";
+import ColumnDefinition from "./ColumnDefinition.js";
+import RowDefinition from "./RowDefinition.js"; // eslint-disable-line
+
+declare class DataConnector extends EventDispatcher {
+
+    constructor();
+
+    public dispose(): void;
+
+    public getAllRics(): (string)[]|null;
+
+    public hasRic(): boolean;
+
+    public getAllRowDefs(): (RowDefinition)[]|null;
+
+    public getAllFields(): (string)[];
+
+    public getRowDefByRic(ric: string): (RowDefinition)[]|null;
+
+    public addRic(rowDef: RowDefinition|null): boolean;
+
+    public removeRic(rowDef: RowDefinition|null, ric?: string|null): void;
+
+    public removeAllRics(): void;
+
+    public addFields(fieldRef: string|(string)[]|ColumnDefinition|null, referer?: string|null): void;
+
+    public removeFields(fieldRef: ColumnDefinition|string|null, referer?: string|null): void;
+
+    public removeFieldReferrer(referrer: string): void;
+
+    public removeAllFields(): void;
+
+    public reset(): void;
+
+}
+
+export { DataConnector };
+export default DataConnector;

package/lib/rt-grid/es6/DataConnector.js

@@ -0,0 +1,290 @@
+import { Ext } from "../../tr-grid-util/es6/Ext.js";
+import { EventDispatcher } from "../../tr-grid-util/es6/EventDispatcher.js";
+import { Conflator } from "../../tr-grid-util/es6/Conflator.js";
+import ReferenceCounter from "./ReferenceCounter.js";
+import ColumnDefinition from "./ColumnDefinition.js";
+import RowDefinition from "./RowDefinition.js"; // eslint-disable-line
+
+/**
+* @constructor
+* @extends {EventDispatcher}
+*/
+let DataConnector = function () {
+	let t = this;
+	t._commitRicsChanges = t._commitRicsChanges.bind(t);
+	t._commitFieldsChanges = t._commitFieldsChanges.bind(t);
+	t._fieldChangedConflator = new Conflator(0, t._commitFieldsChanges);
+	t._ricChangedConflator = new Conflator(0, t._commitRicsChanges);
+	t._fields = new ReferenceCounter();
+	t._rics = new ReferenceCounter();
+	t._rowDefMap = {};
+};
+Ext.inherits(DataConnector, EventDispatcher);
+
+/** @type {Conflator}
+* @private
+*/
+DataConnector.prototype._fieldChangedConflator = null;
+/** @type {Conflator}
+* @private
+*/
+DataConnector.prototype._ricChangedConflator = null;
+/** @type {Object.<string, Array.<RowDefinition>>}
+* @private
+*/
+DataConnector.prototype._rowDefMap = null;
+/** @type {ReferenceCounter}
+* @private
+*/
+DataConnector.prototype._rics = null;
+/** @type {ReferenceCounter}
+* @private
+*/
+DataConnector.prototype._fields = null;
+
+/** @public
+*/
+DataConnector.prototype.dispose = function () {
+	this.removeAllEventListeners();
+
+	this._rowDefMap = this._fields = this._rics = null;
+	this._fieldChangedConflator.reset();
+	this._ricChangedConflator.reset();
+};
+
+/** Get all ric with no duplication
+ * @public
+ * @returns {Array.<string>}
+*/
+DataConnector.prototype.getAllRics = function () {
+	return this._rics.getAllReferences();
+};
+
+/**
+ * @public
+ * @returns {boolean}
+*/
+DataConnector.prototype.hasRic = function () {
+	return this._rics.hasReference();
+};
+
+/** @public
+ * @returns {Array.<RowDefinition>}
+*/
+DataConnector.prototype.getAllRowDefs = function () {
+	let results = [];
+	for (let i in this._rowDefMap) { // TODO: Check if push is better than concat
+		results = results.concat(this._rowDefMap[i]);
+	}
+	return results;
+};
+
+/** Get all fields, including required fields and data fields, with no duplicate
+* @public
+* @return {!Array.<string>} New array is created
+*/
+DataConnector.prototype.getAllFields = function () {
+	return this._fields.getAllReferences();
+};
+
+/** @public
+ * @param {string} ric
+ * @returns {Array.<RowDefinition>}
+*/
+DataConnector.prototype.getRowDefByRic = function (ric) {
+	return this._rowDefMap[ric] || null;
+};
+
+/** @public
+* @param {RowDefinition} rowDef
+* @return {boolean} True if new reference is added.
+*/
+DataConnector.prototype.addRic = function (rowDef) {
+	let ric = rowDef ? rowDef.getSymbol() : "";
+	if(!ric) {
+		return false;
+	}
+
+	let rowDefMap = this._rowDefMap;
+	let rowDefs = rowDefMap[ric];
+	if (!rowDefs) {
+		rowDefs = rowDefMap[ric] = [rowDef];
+	} else {
+		if (rowDefs.indexOf(rowDef) < 0) {
+			rowDefs.push(rowDef);
+		}
+	}
+
+	// Referer could be added, even if no new reference is added.
+	let newReference = this._rics.addReference(ric, rowDef.getRowId());
+
+	this._commitRicsChanges();
+	return newReference;
+};
+
+/** @public
+* @param {RowDefinition} rowDef Row defintion object used as a referer
+* @param {string=} ric RIC to be removed
+*/
+DataConnector.prototype.removeRic = function (rowDef, ric) {
+	if(!ric) {
+		// TODO: RIC or permId maybe change during run-time, need to check before remove RIC/permId
+		ric = rowDef ? rowDef.getSymbol() : "";
+	}
+	if(!ric) {
+		return;
+	}
+
+	let rowDefMap = this._rowDefMap;
+	let rowDefs = rowDefMap[ric];
+	if (rowDefs) {
+		let index = rowDefs.indexOf(rowDef);
+		if (index >= 0) {
+			rowDefs.splice(index, 1);
+		}
+	}
+
+	this._rics.removeReference(ric, rowDef.getRowId());
+	this._commitRicsChanges();
+};
+
+/** @public
+*/
+DataConnector.prototype.removeAllRics = function () {
+	let referers = this._rics.getAllReferers(); // TODO: Add method to removeAllReferers at once
+	for (let i in referers) {
+		this._rics.removeReferer(referers[i]);
+	}
+	this._rowDefMap = {};
+	this._commitRicsChanges();
+};
+
+/** @private
+*/
+DataConnector.prototype._commitRicsChanges = function () {
+	if (this._ricChangedConflator.conflate()) {
+		return;
+	}
+
+	let rics = this._rics;
+	let session = rics.getSession();
+	let removedEntries = session.removedEntries;
+	let newEntries = session.newEntries;
+
+	if (removedEntries.length) {
+		this._doDispatch({
+			type: "ricRemoved",
+			removedRics: removedEntries
+		});
+	}
+	if (newEntries.length) {
+		this._doDispatch({
+			type: "ricAdded",
+			addedRics: newEntries
+		});
+	}
+
+	rics.newSession();
+};
+
+/** @public
+* @param {string|Array.<string>|ColumnDefinition} fieldRef
+* @param {string=} referer
+*/
+DataConnector.prototype.addFields = function (fieldRef, referer) {
+	if (!fieldRef) { return; }
+
+	let fields = this._fields;
+
+	if (fieldRef instanceof ColumnDefinition) {
+		fields.addReferences(fieldRef.getAllFields(), fieldRef.getId());
+	} else {
+		fields.addReferences(fieldRef, referer);
+	}
+	this._commitFieldsChanges();
+};
+
+/** @public
+* @param {ColumnDefinition|string} fieldRef
+* @param {string=} referer
+*/
+DataConnector.prototype.removeFields = function (fieldRef, referer) {
+	if (!fieldRef) { return; }
+
+	if (fieldRef instanceof ColumnDefinition) {
+		this._fields.removeReferer(fieldRef.getId());
+	} else {
+		this._fields.removeReference(fieldRef, referer);
+	}
+	this._commitFieldsChanges();
+};
+
+/** @public
+* @param {string} referrer
+*/
+DataConnector.prototype.removeFieldReferrer = function (referrer) {
+	this._fields.removeReferer(referrer);
+	this._commitFieldsChanges();
+};
+
+/** @public
+*/
+DataConnector.prototype.removeAllFields = function () {
+	let referers = this._fields.getAllReferers();
+	for (let i in referers) { // TODO: Add method to removeAllReferers at once
+		this._fields.removeReferer(referers[i]);
+	}
+	this._commitFieldsChanges();
+};
+
+/** @private
+*/
+DataConnector.prototype._commitFieldsChanges = function () {
+	if (this._fieldChangedConflator.conflate()) {
+		return;
+	}
+
+	let fields = this._fields;
+	let session = fields.getSession();
+	let removedEntries = session.removedEntries;
+	let newEntries = session.newEntries;
+
+	if (removedEntries.length) {
+		this._doDispatch({
+			type: "fieldRemoved",
+			removedFields: removedEntries
+		});
+	}
+	if (newEntries.length) {
+		this._doDispatch({
+			type: "fieldAdded",
+			addedFields: newEntries
+		});
+	}
+	fields.newSession();
+};
+
+/** @private
+* @param {Object} payload
+*/
+DataConnector.prototype._doDispatch = function (payload) {
+	let t = this;
+	payload.fields = t.getAllFields();
+	payload.rics = t.getAllRics();
+	payload.rowDefs = t.getAllRowDefs();
+	t._dispatch(payload.type, payload);
+};
+
+/** @public
+*/
+DataConnector.prototype.reset = function () {
+	let t = this;
+	t._rowDefMap = {};
+	t._fields.reset();
+	t._rics.reset();
+	t._fieldChangedConflator.reset();
+	t._ricChangedConflator.reset();
+};
+
+export { DataConnector };
+export default DataConnector;

package/lib/rt-grid/es6/FieldDefinition.d.ts

@@ -0,0 +1,40 @@
+import Grid from "./Grid.js";
+import RowDefinition from "./RowDefinition.js";
+import { Deferred } from "../../tr-grid-util/es6/Deferred.js";
+
+declare namespace FieldDefinition {
+
+    function set(field: string, def: any): void;
+
+    function resetAll(): void;
+
+    function get(field: string): any;
+
+    function getFieldInfo(field: string): any;
+
+    function hasFieldInfo(field: string): boolean;
+
+    function getTimeSeriesChildren(field: string): any[]|null;
+
+    function addTimeSeriesChild(tsDef: string, childDef: any): void;
+
+    function remove(field: string): void;
+
+    function setSynapseConfig(config: Grid.SynapseConfig|null): void;
+
+    function disableTimeSeriesExpansion(disabled: boolean): void;
+
+    function isFormula(field: string): boolean;
+
+    function isAdc(field: string): boolean;
+
+    function isRealTimeField(field: string): boolean;
+
+    function isTimeSeriesChild(field: string): boolean;
+
+    function isTimeSeries(field: string): boolean;
+
+}
+
+export {FieldDefinition};
+export default FieldDefinition;