@refinitiv-ui/efx-grid 6.0.34 → 6.0.36

package/lib/rt-grid/dist/rt-grid.js

@@ -9380,7 +9380,8 @@ DataCache_DataCache.prototype._insertRic = function (subId, ric, values) {
 	// We cannot cache event arguments because user may want to collect all the updates
 	this._onADCForNewRic(subId, ric);
 
-	if (!this.getRowData(rid)) { // Ensure that we have subscription id and ric from Quotes2
+	var rowData = this.getRowData(rid);
+	if (!rowData) { // Ensure that we have subscription id and ric from Quotes2
 		var tmp = values;
 
 		values = {}; // Clone a new object for duplicated ric
@@ -9391,6 +9392,11 @@ DataCache_DataCache.prototype._insertRic = function (subId, ric, values) {
 
 		values["SUB_ID"] = subId;
 		values["RIC"] = ric;
+	} else {
+		var rowDef = rowData["ROW_DEF"];
+		if(rowDef && rowDef.isChain()){
+			values["SUB_ID"] = subId;
+		}
 	}
 
 	this.setRowData(rid, values);
@@ -9427,6 +9433,12 @@ DataCache_DataCache.prototype._onQ2SubAdded = function (e) {
 		var sub = subs[i];
 		var ric = sub["ric"];
 
+		// chain subId fires twice, one with "_ci_" and one without "_ci_"
+		// the subId with "_ci_" should be ignore
+		if(sub["id"].indexOf("_ci_") >= 0){
+			continue;
+		}
+
 		this.addSubscription(sub, ric);
 
 		if (duplicateSubIds) { // There will be no network request for duplicate subs, and hence we need to update the data from our cache
@@ -9451,6 +9463,13 @@ DataCache_DataCache.prototype._onQ2SubRemoved = function (e) {
 
 	for (var i = 0; i < len; ++i) {
 		var sub = subs[i];
+
+		// chain subId fires twice, one with "_ci_" and one without "_ci_"
+		// the subId with "_ci_" should be ignore
+		if(sub["id"].indexOf("_ci_") >= 0){
+			continue;
+		}
+
 		this.removeSubscription(sub);
 	}
 };
@@ -12129,7 +12148,24 @@ DataTable.prototype.setSortingLogic = function(func) {
 * @param {DataTable.SortLogic} func Use null to remove current sorting logic
 */
 DataTable.prototype.setColumnSortingLogic = function(cid, func) {
-	this._compMap[cid] = func;
+	if(cid) {
+		this._compMap[cid] = func;
+	}
+};
+/** Get sorting logic for the specified field. Default logic is returned, if no logic is specified for the column
+* @public
+* @param {string=} cid
+* @return {DataTable.SortLogic}
+*/
+DataTable.prototype.getColumnSortingLogic = function(cid) {
+	if(cid) {
+		var logic = this._compMap[cid];
+		if(logic) {
+			return logic;
+		}
+	}
+
+	return this._compMap["_default"] || null;
 };
 
 /** Freeze data table so that no event is fired for data processing until executing {@link DataTable#unfreeze} method
@@ -12292,11 +12328,12 @@ DataTable.prototype.getSegmentParentRowId = function(rid) {
 /**
 * @public
 * @param {Array.<string>=} rids If no row id is given, row ids of this data table is used instead
+* @param {boolean=} partial Indicating that the given ids are not the whole list
 * @return {Array.<number>} Return null if there is no segmentation
 */
-DataTable.prototype.getSegmentValues = function(rids) {
+DataTable.prototype.getSegmentValues = function(rids, partial) {
 	if(this._segments) {
-		return this._segments.getSegmentValues(rids || this._rids);
+		return this._segments.getSegmentValues(rids || this._rids, partial);
 	}
 	return null;
 };
@@ -29444,6 +29481,17 @@ DataView.prototype.setColumnSortingLogic = function(cid, func) {
 		this._dt.setColumnSortingLogic(cid, func);
 	}
 };
+/** Get sorting logic for the specified field. Default logic is returned, if no logic is specified for the column
+* @public
+* @param {string=} cid
+* @return {DataTable.SortLogic}
+*/
+DataView.prototype.getColumnSortingLogic = function(cid) {
+	if(this._dt) {
+		return this._dt.getColumnSortingLogic(cid);
+	}
+	return null;
+};
 /** Check if this view is in sorting mode
 * @public
 * @return {boolean}
@@ -35180,6 +35228,7 @@ VirtualizedLayoutGrid._proto = VirtualizedLayoutGrid.prototype;
 
  // eslint-disable-line
 
+
  // eslint-disable-line
 
 
@@ -35379,7 +35428,9 @@ var Core = function (opt_initializer) {
 		"rowRemoved",
 		"columnPositionChanged",
 		"rowPositionChanged",
-		"beforeColumnBoundUpdate"
+		"beforeColumnBoundUpdate",
+		"beforeBatchOperation",
+		"afterBatchOperation"
 	);
 
 	// For debugging in advanced optimization mode
@@ -35454,6 +35505,15 @@ Core.SectionReference;
 */
 Core.MouseInfo;
 
+/** @typedef {Object} Core~BatchInfo
+* @private
+* @property {string=} reset //set columns
+* @property {string=} insertion //add cols
+* @property {string=} removal //remove cols
+* @property {string=} moving //reorder
+*/
+Core.BatchInfo;
+
 /** @typedef {Core.MouseInfo|ElementWrapper|Element} Core~CellReference
 * @description A section in core grid can be refered by the following object <br>
 * `{Core.MouseInfo}` : Object with valid x, y coordinates and section index <br>
@@ -35708,6 +35768,10 @@ Core.prototype._rowHeightTimerId = 0;
 * @private
 */
 Core.prototype._groupDefs = null;
+/** @type {BatchInfo}
+* @private
+*/
+Core.prototype._batches = null;
 //#region Public Methods
 
 /**
@@ -35715,7 +35779,7 @@ Core.prototype._groupDefs = null;
 * @return {string}
 */
 Core.getVersion = function () {
-	return "5.1.44";
+	return "5.1.49";
 };
 /** {@link ElementWrapper#dispose}
 * @override
@@ -36654,6 +36718,10 @@ Core.prototype.removeColumnAt = function (index) {
 
 	if (this._hasListener("columnRemoved")) {
 		var e = {};
+		var batches = this._batches;
+		if(batches){
+			e["batches"] = batches;
+		}
 		e["atTheMiddle"] = true;
 		e["colIndex"] = index;
 		e["columns"] = "deprecated";
@@ -39498,6 +39566,40 @@ Core.prototype.getColumnGroupChildIds = function (groupId) {
 	}
 	return null;
 };
+
+/** @public
+* @param {string} batchType
+* @return {boolean}
+* @fires Core#beforeBatchOperation
+*/
+Core.prototype.startBatch = function (batchType) {
+	if(!batchType){
+		return false;
+	}
+	if(!this._batches){
+		this._batches = {};
+	}
+	this._batches[batchType] = batchType;
+	this._dispatch("beforeBatchOperation", { batches: this._batches, batchType: batchType });
+	return true;
+};
+/** @public
+* @param {string} batchType
+* @return {boolean}
+* @fires Core#afterBatchOperation
+*/
+Core.prototype.stopBatch = function (batchType) {
+	if(!batchType){
+		return false;
+	}
+	this._dispatch("afterBatchOperation", { batches: this._batches, batchType: batchType });
+
+	delete this._batches[batchType];
+	if(Object(Util["f" /* isEmptyObject */])(this._batches)){
+		this._batches = null;
+	}
+	return true;
+};
 //#endregion Public Methods
 
 //#region Private Methods
@@ -39741,6 +39843,10 @@ Core.prototype._dispatchColumnAddedEvent = function (at, count, atTheMiddle, ctx
 	if (this._hasListener("columnAdded")) {
 		var e = {};
 		e["atTheMiddle"] = atTheMiddle;
+		var batches = this._batches;
+		if(batches){
+			e["batches"] = batches;
+		}
 		if(count === 1) {
 			e["colIndex"] = at;
 			e["context"] = ctx;
@@ -39892,6 +39998,10 @@ Core.prototype._removeColumn = function (num) {  // TODO: change the logic to us
 
 	if (this._hasListener("columnRemoved")) {
 		var e = {};
+		var batches = this._batches;
+		if(batches){
+			e["batches"] = batches;
+		}
 		for (var c = colCount; --c >= newCount; ) {
 			var colDef = removedCols[c - newCount];
 			e["colIndex"] = c;
@@ -41442,73 +41552,150 @@ DataConnector.prototype.reset = function () {
 /* harmony default export */ var js_DataConnector = (DataConnector);
 
 // CONCATENATED MODULE: ./src/js/RowDefSorter.js
+
+
+/** @private
+* @param {*} a
+* @param {*} b
+* @param {number} order
+* @return {number}
+*/
+var _defaultCompare = function(a, b, order) {
+	if(a == null || a !== a) {
+		if(b == null || b !== b) {
+			return 0;
+		}
+		return 1;
+	}
+	if(b == null || b !== b) {
+		return -1;
+	}
+
+	if(a < b) {
+		return -order;
+	}
+	if(b < a) {
+		return order;
+	}
+	return 0;
+};
+
 /** @constructor
 */
 var RowDefSorter = function() {
 	this._defaultSorter = this._defaultSorter.bind(this);
 	this._dataSorter = this._dataSorter.bind(this);
 	this._rowDefSorter = this._rowDefSorter.bind(this);
+	this._multiColumnsSorter = this._multiColumnsSorter.bind(this);
 
-	this._sortContext = {};
+	this._globalContext = {};
+	this._sortParams = [];
+	this._ctxCaches = [];
 };
 
-
-/** @type {string}
+/** @type {!Object}
 * @private
 */
-RowDefSorter.prototype._field = "";
-/** @type {!Object}
+RowDefSorter.prototype._globalContext;
+/** @type {!Array.<Array>}
 * @private
 */
-RowDefSorter.prototype._sortContext;
-/** @type {Function}
+RowDefSorter.prototype._sortParams;
+/** @type {!Array.<Object>}
+* @private
+*/
+RowDefSorter.prototype._ctxCaches;
+/** @type {Array}
 * @private
 */
-RowDefSorter.prototype._sortLogic = null;
+RowDefSorter.prototype._primaryParams;
 
 
 /** @public
 */
 RowDefSorter.prototype.dispose = function() {
-	this._sortLogic = null;
-	this._sortContext = {}; // Clear any existing reference
+	this._globalContext = {}; // Clear any existing reference
+	this._sortParams.length = 0;
+	this._ctxCaches.length = 0;
+	this._primaryParams = null;
 };
 
 /** @public
-* @param {boolean=} rowSorting=false
 * @return {Function}
 */
-RowDefSorter.prototype.getSorter = function(rowSorting) {
-	if(this._sortLogic) {
-		return rowSorting ? this._rowDefSorter : this._dataSorter;
-	} else {
-		return this._defaultSorter;
+RowDefSorter.prototype.getSorter = function() {
+	this._primaryParams = null;
+	var sortCount = this._sortParams.length;
+	if(sortCount === 1) {
+		var params = this._primaryParams = this._sortParams[0];
+		var sortLogic = params[1];
+		if(sortLogic) {
+			var rowSorting = params[3];
+			return rowSorting ? this._rowDefSorter : this._dataSorter;
+		} else {
+			return this._defaultSorter;
+		}
+	} else if(sortCount > 1) {
+		return this._multiColumnsSorter;
 	}
-};
-/** @public
-* @param {Function=} func
-*/
-RowDefSorter.prototype.setSortLogic = function(func) {
-	this._sortLogic = (typeof func === "function") ? func : null;
-};
 
+	return RowDefSorter._noSorting;
+};
 
 /** @public
-* @param {string} field
+* @param {string} key
+* @param {*} value
 */
-RowDefSorter.prototype.setField = function(field) {
-	if(!field) {
-		field = "";
+RowDefSorter.prototype.reset = function() {
+	if(this._sortParams.length) {
+		this._sortParams.length = 0;
 	}
-	this._sortContext["field"] = this._field = field;
-	this._sortContext["formattedField"] = field + "_FORMATTED";
 };
 /** @public
 * @param {string} key
 * @param {*} value
 */
 RowDefSorter.prototype.setContext = function(key, value) {
-	this._sortContext[key] = value;
+	this._globalContext[key] = value;
+};
+/** @public
+* @param {string} field
+* @param {Function} logic
+* @param {boolean} rowSorting
+* @param {string} order
+* @param {number} colIndex
+* @param {*} colDef
+*/
+RowDefSorter.prototype.addColumnContext = function(field, logic, rowSorting, order, colIndex, colDef) {
+	if(!field) {
+		field = "";
+	}
+	var sortPriority = this._sortParams.length;
+	var ctx = this._ctxCaches[sortPriority];
+	if(!ctx) {
+		ctx = this._ctxCaches[sortPriority] = Object(Util["b" /* cloneObject */])(this._globalContext);
+	}
+	var orderNum = 0;
+	if(order === "a") {
+		orderNum = 1;
+	} else if(order === "d") {
+		orderNum = -1;
+	}
+
+	var params = [
+		field, // 0
+		(typeof logic === "function") ? logic : null,  // 1
+		ctx, // 2
+		rowSorting, // 3
+		orderNum  // 4
+	];
+
+	ctx["colIndex"] = colIndex;
+	ctx["field"] = field;
+	ctx["formattedField"] = field + "_FORMATTED";
+	ctx["colDef"] = colDef;
+
+	this._sortParams.push(params);
 };
 
 /** @private
@@ -41517,32 +41704,7 @@ RowDefSorter.prototype.setContext = function(key, value) {
 * @param {number} order
 * @return {number}
 */
-RowDefSorter.prototype._defaultSorter = function(rowDefA, rowDefB, order) {
-	var orderA = rowDefA.getGroupOrder();
-	var orderB = rowDefB.getGroupOrder();
-	if(orderA !== orderB) {
-		return orderA - orderB; // Regardless of sort order
-	}
-
-	var a = rowDefA.getData(this._field);
-	var b = rowDefB.getData(this._field);
-
-	if(a == null || a !== a) {
-		if(b == null || b !== b) {
-			return 0;
-		}
-		return 1;
-	}
-	if(b == null || b !== b) {
-		return -1;
-	}
-
-	if(a < b) {
-		return -order;
-	}
-	if(b < a) {
-		return order;
-	}
+RowDefSorter._noSorting = function(rowDefA, rowDefB, order) {
 	return 0;
 };
 /** @private
@@ -41551,16 +41713,30 @@ RowDefSorter.prototype._defaultSorter = function(rowDefA, rowDefB, order) {
 * @param {number} order
 * @return {number}
 */
+RowDefSorter.prototype._defaultSorter = function(rowDefA, rowDefB, order) {
+	var field = this._primaryParams[0];
+	return _defaultCompare(
+		rowDefA.getData(field),
+		rowDefB.getData(field),
+		order
+	);
+};
+/** @private
+* @param {RowDefinition} rowDefA
+* @param {RowDefinition} rowDefB
+* @param {number} order
+* @return {number}
+*/
 RowDefSorter.prototype._dataSorter = function(rowDefA, rowDefB, order) {
-	var orderA = rowDefA.getGroupOrder();
-	var orderB = rowDefB.getGroupOrder();
-	if(orderA !== orderB) {
-		return orderA - orderB; // Regardless of sort order
-	}
-
-	var a = rowDefA.getData(this._field);
-	var b = rowDefB.getData(this._field);
-	return this._sortLogic(a, b, order, this._sortContext);
+	var params = this._primaryParams;
+	var field = params[0];
+	var sortLogic = params[1];
+	return sortLogic(
+		rowDefA.getData(field),
+		rowDefB.getData(field),
+		order,
+		params[2]
+	);
 };
 /** @private
 * @param {RowDefinition} rowDefA
@@ -41569,13 +41745,41 @@ RowDefSorter.prototype._dataSorter = function(rowDefA, rowDefB, order) {
 * @return {number}
 */
 RowDefSorter.prototype._rowDefSorter = function(rowDefA, rowDefB, order) {
-	var orderA = rowDefA.getGroupOrder();
-	var orderB = rowDefB.getGroupOrder();
-	if(orderA !== orderB) {
-		return orderA - orderB; // Regardless of sort order
+	var params = this._primaryParams;
+	var sortLogic = params[1];
+	return sortLogic(rowDefA, rowDefB, order, params[2]);
+};
+/** @private
+* @param {RowDefinition} rowDefA
+* @param {RowDefinition} rowDefB
+* @param {number} primaryOrder
+* @return {number}
+*/
+RowDefSorter.prototype._multiColumnsSorter = function(rowDefA, rowDefB, primaryOrder) {
+	var sortParams = this._sortParams;
+	var sortCount = sortParams.length;
+	for(var i = 0; i < sortCount; ++i) {
+		var params = sortParams[i];
+		var field = params[0];
+		var sortLogic = params[1];
+		var ctx = params[2];
+		var rowSorting = params[3];
+		var orderNum = params[4];
+		var ret = 0;
+		if(sortLogic) {
+			if(rowSorting) {
+				ret = sortLogic(rowDefA, rowDefB, orderNum, ctx);
+			} else {
+				ret = sortLogic(rowDefA.getData(field), rowDefB.getData(field), orderNum, ctx);
+			}
+		} else {
+			ret = _defaultCompare(rowDefA.getData(field), rowDefB.getData(field), orderNum);
+		}
+		if(ret) {
+			return ret;
+		}
 	}
-
-	return this._sortLogic(rowDefA, rowDefB, order, this._sortContext);
+	return 0;
 };
 
 /* harmony default export */ var js_RowDefSorter = (RowDefSorter);
@@ -43124,6 +43328,9 @@ SortableTitlePlugin.prototype._sortDataView = function (opt_action) {
 	if (!this._dataSorting) { return; }
 
 	var sortCount = this._sortStates.length;
+	if(this._userManagedLogic && sortCount > 1) { // The logic is managed by the user. There is no point in using multi-column sorting
+		sortCount = 1;
+	}
 	var orders = null;
 	var sortLogics = null;
 	var c_ref = null;
@@ -43139,6 +43346,9 @@ SortableTitlePlugin.prototype._sortDataView = function (opt_action) {
 		} else {
 			c_ref = this.getColumnSortingFields();
 		}
+		if(this._userManagedLogic && c_ref.length > 1) {
+			c_ref = c_ref.slice(0, 1);
+		}
 	}
 
 	// Perform sorting even if there is no sort state
@@ -43247,16 +43457,16 @@ SortableTitlePlugin.prototype._updateSortableIndicator = function (hostIndex) {
 					symbol = t._createIconElem(icon, textContent);
 					symbol.className = "sort-symbol";
 					cell["insertFloatingIcon"](symbol, 0);
-
-					if (t._sortStates.length > 1) {
-						symbol = document.createElement("span");
-						symbol.className = "priority-symbol";
-						symbol.textContent = priority + 1;
-						cell["insertFloatingIcon"](symbol, 1);
-					}
 				} else {
 					cell["addClass"]("edge-indicator");
 				}
+
+				if (t._sortStates.length > 1) {
+					symbol = document.createElement("span");
+					symbol.className = "priority-symbol";
+					symbol.textContent = priority + 1;
+					cell["insertFloatingIcon"](symbol, 1);
+				}
 			} else if (t._sortableIndicator) { // Can sort but currently not sorting
 				icon = SortableTitlePlugin._icons["sortable"];
 				symbol = t._createIconElem(icon, CODE_DIAMOND);
@@ -43716,6 +43926,7 @@ var Grid = function(placeholder, config) {
 		t._dc = new DataCache_DataCache();
 		t._dc.listen("dataChanged", t._onDataChanged);
 		t._dc.listen("dataComposed", t._onDataComposed);
+		t._dc.addStaticFields([ROW_DEF, SUB_ID]); // Static fields are deprecated, set fields to be ignore during clone in DataCache
 
 		t._dt = new DataTable();
 		t._dt.setSortingLogic(/** @type{Function} */(t._mainSorter));
@@ -44916,8 +45127,11 @@ Grid.prototype.replaceColumn = function (columnOption, colRef) {
 	if(colDef.getChildren()) { // Parent time series field doesn't provide hidden property
 		colConfig["hidden"] = false;
 	}
+
+	this._grid.startBatch("reset");
 	this.insertColumn(colConfig, colIndex);
 	this.removeColumn(colIndex + 1); // remove existing column after insert
+	this._grid.stopBatch("reset");
 };
 
 /** to update column name when field info is loaded
@@ -45010,21 +45224,24 @@ Grid.prototype._shouldLoadFieldInfo = function (field) {
 * @param {Array.<Object>} columns Array of column options
 */
 Grid.prototype.setColumns = function(columns) {
+	var grid = this._grid;
 	var colCount = (columns) ? columns.length : 0;
 
+	grid.startBatch("reset");
 	this.removeAllColumns();
 	if(colCount > 0) {
 		var prevState = false;
 		if(colCount > 1) {
-			prevState = this._grid.freezeLayout(true); // Insert multiple columns can be a huge time consuming
+			prevState = grid.freezeLayout(true); // Insert multiple columns can be a huge time consuming
 		}
 		for(var i = 0; i < colCount; ++i) {
 			this.insertColumn(columns[i], i);
 		}
 		if(colCount > 1) {
-			this._grid.freezeLayout(prevState);
+			grid.freezeLayout(prevState);
 		}
 	}
+	grid.stopBatch("reset");
 };
 
 
@@ -45033,6 +45250,8 @@ Grid.prototype.setColumns = function(columns) {
 * @param {Array.<Object>} columns Array of column options
 */
 Grid.prototype.restoreColumns = function(columns) {
+	var grid = this._grid;
+	grid.startBatch("reset");
 	var configObj = this.getConfigObject();
 	var previousColumns = configObj.columns;
 
@@ -45096,7 +45315,8 @@ Grid.prototype.restoreColumns = function(columns) {
 		this._stp.sortColumns(sortingStates);
 	}
 
-	this._grid.reorderColumns(columnOrdering);
+	grid.reorderColumns(columnOrdering);
+	grid.stopBatch("reset");
 };
 
 /** Remove all existing columns and add new columns based on the given texts/fields
@@ -45172,11 +45392,6 @@ Grid.prototype._onColumnAdded = function(e) {
 		this._grid.enableColumnClass(idx, classes[i]);
 	}
 	var colField = colDef.getField();
-	if (!colDef.isRealTimeField()) {
-		if(this._dc) {
-			this._dc.addStaticFields([colField]);
-		}
-	}
 	this._grid.setDataColumnName(idx, ROW_DEF); // This make ColumnDefinition renderer work
 	var fields = colDef.getAllFields();
 	var referrer = colDef.getId();
@@ -46789,33 +47004,34 @@ Grid.prototype._updateStreamingData = function() {
 * @param {Object} e
 */
 Grid.prototype._onPreDataSorting = function (e) {
-	var field = "";
-	var rowSorting = false;
-	var sortLogic = null;
-
-	var states = this._stp.getSortingStates(); // WARNING: Use of deprecated function
-	var state = states ? states[0] : null; // TODO: Support multi-column sorting
-
-	if(state) {
-		field = state["field"] || "";
-		var colIndex = this._stp.getSortedColumnIndex(0);
-		var colDef = (colIndex >= 0) ? this.getColumnDefinition(colIndex) : null;
-		this._sorter.setContext("colIndex", colIndex);
-		this._sorter.setContext("colDef", colDef);
+	var objs = this._stp.getSortedColumns();
+
+	this._sorter.reset();
+	if(Array.isArray(objs)) {
+		var sortCount = objs.length;
+		for(var i = 0; i < sortCount; ++i) {
+			var obj = objs[i];
+			var field = obj["field"] || "";
+			var colIndex = obj["colIndex"];
+			var colDef = (colIndex >= 0) ? this.getColumnDefinition(colIndex) : null;
+
+			var rowSorting = false;
+			var sortLogic = null;
+			if(colDef) {
+				field = colDef.getField(); // WARNING: Field and logic could be out of sync
+				rowSorting = colDef.isRowSorting();
+				sortLogic = colDef.getSorter();
+			}
+			// TODO: get sortLogic from DataView
+			// if(!sortLogic && field) {
+			// sortLogic = state["sortLogic"];
+			// }
 
-		if(colDef) {
-			field = colDef.getField(); // WARNING: Field and logic could be out of sync
-			sortLogic = colDef.getSorter();
-			rowSorting = colDef.isRowSorting();
+			this._sorter.addColumnContext(field, sortLogic, rowSorting, obj["sortOrder"], colIndex, colDef);
 		}
 	}
-	if(!sortLogic && field) {
-		sortLogic = state["sortLogic"];
-	}
 
-	this._sorter.setField(field);
-	this._sorter.setSortLogic(sortLogic);
-	this._columnSorter = this._sorter.getSorter(rowSorting);
+	this._columnSorter = this._sorter.getSorter();
 };
 /** @private
 * @param {RowDefinition} rowDefA
@@ -47716,7 +47932,7 @@ var _fieldInfo = {
 	"words2": {type: "string", min: 3, max: 10},
 	"words3": {type: "string", min: 5, max: 15},
 	"sentence": {type: "string", min: 8, max: 20},
-	"id": {type: "function", generate: _generateId},
+	"id": {type: "function", hash: 0, generate: _generateId},
 	"companyName": {type: "set", members: jet_DataSet.companyName },
 	"industry": {type: "set", members: jet_DataSet.industry },
 	"market": {type: "set", members: jet_DataSet.market },
@@ -47736,14 +47952,16 @@ var getFieldInfo = function(field) {
 * @param {Object|Function} options
 */
 var addFieldInfo = function(field, options) {
-	var opt = options;
-	if(typeof options === "function") {
-		opt = {
-			type: "function",
-			generate: options
-		};
+	if(field) {
+		var opt = options;
+		if(typeof options === "function") {
+			opt = {
+				type: "function",
+				generate: options
+			};
+		}
+		_fieldInfo[field] = opt; // WARNING: This could replace existing info
 	}
-	_fieldInfo[field] = opt;
 };
 
 /** Return pseudo random number in the range of 0 to 1 (exclusive of 1)
@@ -48085,8 +48303,9 @@ var _generate2DArray = function(fields, options, seed) {
 */
 var _hash = function(str) {
 	var sum = 0;
-	for(var i = str.length; --i >= 0;) {
-		sum += str.charCodeAt(i) * (i + 0.9);
+	var i = str ? str.length : 0;
+	while(--i >= 0) {
+		sum += str.charCodeAt(i) * (i + 0.9879);
 	}
 	return sum;
 };
@@ -48098,35 +48317,34 @@ var _hash = function(str) {
 */
 var _generateFieldData = function(field, options, seed) {
 	var fInfo = getFieldInfo(field);
+	if(!fInfo.type) {
+		fInfo.type = "number";
+		addFieldInfo(field, fInfo);
+	}
+	if(fInfo.fixedValue){
+		fInfo.value = value;
+		return fInfo;
+	}
+	if(seed != null) {
+		if(fInfo.hash == null) {
+			fInfo.hash = _hash(field);
+		}
+		seed += fInfo.hash; // Make each field unique for the same seed
+	}
+
 	var min = fInfo.min != null ? fInfo.min : 100; // WARNING: Default values are non-standard values
 	var max = fInfo.max != null ? fInfo.max : 10000;
-	var prec = fInfo.prec != null ? fInfo.prec : 0;
 	var value;
 
-	if(fInfo.fixedValue){
-		value = fInfo.fixedValue;
-	} else if(!fInfo.type) { // Unknown type
-		if(seed != null) {
-			if(field) {
-				if(!fInfo.hash) {
-					fInfo.hash = _hash(field);
-					addFieldInfo(field, fInfo); // WARNING: modify global state
-				}
-				seed += fInfo.hash;
-			}
-		}
-		value = randNumber(min, max, prec, seed);
-	} else if(fInfo.type === "string") {
+	if(fInfo.type === "string") {
 		if(fInfo.min != null || fInfo.max != null) {
-			if(seed != null) {
-				if(!fInfo.hash) {
-					fInfo.hash = _hash(field);
-				}
-				seed += fInfo.hash;
-			}
 			value = randString(min, max, seed);
 		} else {
-			value = options.text || "";
+			if(options) {
+				value = options.text || "";
+			} else {
+				value = "";
+			}
 		}
 	} else if(fInfo.type === "set") {
 		value = randMember(fInfo.members, seed);
@@ -48143,7 +48361,8 @@ var _generateFieldData = function(field, options, seed) {
 	} else if(fInfo.type === "function") {
 		fInfo.field = field;
 		value = fInfo.generate(fInfo, seed);
-	} else { // Default is number
+	} else { // Default is number for all unknown type
+		var prec = fInfo.prec != null ? fInfo.prec : 0;
 		value = randNumber(min, max, prec, seed);
 	}
 	fInfo.value = value;