tabulator-tables 6.5.0 → 6.5.1

package/src/js/modules/Sort/defaults/sorters/datetime.js

@@ -0,0 +1,48 @@
+//sort datetime
+export default function(a, b, aRow, bRow, column, dir, params){
+	var DT = this.table.dependencyRegistry.lookup(["luxon", "DateTime"], "DateTime");
+	var format = params.format || "dd/MM/yyyy HH:mm:ss",
+	alignEmptyValues = params.alignEmptyValues,
+	emptyAlign = 0;
+
+	if(typeof DT != "undefined"){
+		if(!DT.isDateTime(a)){
+			if(format === "iso"){
+				a = DT.fromISO(String(a));
+			}else if(format === "x"){
+				a = DT.fromMillis(a);
+			}else{
+				a = DT.fromFormat(String(a), format);
+			}
+		}
+
+		if(!DT.isDateTime(b)){
+			if(format === "iso"){
+				b = DT.fromISO(String(b));
+			}else if(format === "x"){
+				b = DT.fromMillis(b);
+			}else{
+				b = DT.fromFormat(String(b), format);
+			}
+		}
+
+		if(!a.isValid){
+			emptyAlign = !b.isValid ? 0 : -1;
+		}else if(!b.isValid){
+			emptyAlign =  1;
+		}else{
+			//compare valid values
+			return a - b;
+		}
+
+		//fix empty values in position
+		if((alignEmptyValues === "top" && dir === "desc") || (alignEmptyValues === "bottom" && dir === "asc")){
+			emptyAlign *= -1;
+		}
+
+		return emptyAlign;
+
+	}else{
+		console.error("Sort Error - 'datetime' sorter is dependant on luxon.js");
+	}
+}

package/src/js/modules/Sort/defaults/sorters/exists.js

@@ -0,0 +1,7 @@
+//sort if element contains any data
+export default function(a, b, aRow, bRow, column, dir, params){
+	var el1 = typeof a == "undefined" ? 0 : 1;
+	var el2 = typeof b == "undefined" ? 0 : 1;
+
+	return el1 - el2;
+}

package/src/js/modules/Sort/defaults/sorters/number.js

@@ -0,0 +1,40 @@
+//sort numbers
+export default function(a, b, aRow, bRow, column, dir, params){
+	var alignEmptyValues = params.alignEmptyValues;
+	var decimal = params.decimalSeparator;
+	var thousand = params.thousandSeparator;
+	var emptyAlign = 0;
+
+	a = String(a);
+	b = String(b);
+
+	if(thousand){
+		a = a.split(thousand).join("");
+		b = b.split(thousand).join("");
+	}
+
+	if(decimal){
+		a = a.split(decimal).join(".");
+		b = b.split(decimal).join(".");
+	}
+
+	a = parseFloat(a);
+	b = parseFloat(b);
+
+	//handle non numeric values
+	if(isNaN(a)){
+		emptyAlign =  isNaN(b) ? 0 : -1;
+	}else if(isNaN(b)){
+		emptyAlign =  1;
+	}else{
+		//compare valid values
+		return a - b;
+	}
+
+	//fix empty values in position
+	if((alignEmptyValues === "top" && dir === "desc") || (alignEmptyValues === "bottom" && dir === "asc")){
+		emptyAlign *= -1;
+	}
+
+	return emptyAlign;
+}

package/src/js/modules/Sort/defaults/sorters/string.js

@@ -0,0 +1,34 @@
+//sort strings
+export default function(a, b, aRow, bRow, column, dir, params){
+	var alignEmptyValues = params.alignEmptyValues;
+	var emptyAlign = 0;
+	var locale;
+
+	//handle empty values
+	if(!a){
+		emptyAlign =  !b ? 0 : -1;
+	}else if(!b){
+		emptyAlign =  1;
+	}else{
+		//compare valid values
+		switch(typeof params.locale){
+			case "boolean":
+				if(params.locale){
+					locale = this.langLocale();
+				}
+				break;
+			case "string":
+				locale = params.locale;
+				break;
+		}
+
+		return String(a).toLowerCase().localeCompare(String(b).toLowerCase(), locale);
+	}
+
+	//fix empty values in position
+	if((alignEmptyValues === "top" && dir === "desc") || (alignEmptyValues === "bottom" && dir === "asc")){
+		emptyAlign *= -1;
+	}
+
+	return emptyAlign;
+}

package/src/js/modules/Sort/defaults/sorters/time.js

@@ -0,0 +1,10 @@
+import datetime from './datetime.js';
+
+//sort times
+export default function(a, b, aRow, bRow, column, dir, params){
+	if(!params.format){
+		params.format = "HH:mm";
+	}
+
+	return datetime.call(this, a, b, aRow, bRow, column, dir, params);
+}

package/src/js/modules/Sort/defaults/sorters.js

@@ -0,0 +1,21 @@
+import number from './sorters/number.js';
+import string from './sorters/string.js';
+import date from './sorters/date.js';
+import time from './sorters/time.js';
+import datetime from './sorters/datetime.js';
+import boolean from './sorters/boolean.js';
+import array from './sorters/array.js';
+import exists from './sorters/exists.js';
+import alphanum from './sorters/alphanum.js';
+
+export default {
+	number:number,
+	string:string,
+	date:date,
+	time:time,
+	datetime:datetime,
+	boolean:boolean,
+	array:array,
+	exists:exists,
+	alphanum:alphanum
+};

package/src/js/modules/Spreadsheet/GridCalculator.js

@@ -0,0 +1,64 @@
+export default class GridCalculator{
+	constructor(columns, rows){
+		this.columnCount = columns;
+		this.rowCount = rows;
+
+		this.columnString = [];
+		this.columns = [];
+		this.rows = [];
+	}
+
+	genColumns(data){
+		var colCount = Math.max(this.columnCount, Math.max(...data.map(item => item.length)));
+
+		this.columnString = [];
+		this.columns = [];
+
+		for(let i = 1; i <= colCount; i++){
+			this.incrementChar(this.columnString.length - 1);
+			this.columns.push(this.columnString.join(""));
+		}
+
+		return this.columns;
+	}
+
+	genRows(data){
+		var rowCount = Math.max(this.rowCount, data.length);
+
+		this.rows = [];
+
+		for(let i = 1; i <= rowCount; i++){
+			this.rows.push(i);
+		}
+		
+		return this.rows;
+	}
+
+	incrementChar(i){
+		let char = this.columnString[i];
+
+		if(char){
+			if(char !== "Z"){
+				this.columnString[i] = String.fromCharCode(this.columnString[i].charCodeAt(0) + 1);
+			}else{
+				this.columnString[i] = "A";
+				
+				if(i){
+					this.incrementChar(i-1);
+				}else{
+					this.columnString.push("A");
+				}
+			}
+		}else{
+			this.columnString.push("A");
+		}
+	}
+
+	setRowCount(count){
+		this.rowCount = count;
+	}
+
+	setColumnCount(count){
+		this.columnCount = count;
+	}
+}

package/src/js/modules/Spreadsheet/Sheet.js

@@ -0,0 +1,243 @@
+import CoreFeature from '../../core/CoreFeature.js';
+import GridCalculator from "./GridCalculator";
+import SheetComponent from "./SheetComponent";
+
+export default class Sheet extends CoreFeature{
+	constructor(spreadsheetManager, definition) {
+		super(spreadsheetManager.table);
+		
+		this.spreadsheetManager = spreadsheetManager;
+		this.definition = definition;
+		
+		this.title = this.definition.title || "";
+		this.key = this.definition.key || this.definition.title;
+		this.rowCount = this.definition.rows;
+		this.columnCount = this.definition.columns;
+		this.data = this.definition.data || [];
+		this.element = null;
+		this.isActive = false;
+		
+		this.grid = new GridCalculator(this.columnCount, this.rowCount);
+		
+		this.defaultColumnDefinition = {width:100, headerHozAlign:"center", headerSort:false};
+		this.columnDefinition = Object.assign(this.defaultColumnDefinition, this.options("spreadsheetColumnDefinition"));
+		
+		this.columnDefs = [];
+		this.rowDefs = [];
+		this.columnFields = [];
+		this.columns = [];
+		this.rows = [];
+		
+		this.scrollTop = null;
+		this.scrollLeft = null;
+		
+		this.initialize();
+		
+		this.dispatchExternal("sheetAdded", this.getComponent());
+	}
+	
+	///////////////////////////////////
+	///////// Initialization //////////
+	///////////////////////////////////
+	
+	initialize(){
+		this.initializeElement();
+		this.initializeColumns();
+		this.initializeRows();
+	}
+	
+	reinitialize(){
+		this.initializeColumns();
+		this.initializeRows();
+	}
+	
+	initializeElement(){
+		this.element = document.createElement("div");
+		this.element.classList.add("tabulator-spreadsheet-tab");
+		this.element.innerText = this.title;
+		
+		this.element.addEventListener("click", () => {
+			this.spreadsheetManager.loadSheet(this);
+		});
+	}
+	
+	initializeColumns(){
+		this.grid.setColumnCount(this.columnCount);
+		this.columnFields = this.grid.genColumns(this.data);
+		
+		this.columnDefs = [];
+		
+		this.columnFields.forEach((ref) => {
+			var def = Object.assign({}, this.columnDefinition);
+			def.field = ref;
+			def.title = ref;
+			
+			this.columnDefs.push(def);
+		});
+	}
+	
+	initializeRows(){
+		var refs;
+		
+		this.grid.setRowCount(this.rowCount);
+		
+		refs = this.grid.genRows(this.data);
+		
+		this.rowDefs = [];
+		
+		refs.forEach((ref, i) => {
+			var def = {"_id":ref};
+			var data = this.data[i];
+			
+			if(data){
+				data.forEach((val, j) => {
+					var field = this.columnFields[j];
+					
+					if(field){
+						def[field] = val;
+					}
+				});
+			}
+			
+			this.rowDefs.push(def);
+		});
+	}
+	
+	unload(){
+		this.isActive = false;
+		this.scrollTop = this.table.rowManager.scrollTop;
+		this.scrollLeft = this.table.rowManager.scrollLeft;
+		this.data = this.getData(true);
+		this.element.classList.remove("tabulator-spreadsheet-tab-active");
+	}
+	
+	load(){
+		
+		var wasInactive = !this.isActive;
+		
+		this.isActive = true;
+		this.table.blockRedraw();
+		this.table.setData([]);
+		this.table.setColumns(this.columnDefs);
+		this.table.setData(this.rowDefs);
+		this.table.restoreRedraw();
+		
+		if(wasInactive && this.scrollTop !== null){
+			this.table.rowManager.element.scrollLeft = this.scrollLeft;
+			this.table.rowManager.element.scrollTop = this.scrollTop;
+		}
+		
+		this.element.classList.add("tabulator-spreadsheet-tab-active");
+		
+		this.dispatchExternal("sheetLoaded", this.getComponent());
+	}
+	
+	///////////////////////////////////
+	//////// Helper Functions /////////
+	///////////////////////////////////
+	
+	getComponent(){
+		return new SheetComponent(this);
+	}
+	
+	getDefinition(){
+		return {
+			title:this.title,
+			key:this.key,
+			rows:this.rowCount,
+			columns:this.columnCount,
+			data:this.getData(),
+		};
+	}
+	
+	getData(full){
+		var output = [], 
+		rowWidths,
+		outputWidth, outputHeight;
+		
+		//map data to array format
+		this.rowDefs.forEach((rowData) => {
+			var row = [];
+			
+			this.columnFields.forEach((field) => {
+				row.push(rowData[field]);
+			});
+			
+			output.push(row);
+		});
+		
+		//trim output
+		if(!full && !this.options("spreadsheetOutputFull")){
+			
+			//calculate used area of data
+			rowWidths = output.map(row => row.findLastIndex(val => typeof val !== 'undefined') + 1);
+			outputWidth = Math.max(...rowWidths);
+			outputHeight = rowWidths.findLastIndex(width => width > 0) + 1;
+			
+			output = output.slice(0, outputHeight);
+			output = output.map(row => row.slice(0, outputWidth));
+		}
+		
+		return output;
+	}
+	
+	setData(data){
+		this.data = data;
+		this.reinitialize();
+		
+		this.dispatchExternal("sheetUpdated", this.getComponent());
+		
+		if(this.isActive){
+			this.load();
+		}
+	}
+	
+	clear(){
+		this.setData([]);
+	}
+	
+	setTitle(title){
+		this.title = title;
+		this.element.innerText = title;
+		
+		this.dispatchExternal("sheetUpdated", this.getComponent());
+	}
+	
+	setRows(rows){
+		this.rowCount = rows;
+		this.initializeRows();
+		
+		this.dispatchExternal("sheetUpdated", this.getComponent());
+		
+		if(this.isActive){
+			this.load();
+		}
+	}
+	
+	setColumns(columns){
+		this.columnCount = columns;
+		this.reinitialize();
+		
+		this.dispatchExternal("sheetUpdated", this.getComponent());
+		
+		if(this.isActive){
+			this.load();
+		}
+	}
+	
+	remove(){
+		this.spreadsheetManager.removeSheet(this);
+	}
+	
+	destroy(){
+		if(this.element.parentNode){
+			this.element.parentNode.removeChild(this.element);
+		}
+		
+		this.dispatchExternal("sheetRemoved", this.getComponent());
+	}
+	
+	active(){
+		this.spreadsheetManager.loadSheet(this);
+	}
+}

package/src/js/modules/Spreadsheet/SheetComponent.js

@@ -0,0 +1,59 @@
+export default class SheetComponent {
+	constructor(sheet) {
+		this._sheet = sheet;
+
+		return new Proxy(this, {
+			get: function (target, name, receiver) {
+				if (typeof target[name] !== "undefined") {
+					return target[name];
+				} else {
+					return target._sheet.table.componentFunctionBinder.handle("sheet", target._sheet, name);
+				}
+			},
+		});
+	}
+
+	getTitle(){
+		return this._sheet.title;
+	}
+
+	getKey(){
+		return this._sheet.key;
+	}
+
+	getDefinition(){
+		return this._sheet.getDefinition();
+	}
+
+	getData() {
+		return this._sheet.getData();
+	}
+
+	setData(data) {
+		return this._sheet.setData(data);
+	}
+
+	clear(){
+		return this._sheet.clear();
+	}
+
+	remove(){
+		return this._sheet.remove();
+	}
+	
+	active(){
+		return this._sheet.active();
+	}
+
+	setTitle(title){
+		return this._sheet.setTitle(title);
+	}
+
+	setRows(rows){
+		return this._sheet.setRows(rows);
+	}
+
+	setColumns(columns){
+		return this._sheet.setColumns(columns);
+	}
+}