tabulator-tables 6.5.0 → 6.5.1

package/src/js/modules/Download/Download.js

@@ -0,0 +1,146 @@
+import Module from '../../core/Module.js';
+
+import defaultDownloaders from './defaults/downloaders.js';
+
+export default class Download extends Module{
+
+	static moduleName = "download";
+
+	//load defaults
+	static downloaders = defaultDownloaders;
+
+	constructor(table){
+		super(table);
+
+		this.registerTableOption("downloadEncoder", function(data, mimeType){
+			return new Blob([data],{type:mimeType});
+		}); //function to manipulate download data
+		this.registerTableOption("downloadConfig", {}); //download config
+		this.registerTableOption("downloadRowRange", "active"); //restrict download to active rows only
+
+		this.registerColumnOption("download");
+		this.registerColumnOption("titleDownload");
+	}
+
+	initialize(){
+		this.deprecatedOptionsCheck();
+
+		this.registerTableFunction("download", this.download.bind(this));
+		this.registerTableFunction("downloadToTab", this.downloadToTab.bind(this));
+	}
+
+	deprecatedOptionsCheck(){
+
+	}	
+
+	///////////////////////////////////
+	///////// Table Functions /////////
+	///////////////////////////////////
+
+	downloadToTab(type, filename, options, active){
+		this.download(type, filename, options, active, true);
+	}
+
+	///////////////////////////////////
+	///////// Internal Logic //////////
+	///////////////////////////////////
+
+	//trigger file download
+	download(type, filename, options, range, interceptCallback){
+		var downloadFunc = false;
+
+		function buildLink(data, mime){
+			if(interceptCallback){
+				if(interceptCallback === true){
+					this.triggerDownload(data, mime, type, filename, true);
+				}else{
+					interceptCallback(data);
+				}
+
+			}else{
+				this.triggerDownload(data, mime, type, filename);
+			}
+		}
+
+		if(typeof type == "function"){
+			downloadFunc = type;
+		}else{
+			if(Download.downloaders[type]){
+				downloadFunc = Download.downloaders[type];
+			}else{
+				console.warn("Download Error - No such download type found: ", type);
+			}
+		}
+
+		if(downloadFunc){
+			var list = this.generateExportList(range);
+
+			downloadFunc.call(this.table, list , options || {}, buildLink.bind(this));
+		}
+	}
+
+	generateExportList(range){
+		var list = this.table.modules.export.generateExportList(this.table.options.downloadConfig, false, range || this.table.options.downloadRowRange, "download");
+
+		//assign group header formatter
+		var groupHeader = this.table.options.groupHeaderDownload;
+
+		if(groupHeader && !Array.isArray(groupHeader)){
+			groupHeader = [groupHeader];
+		}
+
+		list.forEach((row) => {
+			var group;
+
+			if(row.type === "group"){
+				group = row.columns[0];
+
+				if(groupHeader && groupHeader[row.indent]){
+					group.value = groupHeader[row.indent](group.value, row.component._group.getRowCount(), row.component._group.getData(), row.component);
+				}
+			}
+		});
+
+		return list;
+	}
+
+	triggerDownload(data, mime, type, filename, newTab){
+		var element = document.createElement('a'),
+		blob = this.table.options.downloadEncoder(data, mime);
+
+		if(blob){
+			if(newTab){
+				window.open(window.URL.createObjectURL(blob));
+			}else{
+				filename = filename || "Tabulator." + (typeof type === "function" ? "txt" : type);
+				
+				if(navigator.msSaveOrOpenBlob){
+					navigator.msSaveOrOpenBlob(blob, filename);
+				}else{
+					element.setAttribute('href', window.URL.createObjectURL(blob));
+
+					//set file title
+					element.setAttribute('download', filename);
+
+					//trigger download
+					element.style.display = 'none';
+					document.body.appendChild(element);
+					element.click();
+
+					//remove temporary link element
+					document.body.removeChild(element);
+				}
+			}
+
+			this.dispatchExternal("downloadComplete");
+		}
+	}
+
+	commsReceived(table, action, data){
+		switch(action){
+			case "intercept":
+				this.download(data.type, "", data.options, data.active, data.intercept);
+				break;
+		}
+	}
+}

package/src/js/modules/Download/defaults/downloaders/csv.js

@@ -0,0 +1,61 @@
+export default function(list, options = {}, setFileContents){
+	var delimiter = options.delimiter ? options.delimiter : ",",
+	fileContents = [],
+	headers = [];
+
+	list.forEach((row) => {
+		var item = [];
+
+		switch(row.type){
+			case "group":
+				console.warn("Download Warning - CSV downloader cannot process row groups");
+				break;
+
+			case "calc":
+				console.warn("Download Warning - CSV downloader cannot process column calculations");
+				break;
+
+			case "header":
+				row.columns.forEach((col, i) => {
+					if(col && col.depth === 1){
+						headers[i] = typeof col.value == "undefined"  || col.value === null ? "" : ('"' + String(col.value).split('"').join('""') + '"');
+					}
+				});
+				break;
+
+			case "row":
+				row.columns.forEach((col) => {
+
+					if(col){
+
+						switch(typeof col.value){
+							case "object":
+								col.value = col.value !== null ? JSON.stringify(col.value) : "";
+								break;
+
+							case "undefined":
+								col.value = "";
+								break;
+						}
+
+						item.push('"' + String(col.value).split('"').join('""') + '"');
+					}
+				});
+
+				fileContents.push(item.join(delimiter));
+				break;
+		}
+	});
+
+	if(headers.length){
+		fileContents.unshift(headers.join(delimiter));
+	}
+
+	fileContents = fileContents.join("\n");
+
+	if(options.bom){
+		fileContents = "\ufeff" + fileContents;
+	}
+
+	setFileContents(fileContents, "text/csv");
+}

package/src/js/modules/Download/defaults/downloaders/html.js

@@ -0,0 +1,5 @@
+export default function(list, options, setFileContents){
+	if(this.modExists("export", true)){
+		setFileContents(this.modules.export.generateHTMLTable(list), "text/html");
+	}
+}

package/src/js/modules/Download/defaults/downloaders/json.js

@@ -0,0 +1,34 @@
+export default function(list, options, setFileContents){
+	var fileContents = [];
+
+	list.forEach((row) => {
+		var item = {};
+
+		switch(row.type){
+			case "header":
+				break;
+
+			case "group":
+				console.warn("Download Warning - JSON downloader cannot process row groups");
+				break;
+
+			case "calc":
+				console.warn("Download Warning - JSON downloader cannot process column calculations");
+				break;
+
+			case "row":
+				row.columns.forEach((col) => {
+					if(col){
+						item[col.component.getTitleDownload() || col.component.getField()] = col.value;
+					}
+				});
+
+				fileContents.push(item);
+				break;
+		}
+	});
+
+	fileContents = JSON.stringify(fileContents, null, '\t');
+
+	setFileContents(fileContents, "application/json");
+}

package/src/js/modules/Download/defaults/downloaders/jsonLines.js

@@ -0,0 +1,32 @@
+export default function (list, options, setFileContents) {
+	const fileContents = [];
+
+	list.forEach((row) => {
+		const item = {};
+
+		switch (row.type) {
+			case "header":
+				break;
+
+			case "group":
+				console.warn("Download Warning - JSON downloader cannot process row groups");
+				break;
+
+			case "calc":
+				console.warn("Download Warning - JSON downloader cannot process column calculations");
+				break;
+
+			case "row":
+				row.columns.forEach((col) => {
+					if (col) {
+						item[col.component.getTitleDownload() || col.component.getField()] = col.value;
+					}
+				});
+
+				fileContents.push(JSON.stringify(item));
+				break;
+		}
+	});
+
+	setFileContents(fileContents.join("\n"), "application/x-ndjson");
+}

package/src/js/modules/Download/defaults/downloaders/pdf.js

@@ -0,0 +1,113 @@
+export default function(list, options = {}, setFileContents){
+	var header = [],
+	body = [],
+	autoTableParams = {},
+	rowGroupStyles = options.rowGroupStyles || {
+		fontStyle: "bold",
+		fontSize: 12,
+		cellPadding: 6,
+		fillColor: 220,
+	},
+	rowCalcStyles = options.rowCalcStyles || {
+		fontStyle: "bold",
+		fontSize: 10,
+		cellPadding: 4,
+		fillColor: 232,
+	},
+	jsPDFParams = options.jsPDF || {},
+	title = options.title ? options.title : "",
+	jspdfLib, doc;
+
+	if(!jsPDFParams.orientation){
+		jsPDFParams.orientation = options.orientation || "landscape";
+	}
+
+	if(!jsPDFParams.unit){
+		jsPDFParams.unit = "pt";
+	}
+
+	//parse row list
+	list.forEach((row) => {
+		switch(row.type){
+			case "header":
+				header.push(parseRow(row));
+				break;
+
+			case "group":
+				body.push(parseRow(row, rowGroupStyles));
+				break;
+
+			case "calc":
+				body.push(parseRow(row, rowCalcStyles));
+				break;
+
+			case "row":
+				body.push(parseRow(row));
+				break;
+		}
+	});
+
+	function parseRow(row, styles){
+		var rowData = [];
+
+		row.columns.forEach((col) =>{
+			var cell;
+
+			if(col){
+				switch(typeof col.value){
+					case "object":
+						col.value = col.value !== null ? JSON.stringify(col.value) : "";
+						break;
+
+					case "undefined":
+						col.value = "";
+						break;
+				}
+
+				cell = {
+					content:col.value,
+					colSpan:col.width,
+					rowSpan:col.height,
+				};
+
+				if(styles){
+					cell.styles = styles;
+				}
+
+				rowData.push(cell);
+			}
+		});
+
+		return rowData;
+	}
+
+
+	//configure PDF
+	jspdfLib = this.dependencyRegistry.lookup("jspdf", "jsPDF");
+	doc = new jspdfLib(jsPDFParams); //set document to landscape, better for most tables
+
+	if(options.autoTable){
+		if(typeof options.autoTable === "function"){
+			autoTableParams = options.autoTable(doc) || {};
+		}else{
+			autoTableParams = options.autoTable;
+		}
+	}
+
+	if(title){
+		autoTableParams.didDrawPage = function(data) {
+			doc.text(title, 40, 30);
+		};
+	}
+
+	autoTableParams.head = header;
+	autoTableParams.body = body;
+
+	doc.autoTable(autoTableParams);
+
+	if(options.documentProcessing){
+		options.documentProcessing(doc);
+	}
+
+	setFileContents(doc.output("arraybuffer"), "application/pdf");
+}

package/src/js/modules/Download/defaults/downloaders/xlsx.js

@@ -0,0 +1,103 @@
+import CoreFeature from '../../../../core/CoreFeature.js';
+
+export default function(list, options, setFileContents){
+	var self = this,
+	sheetName = options.sheetName || "Sheet1",
+	XLSXLib = this.dependencyRegistry.lookup("XLSX"),
+	workbook = XLSXLib.utils.book_new(),
+	tableFeatures = new CoreFeature(this),
+	compression =  'compress' in options ? options.compress : true,
+	writeOptions = options.writeOptions || {bookType:'xlsx', bookSST:true, compression},
+	output;
+
+	writeOptions.type = 'binary';
+
+	workbook.SheetNames = [];
+	workbook.Sheets = {};
+
+	function generateSheet(){
+		var rows = [],
+		merges = [],
+		worksheet = {},
+		range = {s: {c:0, r:0}, e: {c:(list[0] ? list[0].columns.reduce((a, b) => a + (b && b.width ? b.width : 1), 0) : 0), r:list.length }};
+
+		//parse row list
+		list.forEach((row, i) => {
+			var rowData = [];
+
+			row.columns.forEach(function(col, j){
+
+				if(col){
+					rowData.push(!(col.value instanceof Date) && typeof col.value === "object" ? JSON.stringify(col.value) : col.value);
+
+					if(col.width > 1 || col.height > -1){
+						if(col.height > 1 || col.width > 1){
+							merges.push({s:{r:i,c:j},e:{r:i + col.height - 1,c:j + col.width - 1}});
+						}
+					}
+				}else{
+					rowData.push("");
+				}
+			});
+
+			rows.push(rowData);
+		});
+
+		//convert rows to worksheet
+		XLSXLib.utils.sheet_add_aoa(worksheet, rows);
+
+		worksheet['!ref'] = XLSXLib.utils.encode_range(range);
+
+		if(merges.length){
+			worksheet["!merges"] = merges;
+		}
+
+		return worksheet;
+	}
+
+	if(options.sheetOnly){
+		setFileContents(generateSheet());
+		return;
+	}
+
+	if(options.sheets){
+		for(var sheet in options.sheets){
+
+			if(options.sheets[sheet] === true){
+				workbook.SheetNames.push(sheet);
+				workbook.Sheets[sheet] = generateSheet();
+			}else{
+
+				workbook.SheetNames.push(sheet);
+
+				tableFeatures.commsSend(options.sheets[sheet], "download", "intercept",{
+					type:"xlsx",
+					options:{sheetOnly:true},
+					active:self.active,
+					intercept:function(data){
+						workbook.Sheets[sheet] = data;
+					}
+				});
+			}
+		}
+	}else{
+		workbook.SheetNames.push(sheetName);
+		workbook.Sheets[sheetName] = generateSheet();
+	}
+
+	if(options.documentProcessing){
+		workbook = options.documentProcessing(workbook);
+	}
+
+	//convert workbook to binary array
+	function s2ab(s) {
+		var buf = new ArrayBuffer(s.length);
+		var view = new Uint8Array(buf);
+		for (var i=0; i!=s.length; ++i) view[i] = s.charCodeAt(i) & 0xFF;
+		return buf;
+	}
+
+	output = XLSXLib.write(workbook, writeOptions);
+
+	setFileContents(s2ab(output), "application/octet-stream");
+}

package/src/js/modules/Download/defaults/downloaders.js

@@ -0,0 +1,15 @@
+import csv from './downloaders/csv.js';
+import json from './downloaders/json.js';
+import pdf from './downloaders/pdf.js';
+import xlsx from './downloaders/xlsx.js';
+import html from './downloaders/html.js';
+import jsonLines from './downloaders/jsonLines.js';
+
+export default {
+	csv:csv,
+	json:json,
+	jsonLines:jsonLines,
+	pdf:pdf,
+	xlsx:xlsx,
+	html:html,
+};