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

package/lib/tr-grid-util/es6/jet/MockRTK.d.ts

@@ -0,0 +1,48 @@
+import { DataGrid, Adc, setInvalidFields } from "./mockDataAPI.js";
+import { MockQuotes2 } from "./MockQuotes2.js";
+import { cloneObject } from "../Util.js";
+
+declare class MockRTKData {
+
+    constructor();
+
+    public static readonly DataGrid: any;
+
+    public static readonly Adc: any;
+
+    public static readonly Data: any;
+
+    public static request(payload: any): any;
+
+    public static request(payload: any): any;
+
+    public static setInvalidFields(payload: any): any;
+
+}
+
+declare class MockRTK {
+
+    constructor();
+
+    public static readonly DataGrid: any;
+
+    public static readonly Adc: any;
+
+    public static readonly Quotes: MockQuotes2|null;
+
+    public static readonly Data: any;
+
+    public static request(payload: any): any;
+
+    public static request(payload: any): any;
+
+    public static setInvalidFields(payload: any): any;
+
+    public static init(options?: any): MockRTK|null;
+
+    public static ready(options?: any): MockRTK|null;
+
+}
+
+export default MockRTK;
+export { MockRTK };

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

@@ -0,0 +1,82 @@
+import { DataGrid, Adc, setInvalidFields } from "./mockDataAPI.js";
+import { MockQuotes2 } from "./MockQuotes2.js";
+import { cloneObject } from "../Util.js";
+
+/** @constructor */
+let MockRTKData = {};
+
+/** @type {Object}
+* @public
+*/
+MockRTKData.DataGrid = cloneObject(DataGrid);
+/** @public
+* @param {Object} payload
+* @return {*}
+*/
+MockRTKData.DataGrid.request = function (payload) {
+	let p = DataGrid.request(payload);
+	return p.then(function (res) {
+		return JSON.parse(res);
+	});
+};
+
+/** @type {Object}
+* @public
+*/
+MockRTKData.Adc = cloneObject(Adc);
+/** @public
+* @param {Object} payload
+* @return {*}
+*/
+MockRTKData.Adc.request = function (payload) {
+	let p = Adc.request(payload);
+	return p.then(function (res) {
+		return JSON.parse(res);
+	});
+};
+
+/** @public
+* @function
+* @param {Object} payload
+* @return {*}
+*/
+MockRTKData.setInvalidFields = setInvalidFields;
+
+
+/** @constructor */
+let MockRTK = {};
+
+/** @type {MockQuotes2}
+* @public
+*/
+MockRTK.Quotes = new MockQuotes2();
+/** @type {Object}
+* @public
+*/
+MockRTK.Data = MockRTKData;
+
+/** @public
+* @param {Object=} options
+* @return {MockRTK}
+*/
+MockRTK.init = function (options) {
+	if(options) {
+		MockRTK.Quotes.config(options);
+	}
+
+	return new Promise(function (resolve, reject) {
+		setTimeout(function(){
+			resolve(MockRTK);
+		}, 300);
+	});
+};
+/** @public
+* @param {Object=} options
+* @return {MockRTK}
+*/
+MockRTK.ready = function (options) {
+	return MockRTK.init(options);
+};
+
+export default MockRTK;
+export { MockRTK };

package/lib/tr-grid-util/es6/jet/MockUtil.d.ts

@@ -0,0 +1,7 @@
+
+
+declare const invalidFieldDict: any;
+
+declare function setInvalidFields(fields: (string)[]|string|null): void;
+
+export { invalidFieldDict, setInvalidFields };

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

@@ -0,0 +1,25 @@
+/**
+* @public
+* @type {Object}
+*/
+let invalidFieldDict = {
+	'TR.NonExistField': true,
+	'TR.NotExistField': true,
+	'CF_IGNORE_FIELD': true
+};
+
+/** to mock invalid fields.
+* @public
+* @param {Array<string>|string} fields ex. TR.NonExistField, CF_IGNORE_FIELD
+*/
+function setInvalidFields(fields) {
+	if (fields && typeof fields === 'string') {
+		invalidFieldDict[fields] = true;
+	} else if (Array.isArray(fields)) {
+		for (let i = 0; i < fields.length; i++) {
+			invalidFieldDict[fields[i]] = true;
+		}
+	}
+}
+
+export { invalidFieldDict, setInvalidFields };

package/lib/tr-grid-util/es6/jet/index.d.ts

@@ -0,0 +1,9 @@
+import { MockJET } from "./MockJET.js";
+import { DataGenerator } from "./DataGenerator.js";
+import { MockRTK } from "./MockRTK.js";
+
+export {
+	MockJET,
+	DataGenerator,
+	MockRTK
+};

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

@@ -0,0 +1,18 @@
+import { MockJET } from "./MockJET.js";
+import { DataGenerator } from "./DataGenerator.js";
+import { MockRTK } from "./MockRTK.js";
+
+let tr = window["tr"];
+if(!tr) {
+	tr = window["tr"] = {};
+}
+
+tr.MockJET = MockJET;
+tr.DataGenerator = DataGenerator;
+tr.MockRTK = MockRTK;
+
+export {
+	MockJET,
+	DataGenerator,
+	MockRTK
+};

package/lib/tr-grid-util/es6/jet/mockDataAPI.d.ts

@@ -0,0 +1,11 @@
+import { Adc } from "./Adc.js";
+import { DataGenerator } from "./DataGenerator.js";
+import { invalidFieldDict, setInvalidFields } from "./MockUtil.js";
+
+declare namespace DataGrid {
+
+}
+
+declare function mockDataAPI(dataType: string): Promise<any>|null;
+
+export { mockDataAPI, DataGrid, Adc, setInvalidFields };

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

@@ -0,0 +1,111 @@
+import { Adc } from "./Adc.js";
+import { DataGenerator } from "./DataGenerator.js";
+import { invalidFieldDict, setInvalidFields } from "./MockUtil.js";
+
+let dataGen = new DataGenerator();
+
+/** @private
+* @namespace
+*/
+let DataGrid = {};
+
+/** @private
+* @function
+* @param {Object} payload
+* @param {Object=} mockResponse
+* @return {Promise}
+*/
+DataGrid.request = function (payload, mockResponse) {
+	if (mockResponse) {
+		return Promise.resolve(JSON.stringify(mockResponse));
+	}
+
+	let i, f, len, row;
+	let instruments = payload.instruments;
+	let fields = payload.fields;
+
+	// _invalidFieldDict is a dictionary of non exist field
+	// so we must remove invalid field to make "mocking api" return result more like a "real api".
+	let invalidDict = invalidFieldDict;
+	fields = [];
+	for (i = 0; i < payload.fields.length; i++) {
+		f = payload.fields[i];
+		if (!invalidDict[f.name]) {
+			fields.push(f);
+		}
+	}
+
+	// for filter duplicate instrument
+	let rowMap = {};
+
+	// build data
+	len = instruments.length;
+	let data2D = [];
+	let rowData = dataGen.generate(fields, len);
+	for (i = 0; i < len; ++i) {
+		let inst = instruments[i];
+		row = rowMap[inst];
+		if (!row) {
+			row = rowMap[inst] = rowData[i];
+			row.unshift(inst); // prepend instrument on each row
+		}
+		data2D.push(row);
+	}
+
+	// There is a chance that rtk will return multiple row data per instrument
+	// so we must create mock up for this case
+	if (data2D.length > 0) {
+		let chance = dataGen.randInt(1, 10);
+		if (chance <= 3) { // chance 30%
+			let pos = dataGen.randInt(0, data2D.length - 1); // random row pos
+			row = data2D[pos];
+			len = row.length;
+			let mockupRow = new Array(len);
+			mockupRow[0] = row[0]; // 1st index is for instrument
+			for (i = 1; i < len; i++) {
+				mockupRow[i] = ''; // real case will return null or empty string
+			}
+			data2D.splice(pos + 1, 0, mockupRow);
+		}
+	}
+
+	// build header
+	let headers = [{
+		"displayName": "Instrument"
+	}];
+	for (i = 0; i < fields.length; i++) {
+		f = fields[i];
+		headers.push({
+			"displayName": f.name,
+			"field": f.name.toUpperCase() // server only return in uppercase
+		});
+	}
+
+	return Promise.resolve(JSON.stringify({
+		data: data2D,
+		headers: [headers]
+	}));
+};
+
+/** @public
+* @function
+* @param {string} dataType
+* @return {Promise}
+*/
+let mockDataAPI = function (dataType) {
+	if (dataType === "datagrid") {
+		return Promise.resolve(DataGrid);
+	}  else if(dataType === "adc") {
+		return Promise.resolve(Adc);
+	} else {
+		return Promise.reject(dataType + " is not supported.");
+	}
+};
+
+/** to mock invalid fields.
+* @public
+* @param {Array<string>} fields ex. TR.NonExistField, CF_IGNORE_FIELD
+*/
+mockDataAPI.setInvalidFields = setInvalidFields;
+
+export { mockDataAPI, DataGrid, Adc, setInvalidFields };

package/lib/tr-grid-util/es6/jsx.d.ts

@@ -0,0 +1,223 @@
+export declare namespace JSXInterface {
+	interface ControlHTMLAttributes<T> extends HTMLAttributes<T> {
+	  accept?: string;
+	  alt?: string;
+	  autoComplete?: string;
+	  autocomplete?: string;
+	  autoFocus?: boolean;
+	  autofocus?: boolean | string;
+	  capture?: string;
+	  checked?: boolean;
+	  crossOrigin?: string;
+	  crossorigin?: string;
+	  disabled?: boolean;
+	  form?: string;
+	  formAction?: string;
+	  formaction?: string;
+	  formEncType?: string;
+	  formenctype?: string;
+	  formMethod?: string;
+	  formmethod?: string;
+	  formNoValidate?: boolean;
+	  formnovalidate?: boolean;
+	  formTarget?: string;
+	  formtarget?: string;
+	  height?: number | string;
+	  list?: string;
+	  max?: number | string;
+	  maxLength?: number;
+	  maxlength?: number | string;
+	  min?: number | string;
+	  minLength?: number;
+	  minlength?: number | string;
+	  multiple?: boolean;
+	  name?: string;
+	  pattern?: string;
+	  placeholder?: string;
+	  readOnly?: boolean;
+	  readonly?: boolean | string;
+	  required?: boolean;
+	  size?: number;
+	  src?: string;
+	  step?: number | string;
+	  type?: string;
+	  value?: string | string[] | number;
+	  width?: number | string;
+	}
+	interface HTMLAttributes<T = HTMLElement> extends DOMAttributes<T> {
+	  innerHTML?: string;
+	  key?: string | number;
+	  accessKey?: string;
+	  class?: string | {
+		[className: string]: boolean;
+	  };
+	  contentEditable?: boolean | string;
+	  contenteditable?: boolean | string;
+	  contextMenu?: string;
+	  contextmenu?: string;
+	  dir?: string;
+	  draggable?: boolean;
+	  hidden?: boolean;
+	  id?: string;
+	  lang?: string;
+	  spellCheck?: boolean;
+	  spellcheck?: boolean | string;
+	  style?: {
+		[key: string]: string | undefined;
+	  };
+	  tabIndex?: number;
+	  tabindex?: number | string;
+	  title?: string;
+	  inputMode?: string;
+	  inputmode?: string;
+	  is?: string;
+	  radioGroup?: string;
+	  radiogroup?: string;
+	  part?: string;
+	  role?: string;
+	  about?: string;
+	  datatype?: string;
+	  inlist?: any;
+	  prefix?: string;
+	  property?: string;
+	  resource?: string;
+	  typeof?: string;
+	  vocab?: string;
+	  autoCapitalize?: string;
+	  autocapitalize?: string;
+	  autoCorrect?: string;
+	  autocorrect?: string;
+	  autoSave?: string;
+	  autosave?: string;
+	  color?: string;
+	  itemProp?: string;
+	  itemprop?: string;
+	  itemScope?: boolean;
+	  itemscope?: boolean;
+	  itemType?: string;
+	  itemtype?: string;
+	  itemID?: string;
+	  itemid?: string;
+	  itemRef?: string;
+	  itemref?: string;
+	  results?: number;
+	  security?: string;
+	  unselectable?: boolean;
+	}
+	interface DOMAttributes<T = Element> {
+	  ref?: any;
+	  slot?: string;
+	  children?: any;
+	  onCopy?: (event: ClipboardEvent) => void;
+	  onCopyCapture?: (event: ClipboardEvent) => void;
+	  onCut?: (event: ClipboardEvent) => void;
+	  onCutCapture?: (event: ClipboardEvent) => void;
+	  onPaste?: (event: ClipboardEvent) => void;
+	  onPasteCapture?: (event: ClipboardEvent) => void;
+	  onCompositionEnd?: (event: CompositionEvent) => void;
+	  onCompositionEndCapture?: (event: CompositionEvent) => void;
+	  onCompositionStart?: (event: CompositionEvent) => void;
+	  onCompositionStartCapture?: (event: CompositionEvent) => void;
+	  onCompositionUpdate?: (event: CompositionEvent) => void;
+	  onCompositionUpdateCapture?: (event: CompositionEvent) => void;
+	  onFocus?: (event: FocusEvent) => void;
+	  onFocusCapture?: (event: FocusEvent) => void;
+	  onBlur?: (event: FocusEvent) => void;
+	  onBlurCapture?: (event: FocusEvent) => void;
+	  onChange?: (event: Event) => void;
+	  onChangeCapture?: (event: Event) => void;
+	  onInput?: (event: Event) => void;
+	  onInputCapture?: (event: Event) => void;
+	  onReset?: (event: Event) => void;
+	  onResetCapture?: (event: Event) => void;
+	  onSubmit?: (event: Event) => void;
+	  onSubmitCapture?: (event: Event) => void;
+	  onInvalid?: (event: Event) => void;
+	  onInvalidCapture?: (event: Event) => void;
+	  onLoad?: (event: Event) => void;
+	  onLoadCapture?: (event: Event) => void;
+	  onError?: (event: Event) => void;
+	  onErrorCapture?: (event: Event) => void;
+	  onKeyDown?: (event: KeyboardEvent) => void;
+	  onKeyDownCapture?: (event: KeyboardEvent) => void;
+	  onKeyPress?: (event: KeyboardEvent) => void;
+	  onKeyPressCapture?: (event: KeyboardEvent) => void;
+	  onKeyUp?: (event: KeyboardEvent) => void;
+	  onKeyUpCapture?: (event: KeyboardEvent) => void;
+	  onAuxClick?: (event: MouseEvent) => void;
+	  onClick?: (event: MouseEvent) => void;
+	  onClickCapture?: (event: MouseEvent) => void;
+	  onContextMenu?: (event: MouseEvent) => void;
+	  onContextMenuCapture?: (event: MouseEvent) => void;
+	  onDblClick?: (event: MouseEvent) => void;
+	  onDblClickCapture?: (event: MouseEvent) => void;
+	  onDrag?: (event: DragEvent) => void;
+	  onDragCapture?: (event: DragEvent) => void;
+	  onDragEnd?: (event: DragEvent) => void;
+	  onDragEndCapture?: (event: DragEvent) => void;
+	  onDragEnter?: (event: DragEvent) => void;
+	  onDragEnterCapture?: (event: DragEvent) => void;
+	  onDragExit?: (event: DragEvent) => void;
+	  onDragExitCapture?: (event: DragEvent) => void;
+	  onDragLeave?: (event: DragEvent) => void;
+	  onDragLeaveCapture?: (event: DragEvent) => void;
+	  onDragOver?: (event: DragEvent) => void;
+	  onDragOverCapture?: (event: DragEvent) => void;
+	  onDragStart?: (event: DragEvent) => void;
+	  onDragStartCapture?: (event: DragEvent) => void;
+	  onDrop?: (event: DragEvent) => void;
+	  onDropCapture?: (event: DragEvent) => void;
+	  onMouseDown?: (event: MouseEvent) => void;
+	  onMouseDownCapture?: (event: MouseEvent) => void;
+	  onMouseEnter?: (event: MouseEvent) => void;
+	  onMouseLeave?: (event: MouseEvent) => void;
+	  onMouseMove?: (event: MouseEvent) => void;
+	  onMouseMoveCapture?: (event: MouseEvent) => void;
+	  onMouseOut?: (event: MouseEvent) => void;
+	  onMouseOutCapture?: (event: MouseEvent) => void;
+	  onMouseOver?: (event: MouseEvent) => void;
+	  onMouseOverCapture?: (event: MouseEvent) => void;
+	  onMouseUp?: (event: MouseEvent) => void;
+	  onMouseUpCapture?: (event: MouseEvent) => void;
+	  onTouchCancel?: (event: TouchEvent) => void;
+	  onTouchCancelCapture?: (event: TouchEvent) => void;
+	  onTouchEnd?: (event: TouchEvent) => void;
+	  onTouchEndCapture?: (event: TouchEvent) => void;
+	  onTouchMove?: (event: TouchEvent) => void;
+	  onTouchMoveCapture?: (event: TouchEvent) => void;
+	  onTouchStart?: (event: TouchEvent) => void;
+	  onTouchStartCapture?: (event: TouchEvent) => void;
+	  onPointerDown?: (event: PointerEvent) => void;
+	  onPointerDownCapture?: (event: PointerEvent) => void;
+	  onPointerMove?: (event: PointerEvent) => void;
+	  onPointerMoveCapture?: (event: PointerEvent) => void;
+	  onPointerUp?: (event: PointerEvent) => void;
+	  onPointerUpCapture?: (event: PointerEvent) => void;
+	  onPointerCancel?: (event: PointerEvent) => void;
+	  onPointerCancelCapture?: (event: PointerEvent) => void;
+	  onPointerEnter?: (event: PointerEvent) => void;
+	  onPointerEnterCapture?: (event: PointerEvent) => void;
+	  onPointerLeave?: (event: PointerEvent) => void;
+	  onPointerLeaveCapture?: (event: PointerEvent) => void;
+	  onPointerOver?: (event: PointerEvent) => void;
+	  onPointerOverCapture?: (event: PointerEvent) => void;
+	  onPointerOut?: (event: PointerEvent) => void;
+	  onPointerOutCapture?: (event: PointerEvent) => void;
+	  onGotPointerCapture?: (event: PointerEvent) => void;
+	  onGotPointerCaptureCapture?: (event: PointerEvent) => void;
+	  onLostPointerCapture?: (event: PointerEvent) => void;
+	  onLostPointerCaptureCapture?: (event: PointerEvent) => void;
+	  onScroll?: (event: UIEvent) => void;
+	  onScrollCapture?: (event: UIEvent) => void;
+	  onWheel?: (event: WheelEvent) => void;
+	  onWheelCapture?: (event: WheelEvent) => void;
+	  onAnimationStart?: (event: AnimationEvent) => void;
+	  onAnimationStartCapture?: (event: AnimationEvent) => void;
+	  onAnimationEnd?: (event: AnimationEvent) => void;
+	  onAnimationEndCapture?: (event: AnimationEvent) => void;
+	  onAnimationIteration?: (event: AnimationEvent) => void;
+	  onAnimationIterationCapture?: (event: AnimationEvent) => void;
+	  onTransitionEnd?: (event: TransitionEvent) => void;
+	  onTransitionEndCapture?: (event: TransitionEvent) => void;
+	}
+  }

package/lib/tr-grid-util/es6/locale/translation-de.d.ts

@@ -0,0 +1,7 @@
+
+
+declare namespace translationDe {
+
+}
+
+export default translationDe;

package/lib/tr-grid-util/es6/locale/translation-de.js

@@ -0,0 +1,51 @@
+/**
+* @namespace
+*/
+let translationDe = {
+	"sun": "So",
+	"mon": "Mo",
+	"tue": "Di",
+	"wed": "Mi",
+	"thu": "Do",
+	"fri": "Fr",
+	"sat": "Sa",
+	"Sunday": "Sonntag",
+	"Monday": "Montag",
+	"Tuesday": "Dienstag",
+	"Wednesday": "Mittwoch",
+	"Thursday": "Donnerstag",
+	"Friday": "Freitag",
+	"Saturday": "Samstag",
+
+	"jan": "Jan",
+	"feb": "Feb",
+	"mar": "Mrz",
+	"apr": "Apr",
+	"may": "Mai",
+	"jun": "Jun",
+	"jul": "Jul",
+	"aug": "Aug",
+	"sep": "Sep",
+	"oct": "Okt",
+	"nov": "Nov",
+	"dec": "Dez",
+	"January": "Januar",
+	"February": "Februar",
+	"March": "März",
+	"April": "April",
+	"May": "Mai",
+	"June": "Juni",
+	"July": "Juli",
+	"August": "August",
+	"September": "September",
+	"October": "Oktober",
+	"November": "November",
+	"December": "Dezember",
+
+	"am": "am",
+	"AM": "AM",
+	"pm": "pm",
+	"PM": "PM"
+};
+
+export default translationDe;

package/lib/tr-grid-util/es6/locale/translation-en.d.ts

@@ -0,0 +1,7 @@
+
+
+declare namespace translationEn {
+
+}
+
+export default translationEn;

package/lib/tr-grid-util/es6/locale/translation-en.js

@@ -0,0 +1,51 @@
+/**
+* @namespace
+*/
+let translationEn = {
+	"sun": "Sun",
+	"mon": "Mon",
+	"tue": "Tue",
+	"wed": "Wed",
+	"thu": "Thu",
+	"fri": "Fri",
+	"sat": "Sat",
+	"Sunday": "Sunday",
+	"Monday": "Monday",
+	"Tuesday": "Tuesday",
+	"Wednesday": "Wednesday",
+	"Thursday": "Thursday",
+	"Friday": "Friday",
+	"Saturday": "Saturday",
+
+	"jan": "Jan",
+	"feb": "Feb",
+	"mar": "Mar",
+	"apr": "Apr",
+	"may": "May",
+	"jun": "Jun",
+	"jul": "Jul",
+	"aug": "Aug",
+	"sep": "Sep",
+	"oct": "Oct",
+	"nov": "Nov",
+	"dec": "Dec",
+	"January": "January",
+	"February": "February",
+	"March": "March",
+	"April": "April",
+	"May": "May",
+	"June": "June",
+	"July": "July",
+	"August": "August",
+	"September": "September",
+	"October": "October",
+	"November": "November",
+	"December": "December",
+
+	"am": "am",
+	"AM": "AM",
+	"pm": "pm",
+	"PM": "PM"
+};
+
+export default translationEn;

package/lib/tr-grid-util/es6/locale/translation-ja.d.ts

@@ -0,0 +1,7 @@
+
+
+declare namespace translationJa {
+
+}
+
+export default translationJa;