tabulator-tables 6.5.0 → 6.5.1

package/src/js/modules/Ajax/defaults/loaderPromise.js

@@ -0,0 +1,87 @@
+export default function(url, config, params){
+	var contentType;
+
+	return new Promise((resolve, reject) => {
+		//set url
+		url = this.urlGenerator.call(this.table, url, config, params);
+
+		//set body content if not GET request
+		if(config.method.toUpperCase() != "GET"){
+			contentType = typeof this.table.options.ajaxContentType === "object" ?  this.table.options.ajaxContentType : this.contentTypeFormatters[this.table.options.ajaxContentType];
+			if(contentType){
+
+				for(var key in contentType.headers){
+					if(!config.headers){
+						config.headers = {};
+					}
+
+					if(typeof config.headers[key] === "undefined"){
+						config.headers[key] = contentType.headers[key];
+					}
+				}
+
+				config.body = contentType.body.call(this, url, config, params);
+
+			}else{
+				console.warn("Ajax Error - Invalid ajaxContentType value:", this.table.options.ajaxContentType);
+			}
+		}
+
+		if(url){
+			//configure headers
+			if(typeof config.headers === "undefined"){
+				config.headers = {};
+			}
+
+			if(typeof config.headers.Accept === "undefined"){
+				config.headers.Accept = "application/json";
+			}
+
+			if(typeof config.headers["X-Requested-With"] === "undefined"){
+				config.headers["X-Requested-With"] = "XMLHttpRequest";
+			}
+
+			if(typeof config.mode === "undefined"){
+				config.mode = "cors";
+			}
+
+			if(config.mode == "cors"){
+				if(typeof config.headers["Origin"] === "undefined"){
+					config.headers["Origin"] = window.location.origin;
+				}
+        
+				if(typeof config.credentials === "undefined"){
+					config.credentials = 'same-origin';
+				}
+			}else{
+				if(typeof config.credentials === "undefined"){
+					config.credentials = 'include';
+				}
+			}
+
+			//send request
+			fetch(url, config)
+				.then((response)=>{
+					if(response.ok) {
+						response.json()
+							.then((data)=>{
+								resolve(data);
+							}).catch((error)=>{
+								reject(error);
+								console.warn("Ajax Load Error - Invalid JSON returned", error);
+							});
+					}else{
+						console.error("Ajax Load Error - Connection Error: " + response.status, response.statusText);
+						reject(response);
+					}
+				})
+				.catch((error)=>{
+					console.error("Ajax Load Error - Connection Error: ", error);
+					reject(error);
+				});
+		}else{
+			console.warn("Ajax Load Error - No URL Set");
+			resolve([]);
+		}
+	});
+}

package/src/js/modules/Ajax/defaults/urlGenerator.js

@@ -0,0 +1,44 @@
+function generateParamsList(data, prefix){
+	var output = [];
+
+	prefix = prefix || "";
+
+	if(Array.isArray(data)){
+		data.forEach((item, i) => {
+			output = output.concat(generateParamsList(item, prefix ? prefix + "[" + i + "]" : i));
+		});
+	}else if (typeof data === "object"){
+		for (var key in data){
+			output = output.concat(generateParamsList(data[key], prefix ? prefix + "[" + key + "]" : key));
+		}
+	}else{
+		output.push({key:prefix, value:data});
+	}
+
+	return output;
+}
+
+function serializeParams(params){
+	var output = generateParamsList(params),
+	encoded = [];
+
+	output.forEach(function(item){
+		encoded.push(encodeURIComponent(item.key) + "=" + encodeURIComponent(item.value));
+	});
+
+	return encoded.join("&");
+}
+
+export default function(url, config, params){
+	if(url){
+		if(params && Object.keys(params).length){
+			if(!config.method || config.method.toLowerCase() == "get"){
+				config.method = "get";
+
+				url += (url.includes("?") ? "&" : "?") + serializeParams(params);
+			}
+		}
+	}
+
+	return url;
+}

package/src/js/modules/Clipboard/Clipboard.js

@@ -0,0 +1,282 @@
+import Module from '../../core/Module.js';
+
+import defaultPasteActions from './defaults/pasteActions.js';
+import defaultPasteParsers from './defaults/pasteParsers.js';
+import extensions from './extensions/extensions.js';
+
+export default class Clipboard extends Module{
+
+	static moduleName = "clipboard";
+	static moduleExtensions = extensions;
+
+	//load defaults
+	static pasteActions = defaultPasteActions;
+	static pasteParsers = defaultPasteParsers;
+
+	constructor(table){
+		super(table);
+
+		this.mode = true;
+		this.pasteParser = function(){};
+		this.pasteAction = function(){};
+		this.customSelection = false;
+		this.rowRange = false;
+		this.blocked = true; //block copy actions not originating from this command
+
+		this.registerTableOption("clipboard", false); //enable clipboard
+		this.registerTableOption("clipboardCopyStyled", true); //formatted table data
+		this.registerTableOption("clipboardCopyConfig", false); //clipboard config
+		this.registerTableOption("clipboardCopyFormatter", false); //DEPRECATED - REMOVE in 5.0
+		this.registerTableOption("clipboardCopyRowRange", "active"); //restrict clipboard to visible rows only
+		this.registerTableOption("clipboardPasteParser", "table"); //convert pasted clipboard data to rows
+		this.registerTableOption("clipboardPasteAction", "insert"); //how to insert pasted data into the table
+
+		this.registerColumnOption("clipboard");
+		this.registerColumnOption("titleClipboard");
+	}
+
+	initialize(){
+		this.mode = this.table.options.clipboard;
+
+		this.rowRange = this.table.options.clipboardCopyRowRange;
+
+		if(this.mode === true || this.mode === "copy"){
+			this.table.element.addEventListener("copy", (e) => {
+				var plain, html, list;
+
+				if(!this.blocked){
+					e.preventDefault();
+
+					if(this.customSelection){
+						plain = this.customSelection;
+
+						if(this.table.options.clipboardCopyFormatter){
+							plain = this.table.options.clipboardCopyFormatter("plain", plain);
+						}
+					}else{
+
+						list = this.table.modules.export.generateExportList(this.table.options.clipboardCopyConfig, this.table.options.clipboardCopyStyled, this.rowRange, "clipboard");
+
+						html = this.table.modules.export.generateHTMLTable(list);
+						plain = html ? this.generatePlainContent(list) : "";
+
+						if(this.table.options.clipboardCopyFormatter){
+							plain = this.table.options.clipboardCopyFormatter("plain", plain);
+							html = this.table.options.clipboardCopyFormatter("html", html);
+						}
+					}
+
+					if (window.clipboardData && window.clipboardData.setData) {
+						window.clipboardData.setData('Text', plain);
+					} else if (e.clipboardData && e.clipboardData.setData) {
+						e.clipboardData.setData('text/plain', plain);
+						if(html){
+							e.clipboardData.setData('text/html', html);
+						}
+					} else if (e.originalEvent && e.originalEvent.clipboardData.setData) {
+						e.originalEvent.clipboardData.setData('text/plain', plain);
+						if(html){
+							e.originalEvent.clipboardData.setData('text/html', html);
+						}
+					}
+
+					this.dispatchExternal("clipboardCopied", plain, html);
+
+					this.reset();
+				}
+			});
+		}
+
+		if(this.mode === true || this.mode === "paste"){
+			this.table.element.addEventListener("paste", (e) => {
+				this.paste(e);
+			});
+		}
+
+		this.setPasteParser(this.table.options.clipboardPasteParser);
+		this.setPasteAction(this.table.options.clipboardPasteAction);
+
+		this.registerTableFunction("copyToClipboard", this.copy.bind(this));
+	}
+
+	reset(){
+		this.blocked = true;
+		this.customSelection = false;
+	}
+
+	generatePlainContent (list) {
+		var output = [];
+
+		list.forEach((row) => {
+			var rowData = [];
+
+			row.columns.forEach((col) => {
+				var value = "";
+
+				if(col){
+
+					if(row.type === "group"){
+						col.value = col.component.getKey();
+					}
+
+					if(col.value === null){
+						value = "";
+					}else{
+						switch(typeof col.value){
+							case "object":
+								value = JSON.stringify(col.value);
+								break;
+
+							case "undefined":
+								value = "";
+								break;
+
+							default:
+								value = col.value;
+						}
+					}
+				}
+
+				rowData.push(value);
+			});
+
+			output.push(rowData.join("\t"));
+		});
+
+		return output.join("\n");
+	}
+
+	copy (range, internal) {
+		var sel, textRange;
+		this.blocked = false;
+		this.customSelection = false;
+	
+
+		if (this.mode === true || this.mode === "copy") {
+
+			this.rowRange = range || this.table.options.clipboardCopyRowRange;
+
+			if (typeof window.getSelection != "undefined" && typeof document.createRange != "undefined") {
+				range = document.createRange();
+				range.selectNodeContents(this.table.element);
+				sel = window.getSelection();
+
+				if (sel.toString() && internal) {
+					this.customSelection = sel.toString();
+				}
+
+				sel.removeAllRanges();
+				sel.addRange(range);
+			} else if (typeof document.selection != "undefined" && typeof document.body.createTextRange != "undefined") {
+				textRange = document.body.createTextRange();
+				textRange.moveToElementText(this.table.element);
+				textRange.select();
+			}
+
+			document.execCommand('copy');
+
+			if (sel) {
+				sel.removeAllRanges();
+			}
+		}
+	}
+
+	//PASTE EVENT HANDLING
+	setPasteAction(action){
+
+		switch(typeof action){
+			case "string":
+				this.pasteAction = Clipboard.pasteActions[action];
+
+				if(!this.pasteAction){
+					console.warn("Clipboard Error - No such paste action found:", action);
+				}
+				break;
+
+			case "function":
+				this.pasteAction = action;
+				break;
+		}
+	}
+
+	setPasteParser(parser){
+		switch(typeof parser){
+			case "string":
+				this.pasteParser = Clipboard.pasteParsers[parser];
+
+				if(!this.pasteParser){
+					console.warn("Clipboard Error - No such paste parser found:", parser);
+				}
+				break;
+
+			case "function":
+				this.pasteParser = parser;
+				break;
+		}
+	}
+
+	paste(e){
+		var data, rowData, rows;
+
+		if(this.checkPasteOrigin(e)){
+
+			data = this.getPasteData(e);
+
+			rowData = this.pasteParser.call(this, data);
+
+			if(rowData){
+				e.preventDefault();
+
+				if(this.table.modExists("mutator")){
+					rowData = this.mutateData(rowData);
+				}
+
+				rows = this.pasteAction.call(this, rowData);
+
+				this.dispatchExternal("clipboardPasted", data, rowData, rows);
+			}else{
+				this.dispatchExternal("clipboardPasteError", data);
+			}
+		}
+	}
+
+	mutateData(data){
+		var output = [];
+
+		if(Array.isArray(data)){
+			data.forEach((row) => {
+				output.push(this.table.modules.mutator.transformRow(row, "clipboard"));
+			});
+		}else{
+			output = data;
+		}
+
+		return output;
+	}
+
+
+	checkPasteOrigin(e){
+		var valid = true;
+		var blocked = this.confirm("clipboard-paste", [e]);
+
+		if(blocked || !["DIV", "SPAN"].includes(e.target.tagName)){
+			valid = false;
+		}
+
+		return valid;
+	}
+
+	getPasteData(e){
+		var data;
+
+		if (window.clipboardData && window.clipboardData.getData) {
+			data = window.clipboardData.getData('Text');
+		} else if (e.clipboardData && e.clipboardData.getData) {
+			data = e.clipboardData.getData('text/plain');
+		} else if (e.originalEvent && e.originalEvent.clipboardData.getData) {
+			data = e.originalEvent.clipboardData.getData('text/plain');
+		}
+
+		return data;
+	}
+}

package/src/js/modules/Clipboard/defaults/pasteActions.js

@@ -0,0 +1,11 @@
+export default {
+	replace:function(data){
+		return this.table.setData(data);
+	},
+	update:function(data){
+		return this.table.updateOrAddData(data);
+	},
+	insert:function(data){
+		return this.table.addData(data);
+	},
+};

package/src/js/modules/Clipboard/defaults/pasteParsers.js

@@ -0,0 +1,75 @@
+export default {
+	table:function(clipboard){
+		var data = [],
+		headerFindSuccess = true,
+		columns = this.table.columnManager.columns,
+		columnMap = [],
+		rows = [];
+		
+		//get data from clipboard into array of columns and rows.
+		clipboard = clipboard.split("\n");
+		
+		clipboard.forEach(function(row){
+			data.push(row.split("\t"));
+		});
+		
+		if(data.length && !(data.length === 1 && data[0].length < 2)){
+			
+			//check if headers are present by title
+			data[0].forEach(function(value){
+				var column = columns.find(function(column){
+					return value && column.definition.title && value.trim() && column.definition.title.trim() === value.trim();
+				});
+				
+				if(column){
+					columnMap.push(column);
+				}else{
+					headerFindSuccess = false;
+				}
+			});
+			
+			//check if column headers are present by field
+			if(!headerFindSuccess){
+				headerFindSuccess = true;
+				columnMap = [];
+				
+				data[0].forEach(function(value){
+					var column = columns.find(function(column){
+						return value && column.field && value.trim() && column.field.trim() === value.trim();
+					});
+					
+					if(column){
+						columnMap.push(column);
+					}else{
+						headerFindSuccess = false;
+					}
+				});
+				
+				if(!headerFindSuccess){
+					columnMap = this.table.columnManager.columnsByIndex;
+				}
+			}
+			
+			//remove header row if found
+			if(headerFindSuccess){
+				data.shift();
+			}
+			
+			data.forEach(function(item){
+				var row = {};
+				
+				item.forEach(function(value, i){
+					if(columnMap[i]){
+						row[columnMap[i].field] = value;
+					}
+				});
+				
+				rows.push(row);
+			});
+			
+			return rows;
+		}else{
+			return false;
+		}
+	},
+};

package/src/js/modules/Clipboard/extensions/extensions.js

@@ -0,0 +1,9 @@
+import bindings from './keybindings/bindings.js';
+import actions from './keybindings/actions.js';
+
+export default {
+	keybindings:{
+		bindings:bindings,
+		actions:actions
+	},
+};

package/src/js/modules/Clipboard/extensions/keybindings/actions.js

@@ -0,0 +1,9 @@
+export default {
+	copyToClipboard:function(e){
+		if(!this.table.modules.edit.currentCell){
+			if(this.table.modExists("clipboard", true)){
+				this.table.modules.clipboard.copy(false, true);
+			}
+		}
+	},
+};

package/src/js/modules/Clipboard/extensions/keybindings/bindings.js

@@ -0,0 +1,3 @@
+export default {
+	copyToClipboard:["ctrl + 67", "meta + 67"],
+};

package/src/js/modules/ColumnCalcs/CalcComponent.js

@@ -0,0 +1,46 @@
+export default class CalcComponent{
+	constructor (row){
+		this._row = row;
+
+		return new Proxy(this, {
+			get: function(target, name, receiver) {
+				if (typeof target[name] !== "undefined") {
+					return target[name];
+				}else{
+					return target._row.table.componentFunctionBinder.handle("row", target._row, name);
+				}
+			}
+		});
+	}
+
+	getData(transform){
+		return this._row.getData(transform);
+	}
+
+	getElement(){
+		return this._row.getElement();
+	}
+
+	getTable(){
+		return this._row.table;
+	}
+
+	getCells(){
+		var cells = [];
+
+		this._row.getCells().forEach(function(cell){
+			cells.push(cell.getComponent());
+		});
+
+		return cells;
+	}
+
+	getCell(column){
+		var cell = this._row.getCell(column);
+		return cell ? cell.getComponent() : false;
+	}
+
+	_getSelf(){
+		return this._row;
+	}
+}