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

package/lib/tr-grid-util/es6/jet/DataGenerator.js

@@ -0,0 +1,860 @@
+import DataSet from "./DataSet.js";
+
+/** @typedef {Object} DataGenerator~DataOptions
+* @description Options for generating data
+* @property {number=} seed Seed for randomization. If seed is not specified (default), new set of data will be generated every time. Otherwise, the same set of data will be generated.
+* @property {number=} numRows Number of rows to be generated
+* @property {number=} rowCount Alias to numRows
+*/
+
+/** @typedef {Object} DataGenerator~FieldInformation
+* @description Information object for defining how data are generated for a specific field
+* @property {string=} type Available types are number, float, boolean, set, function, and isoDate
+* @property {string=} prefix Add a text prefix to the data
+* @property {string=} suffix Add a text suffix to the data
+* @property {number=} min Minimum value of the numeric data
+* @property {number=} max Maximum value of the numeric data. This is exclusive (not included in the result).
+* @property {string=} prec Precision (place number after the decimal point) of the numeric data.
+* @property {string=} fixedValue Single/static/constant value
+* @property {Array=} members List of possible data when the type is "set"
+* @property {Function=} generate Function for generating data when the type is "function"
+*/
+
+/** @private
+* @param {Object} fInfo
+* @param {number=} seed
+* @return {number}
+*/
+let _generateId = function(fInfo, seed) {
+	if(seed == null) {
+		seed = fInfo._id != null ? fInfo._id : -1;
+		fInfo._id = ++seed;
+	}
+	return seed || 0;
+};
+/** @private
+* @param {Object} fInfo
+* @param {number=} seed
+* @return {Date}
+*/
+let _generateDate1 = function(fInfo, seed) {
+	if(seed == null) {
+		return randDate(6e11, 16e11, seed);
+	}
+	return new Date(1e12 + 1e9 * seed);
+};
+
+let POW10 = [1, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10];
+
+/** @type {Object.<string, DataGenerator~DataOptions>}
+* @private
+*/
+let _fieldInfo = {
+	"X_RIC_NAME": {type: "string"},
+	"CF_NAME": {type: "string", prefix: true, suffix: " Name"},
+	"CF_LAST": {type: "number", min: 0.01, max: 1000, prec: 2},
+	"PCTCHNG": {type: "number", min: -1, max: 1, prec: 2, suffix: "%"},
+	"PCTCHNG2": {type: "float", min: -20, max: 20, prec: 2, suffix: "%"},
+	"CF_CURR": {type: "set", members: ["USD", "GBP", "EUR", "JPY", "THB"]},
+	"INDICATOR": {type: "number", min: 0, max: 5},
+	"CF_TICK": {type: "number", min: 1, max: 3, changeOnly: true},
+	"PRCTCK_1": {type: "set", members: ["\u21e7", "B\u21e7", "\u2191", "B\u2191", "26", "1", "\"1\"", "-1", "\u21e9", "B\u21e9", "\u2193", "B\u2193", "27", "2", "\"2\""] },
+	"CF_NETCHNG": {type: "number", min: -100, max: 100},
+	"CF_VOLUME": {type: "number", min: 0, max: 1e7},
+	"CHILD_ORDER": {type: "set", ignore: true, members: [undefined]}, // eslint-disable-line
+	"RI_FLAG": {type: "set", members: ["R", "Q", "I", "_", ""]},
+	"RI_CODE": {type: "number", min: 0, max: 2},
+	"STATUS": {type: "number", min: 0, max: 6},
+	"YRLOW": {type: "number", min: 0, max: 20},
+	"YRHIGH": {type: "number", min: 200, max: 2000},
+	"CFLOW": {type: "number", min: 0, max: 20},
+	"CFHIGH": {type: "number", min: 200, max: 2000},
+	"LOW_YLD": {type: "set", members: [undefined, 0, 1, 2, 3, 4, 5, 10, 11, 15, 20]}, // eslint-disable-line
+	"HIGH_YLD": {type: "set", members: [undefined, 200, 300, 400, 500, 1000, 1500, 2000]}, // eslint-disable-line
+	"CF_YIELD": {type: "set", members: [undefined, 0, 10, 20, 30, 40, 50, 100, 200, 300, 400, 500]}, // eslint-disable-line
+	"TR.IPODate": {type: "isoDate", min: Date.now() - 63072000000 /* 2 years back from now */, max: Date.now()},
+	"TR.Volume": {type: "number", min: 2000, max: 1e7},
+	"TR.Price52WeekHigh": {type: "number", min: 100, max: 300, prec: 2},
+	"TR.Price52WeekLow": {type: "number", min: 1, max: 200, prec: 2 },
+	"TR.InvalidField": {type: "set", members: [undefined, null, NaN]}, // eslint-disable-line
+	"falsyValues": {type: "set", members: [undefined, null, NaN, 0, false, ""]}, // eslint-disable-line
+	"percent": {type: "number", min: 0, max: 101 },
+	"number_1": {type: "number", min: 1, max: 100 },
+	"number_2": {type: "number", min: -100, max: 100 },
+	"index4": {type: "number", min: 0, max: 4 },
+	"index5": {type: "number", min: 0, max: 5 },
+	"index10": {type: "number", min: 0, max: 10 },
+	"index100": {type: "number", min: 0, max: 100 },
+	"group3": {type: "set", members: ["Group_A", "Group_B", "Group_C"]},
+	"group4": {type: "set", members: ["Group_1", "Group_2", "Group_3", "Group_4"]},
+	"float_1": {type: "float", min: 0, max: 1, prec: 2 },
+	"float_2": {type: "float", min: 0, max: 100, prec: 2 },
+	"float_3": {type: "float", min: -1, max: 1, prec: 2 },
+	"precision4": {type: "float", min: -10, max: 10, prec: 4 },
+	"precision8": {type: "float", min: -100, max: 100, prec: 8 },
+	"boolean": {type: "boolean"},
+	"date": {type: "date", min: 15e11, max: 16e11 },
+	"date1": {type: "function", generate: _generateDate1 },
+	"ISODate": {type: "isoDateObject", min: Date.now() - 63072000000 /* 2 years back from now */, max: Date.now()},
+	"word": {type: "string", min: 1, max: 1},
+	"phrase": {type: "string", min: 2, max: 5},
+	"words": {type: "string", min: 1, max: 20},
+	"words1": {type: "string", min: 2, max: 8},
+	"words2": {type: "string", min: 3, max: 10},
+	"words3": {type: "string", min: 5, max: 15},
+	"sentence": {type: "string", min: 8, max: 20},
+	"id": {type: "function", hash: 0, generate: _generateId},
+	"companyName": {type: "set", members: DataSet.companyName },
+	"industry": {type: "set", members: DataSet.industry },
+	"market": {type: "set", members: DataSet.market },
+	"country": {type: "set", members: DataSet.country }
+};
+
+/** @public
+* @param {string} field
+* @return {!Object}
+*/
+let getFieldInfo = function(field) {
+	return _fieldInfo[field] || {};
+};
+
+/** @public
+* @param {string} field
+* @param {DataGenerator~FieldInformation|Function} options
+*/
+let addFieldInfo = function(field, options) {
+	if(field) {
+		let opt = options;
+		if(typeof options === "function") {
+			opt = {
+				type: "function",
+				generate: options
+			};
+		}
+		_fieldInfo[field] = opt; // WARNING: This could replace existing info
+	}
+};
+
+/** Return pseudo random number in the range of 0 to 1 (exclusive of 1)
+* @public
+* @param {number} seed
+* @return {number}
+*/
+let pseudoRandNumber = function(seed) {
+	let rand = Math.sin(seed * 113) * 10000;
+	rand *= rand;
+	return rand - (rand | 0);
+};
+
+/** @private
+* @param {*=} seed
+* @return {number}
+*/
+let _getRandomNumber = function(seed) {
+	return (typeof seed === "number") ? pseudoRandNumber(seed) : Math.random();
+};
+
+/** Return a floating-point random number in the range min - max (inclusive of min, but not max) with prec digits of precision.
+* @public
+* @param {number=} min=0
+* @param {number=} max=100 Exclusive value
+* @param {(number|null)=} prec
+* @param {number=} seed
+* @return {number}
+*/
+let randNumber = function(min, max, prec, seed) {
+	if(!min) { min = 0; }
+	if(max == null) { max = 100; }
+	let v = (max - min) * _getRandomNumber(seed) + min;
+
+	if(prec > 0) {
+		let pow = POW10[prec];
+		return Math.floor(v * pow) / pow;
+	} else if(prec != null) {
+		return Math.floor(v);
+	} else {
+		return v;
+	}
+};
+
+/** Return an interger random number in the range min - max (inclusive of min and max).
+* @public
+* @param {number} min
+* @param {number} max Inclusive value
+* @param {number=} seed
+* @return {number}
+*/
+let randInt = function(min, max, seed) {
+	return randNumber(min, max + 1, 0, seed);
+};
+
+/** Return a integer random number in the range min - max (inclusive of min, but not max).
+* @public
+* @param {number=} min
+* @param {number=} max Exclusive value
+* @param {number=} seed
+* @return {number}
+*/
+let randBetween = function(min, max, seed) {
+	return randNumber(min, max, 0, seed);
+};
+
+/** Return a integer random number in the range 0 - max (exclusive of max). It is usefull in some cases for example, <br>
+* if you want to get a random member of an array, <br>
+* just get a random index via randIndex(ary.length).
+* @public
+* @param {number} max Exclusive value
+* @param {number=} seed
+* @return {number}
+*/
+let randIndex = function(max, seed) {
+	return randBetween(0, max, seed);
+};
+
+/** @public
+* @param {number=} seed
+* @return {boolean}
+*/
+let randBoolean = function(seed) {
+	return randInt(0, 1, seed) === 0;
+};
+
+/** Return a random member of set or single character in the range of A to Z
+* @public
+* @param {Array} set
+* @param {number=} seed
+* @return {*}
+*/
+let randMember = function(set, seed) {
+	var len = set ? (set.length || 0) : 0;
+	if(len) {
+		if(len === 1) {
+			return set[0];
+		}
+		let index = randIndex(len, seed);
+		return set[index];
+	}
+	return String.fromCharCode(randInt(65, 90, seed));
+};
+
+/** @public
+* @param {(number|Object)=} min minimum timestamp or date object
+* @param {(number|Object)=} max minimum timestamp or date object
+* @param {number=} seed
+* @return {Date}
+*/
+let randDate = function(min, max, seed) {
+	min = min || (Date.now() - 63072000000); //2 years back from now
+	if(min instanceof Date) {
+		min = min.getTime();
+	}
+
+	max = max || Date.now();
+	if(max instanceof Date) {
+		max = max.getTime();
+	}
+
+	let ts = randInt(0, (max - min) / 1000, seed);
+	return new Date(min + (ts * 1000));
+};
+
+/** @public
+* @param {number=} min
+* @param {number=} max Exclusive value
+* @param {number=} seed
+* @return {string}
+*/
+let randString = function(min, max, seed) {
+	let wordCount = (min < max) ? randBetween(min, max, seed) : min;
+
+	let ary = new Array(wordCount);
+	for(let i = 0; i < wordCount; ++i) {
+		if(seed != null) {
+			seed *= 1.17 * (i + 1);
+		}
+		let idx = randIndex(DataSet.words.length, seed);
+		ary[i] = DataSet.words[idx];
+	}
+	return ary.join(" ");
+};
+
+
+/** Convert 2D Array to Array of records
+* @public
+* @param {Array.<Array>} data2D Array of values
+* @param {Array.<string|number>=} fields Keys to be mapped on the output records.
+* @return {Array.<Object>} records
+*/
+let toRecords = function(data2D, fields) {
+	if(!Array.isArray(data2D)) {
+		return null;
+	}
+	if(!Array.isArray(fields)) {
+		if(fields) {
+			fields = [fields + ""];
+		} else {
+			fields = [];
+		}
+	}
+	let len = data2D.length;
+	let records = new Array(len);
+	for(let i = 0; i < len; ++i) {
+		let record = records[i] = {};
+		let columns = data2D[i];
+		let jLen = columns ? (columns.length || 0) : 0;
+		for(let j = 0; j < jLen; ++j) {
+			let value = columns[j];
+			if(value !== undefined) { // eslint-disable-line
+				let key = fields[j];
+				if(!key && key !== 0) {
+					key = j + "";
+				}
+				record[key] = value;
+			}
+		}
+	}
+	return records;
+};
+
+/** @public
+* @return {number}
+*/
+let getSeed = function() {
+	return DataGenerator.seed;
+};
+
+/** Generate 2 dimensional array of data from the specified field and options. Note that 2D array data structure is not recommended for usage due to the position of fields/columns can be changed at runtime.
+* @public
+* @param {string|Array.<string>} fields
+* @param {DataGenerator~DataOptions=} options
+* @return {!Array.<Array>} 2D Array of data
+*/
+let generate = function(fields, options) {
+	let result = _generate2DArray(fields, options, DataGenerator.seed);
+	DataGenerator.seed = result.seed;
+
+	return result.data;
+};
+
+/** WARNING: This method does not modify global seed
+* @public
+* @param {string|Array.<string>} fields
+* @param {(number|DataGenerator~DataOptions)=} options Configuration object or seed number
+* @param {number=} seed
+* @return {!Object} Object with the given fields as its keys
+*/
+let generateRecord = function(fields, options, seed) {
+	if(!Array.isArray(fields)) {
+		fields = [fields + ""];
+	}
+	let config = {};
+	if(options != null) {
+		if(typeof options === "number") {
+			seed = options;
+		} else if(options) {
+			config = options;
+		}
+	}
+
+	let fieldCount = fields.length;
+	let record = {};
+	for(let i = 0; i < fieldCount; ++i) {
+		let field = fields[i];
+		record[field] = _generateFieldData(field, config, seed).value;
+	}
+	return record;
+};
+
+/** @public
+* @param {string|Array.<string>} fields
+* @param {(number|DataGenerator~DataOptions)=} options Configuration object or number of rows
+* @return {!Array.<Object>} Array of object with the given fields as its keys
+*/
+let generateRecords = function(fields, options) {
+	let result = _generate2DArray(fields, options, DataGenerator.seed);
+	DataGenerator.seed = result.seed;
+	fields = result.fields;
+	let fieldCount = fields.length;
+	let records = result.data;
+	for(let i = records.length; --i >= 0;) {
+		let ary = records[i];
+		let record = {};
+		for(let j = 0; j < fieldCount; ++j) {
+			let field = fields[j];
+			record[field] = ary[j];
+		}
+		records[i] = record;
+	}
+	return records;
+};
+
+/** WARNING: This method does not modify global seed
+* @public
+* @param {string} field
+* @param {DataGenerator~DataOptions=} options
+* @param {number=} seed
+* @return {!Object} Object with value, formattedValue and other properties
+*/
+let generateQuoteData = function(field, options, seed) {
+	let fInfo = _generateFieldData(field, options, seed);
+
+	//formatting
+	let fmtValue = fInfo.value + "";
+	if(fInfo.prefix){
+		if(typeof fInfo.prefix == "string") {
+			fmtValue = fInfo.prefix + fmtValue;
+		} else if(options.prefix) {
+			fmtValue = options.prefix + " " + fmtValue;
+		}
+	}
+	if(fInfo.suffix){
+		fmtValue = fmtValue + fInfo.suffix;
+	}
+
+	if(fInfo.type === "string") {
+		fInfo.value = fmtValue; // Make sure that original value has correct data type
+	}
+	fInfo.formattedValue = fmtValue;
+	return fInfo;
+};
+
+/** @private
+* @param {string|Array.<string>} fields
+* @param {(number|Object)=} options Configuration object or number of rows
+* @param {number=} seed Default seed for randomization
+* @return {!Object}
+*/
+let _generate2DArray = function(fields, options, seed) {
+	let config = {};
+	let numRows = 0;
+	if(options) {
+		if(typeof options === "number") {
+			numRows = config.numRows = options;
+		} else {
+			config = options;
+			numRows = options.numRows || options.numRow || options.rowCount;
+			if(options.seed != null) {
+				seed = options.seed; // Seed from option object overwrite the default seed
+				if(seed === -1) {
+					seed = null; // Negative one is a special value for reseting seed
+				}
+			}
+		}
+	} // else case is "", false, 0, null, undefined
+	if(!numRows) {
+		numRows = 1;
+	}
+
+	if(!fields) {
+		fields = [""]; // Default field
+	} else if(!Array.isArray(fields)) {
+		fields = [fields + ""];
+	}
+	let fieldCount = fields.length;
+
+	let dataRows = [];
+	for(let i = 0; i < numRows; ++i) {
+		let row = [];
+		// Same field in a single record must be produced to the same value
+		for(let j = 0; j < fieldCount; ++j) {
+			let field = fields[j];
+			row.push(_generateFieldData(field, options, seed).value);
+		}
+		if(seed != null) {
+			++seed;
+		}
+		dataRows.push(row);
+	}
+
+	return {
+		data: dataRows, // Array.<Array>
+		seed: seed, // nullable
+		fields: fields
+	};
+};
+/** Simple hash
+* @private
+* @param {string} str
+* @return {number}
+*/
+let _hash = function(str) {
+	let sum = 0;
+	let i = str ? str.length : 0;
+	while(--i >= 0) {
+		sum += str.charCodeAt(i) * (i + 0.9879);
+	}
+	return sum;
+};
+/** @private
+* @param {string} field
+* @param {DataGenerator~DataOptions=} options
+* @param {number=} seed
+* @return {!Object} Object with value and other properties
+*/
+let _generateFieldData = function(field, options, seed) {
+	let value;
+	let fInfo = getFieldInfo(field);
+	if(!fInfo.type) {
+		fInfo.type = "number";
+		addFieldInfo(field, fInfo);
+	}
+	if(fInfo.fixedValue !== undefined){ // eslint-disable-line
+		fInfo.value = fInfo.fixedValue;
+		return fInfo;
+	}
+	if(seed != null) {
+		if(fInfo.hash == null) {
+			fInfo.hash = _hash(field);
+		}
+		seed += fInfo.hash; // Make each field unique for the same seed
+	}
+
+	let min = fInfo.min != null ? fInfo.min : 100; // WARNING: Default values are non-standard values
+	let max = fInfo.max != null ? fInfo.max : 10000;
+
+	if(fInfo.type === "string") {
+		if(fInfo.min != null || fInfo.max != null) {
+			value = randString(min, max, seed);
+		} else {
+			if(options) {
+				value = options.text || "";
+			} else {
+				value = "";
+			}
+		}
+	} else if(fInfo.type === "set") {
+		value = randMember(fInfo.members, seed);
+	} else if(fInfo.type === "date") {
+		value = randDate(min, max, seed);
+	} else if(fInfo.type === "isoDate") {
+		let date = randDate(min, max, seed);
+		value = date.toISOString().slice(0, 10);
+	} else if(fInfo.type === "isoDateObject") {
+		value = randDate(min, max, seed);
+		value = new Date(value.toISOString().slice(0, 10));
+	} else if(fInfo.type === "boolean") {
+		value = randBoolean(seed);
+	} else if(fInfo.type === "function") {
+		fInfo.field = field;
+		value = fInfo.generate(fInfo, seed);
+	} else { // Default is number for all unknown type
+		let prec = fInfo.prec != null ? fInfo.prec : 0;
+		value = randNumber(min, max, prec, seed);
+	}
+	fInfo.value = value;
+	return fInfo;
+};
+
+
+/** @constructor
+* @param {number=} seed
+*/
+let DataGenerator = function(seed) {
+	this._seed = seed != null ? seed : null;
+};
+
+/** @type {number=}
+* @private
+*/
+DataGenerator.prototype._seed = null;
+
+/** Generate 2 dimensional array of data from the specified field and options. Note that 2D array data structure is not recommended for usage due to the position of fields/columns can be changed at runtime.
+* @public
+* @param {string|Array.<string>} fields
+* @param {(number|DataGenerator~DataOptions)=} options
+* @return {!Array.<Array>} 2D Array of data
+*/
+DataGenerator.prototype.generate = function(fields, options) {
+	let result = _generate2DArray(fields, options, this._seed);
+	this._seed = result.seed;
+
+	return result.data;
+};
+
+/** @public
+* @param {string|Array.<string>} fields
+* @param {(number|Object)=} options
+* @return {!Array.<Object>} Array of data object
+*/
+DataGenerator.prototype.generateRecords = function(fields, options) {
+	let result = _generate2DArray(fields, options, this._seed);
+	this._seed = result.seed;
+	fields = result.fields;
+	let fieldCount = fields.length;
+	let records = result.data;
+	for(let i = records.length; --i >= 0;) {
+		let ary = records[i];
+		let record = {};
+		for(let j = 0; j < fieldCount; ++j) {
+			let field = fields[j];
+			record[field] = ary[j];
+		}
+		records[i] = record;
+	}
+	return records;
+};
+
+/** @public
+* @param {string} field
+* @param {DataGenerator~DataOptions=} options
+* @return {!Object} Object with value, formattedValue and other properties
+*/
+DataGenerator.prototype.generateQuoteData = function(field, options) {
+	let fInfo = generateQuoteData(field, options, this._seed);
+	if(this._seed != null) {
+		++this._seed;
+	}
+
+	return fInfo;
+};
+/** @public
+* @return {?number}
+*/
+DataGenerator.prototype.getSeed = function() {
+	return this._seed;
+};
+
+/** @public
+* @param {number} seed
+*/
+DataGenerator.prototype.setSeed = function(seed) {
+	if(typeof seed === "number") {
+		this._seed = seed;
+	}
+};
+
+/** @public
+* @param {number=} min
+* @param {number=} max Exclusive value
+* @return {number}
+*/
+DataGenerator.prototype.randBetween = function(min, max) {
+	let result = randBetween(min, max, this._seed);
+	if(this._seed != null) {
+		++this._seed;
+	}
+	return result;
+};
+
+/** @public
+* @param {number} min
+* @param {number} max Inclusive value
+* @return {number}
+*/
+DataGenerator.prototype.randInt = function(min, max) {
+	let result = randInt(min, max, this._seed);
+	if(this._seed != null) {
+		++this._seed;
+	}
+	return result;
+};
+
+/** @public
+* @param {number} max Exclusive value
+* @return {number}
+*/
+DataGenerator.prototype.randIndex = function(max) {
+	let result = randIndex(max, this._seed);
+	if(this._seed != null) {
+		++this._seed;
+	}
+	return result;
+};
+
+/** @public
+* @param {number=} min=0
+* @param {number=} max=100 Exclusive value
+* @param {(number|null)=} prec
+* @return {number}
+*/
+DataGenerator.prototype.randNumber = function(min, max, prec) {
+	let result = randNumber(min, max, prec, this._seed);
+	if(this._seed != null) {
+		++this._seed;
+	}
+	return result;
+};
+
+/** @public
+* @return {boolean}
+*/
+DataGenerator.prototype.randBoolean = function() {
+	let result = randBoolean(this._seed);
+	if(this._seed != null) {
+		++this._seed;
+	}
+	return result;
+};
+
+/** @public
+* @param {Array} set
+* @return {*}
+*/
+DataGenerator.prototype.randMember = function(set) {
+	let result = randMember(set, this._seed);
+	if(this._seed != null) {
+		++this._seed;
+	}
+	return result;
+};
+
+/** @public
+* @param {(number|Object)=} min minimum timestamp or date object
+* @param {(number|Object)=} max minimum timestamp or date object
+* @return {Date}
+*/
+DataGenerator.prototype.randDate = function(min, max) {
+	let result = randDate(min, max, this._seed);
+	if(this._seed != null) {
+		++this._seed;
+	}
+	return result;
+};
+
+/** @public
+* @param {number=} min
+* @param {number=} max Exclusive value
+* @return {string}
+*/
+DataGenerator.prototype.randString = function(min, max) {
+	let result = randString(min, max, this._seed);
+	if(this._seed != null) {
+		++this._seed;
+	}
+	return result;
+};
+
+/** @type {?number}
+* @public
+* @ignore
+*/
+DataGenerator.seed = null;
+/** Generate 2 dimensional array of data from the specified field and options. Note that 2D array data structure is not recommended for usage due to the position of fields/columns can be changed at runtime.
+* @public
+* @function
+* @param {string|Array.<string>} fields
+* @param {DataGenerator~DataOptions=} options
+* @return {!Array.<Array>} 2D Array of data
+*/
+DataGenerator.generate = generate;
+/** @public
+* @function
+* @param {string|Array.<string>} fields
+* @param {DataGenerator~DataOptions=} options
+* @return {Object} Object with the given fields as its keys
+*/
+DataGenerator.generateRecord = generateRecord;
+/** @public
+* @function
+* @param {string|Array.<string>} fields
+* @param {(number|DataGenerator~DataOptions)=} options Configuration object or number of rows
+* @return {!Array.<Object>} Array of object with the given fields as its keys
+*/
+DataGenerator.generateRecords = generateRecords;
+/** @public
+* @function
+* @param {string} field
+* @param {DataGenerator~FieldInformation|Function} options
+*/
+DataGenerator.addFieldInfo = addFieldInfo;
+/** Return a floating-point random number in the range min - max (inclusive of min, but not max) with prec digits of precision.
+* @public
+* @function
+* @param {number=} min=0
+* @param {number=} max=100 Exclusive value
+* @param {(number|null)=} prec
+* @param {number=} seed
+* @return {number}
+*/
+DataGenerator.randNumber = randNumber;
+/** Return an interger random number in the range min - max (inclusive of min and max).
+* @public
+* @function
+* @param {number} min
+* @param {number} max Inclusive value
+* @param {number=} seed
+* @return {number}
+*/
+DataGenerator.randInt = randInt;
+/** Return a integer random number in the range min - max (inclusive of min, but not max).
+* @public
+* @function
+* @param {number=} min
+* @param {number=} max Exclusive value
+* @param {number=} seed
+* @return {number}
+*/
+DataGenerator.randBetween = randBetween;
+/** Return a integer random number in the range 0 - max <br>
+* (exclusive of max). It is usefull in some cases for example, <br>
+* if you want to get a random member of an array, <br>
+* just get a random index via randIndex(ary.length).
+* @public
+* @function
+* @param {number} max Exclusive value
+* @param {number=} seed
+* @return {number}
+*/
+DataGenerator.randIndex = randIndex;
+/** @public
+* @function
+* @param {number=} seed
+* @return {boolean}
+*/
+DataGenerator.randBoolean = randBoolean;
+/** Return a random member of set or single character in the range of A to Z
+* @public
+* @function
+* @param {Array} set
+* @param {number=} seed
+* @return {*}
+*/
+DataGenerator.randMember = randMember;
+/** @public
+* @function
+* @param {(number|Object)=} min minimum timestamp or date object
+* @param {(number|Object)=} max minimum timestamp or date object
+* @param {number=} seed
+* @return {Date}
+*/
+DataGenerator.randDate = randDate;
+/** @public
+* @function
+* @param {number=} min
+* @param {number=} max
+* @param {string=} subType "w"/"W" = word, "s"/"S" = sentence
+* @param {number=} seed
+* @return {string}
+*/
+DataGenerator.randString = randString;
+
+/** Convert 2D Array to Array of records
+* @public
+* @function
+* @param {Array.<Array>} data2D Array of values
+* @param {Array.<string>=} fields Keys to be mapped on the output records.
+* @return {Array.<Object>} records
+*/
+DataGenerator.toRecords = toRecords;
+
+
+export default DataGenerator;
+export {
+	DataGenerator,
+	addFieldInfo,
+	getSeed,
+	generate,
+	generateRecord,
+	generateRecords,
+	generateQuoteData,
+	randBetween,
+	randInt,
+	randIndex,
+	randNumber,
+	randBoolean,
+	randMember,
+	randDate,
+	randString,
+	pseudoRandNumber,
+	toRecords
+};