tabulator-tables 6.5.0 → 6.5.1

package/src/js/core/column/ColumnComponent.js

@@ -0,0 +1,151 @@
+//public column object
+export default class ColumnComponent {
+	constructor (column){
+		this._column = column;
+		this.type = "ColumnComponent";
+
+		return new Proxy(this, {
+			get: function(target, name, receiver) {
+				if (typeof target[name] !== "undefined") {
+					return target[name];
+				}else{
+					return target._column.table.componentFunctionBinder.handle("column", target._column, name);
+				}
+			}
+		});
+	}
+
+	getElement(){
+		return this._column.getElement();
+	}
+
+	getDefinition(){
+		return this._column.getDefinition();
+	}
+
+	getField(){
+		return this._column.getField();
+	}
+
+	getTitleDownload() {
+		return this._column.getTitleDownload();
+	}
+
+	getCells(){
+		var cells = [];
+
+		this._column.cells.forEach(function(cell){
+			cells.push(cell.getComponent());
+		});
+
+		return cells;
+	}
+
+	isVisible(){
+		return this._column.visible;
+	}
+
+	show(){
+		if(this._column.isGroup){
+			this._column.columns.forEach(function(column){
+				column.show();
+			});
+		}else{
+			this._column.show();
+		}
+	}
+
+	hide(){
+		if(this._column.isGroup){
+			this._column.columns.forEach(function(column){
+				column.hide();
+			});
+		}else{
+			this._column.hide();
+		}
+	}
+
+	toggle(){
+		if(this._column.visible){
+			this.hide();
+		}else{
+			this.show();
+		}
+	}
+
+	delete(){
+		return this._column.delete();
+	}
+
+	getSubColumns(){
+		var output = [];
+
+		if(this._column.columns.length){
+			this._column.columns.forEach(function(column){
+				output.push(column.getComponent());
+			});
+		}
+
+		return output;
+	}
+
+	getParentColumn(){
+		return this._column.getParentComponent();
+	}
+
+	_getSelf(){
+		return this._column;
+	}
+
+	scrollTo(position, ifVisible){
+		return this._column.table.columnManager.scrollToColumn(this._column, position, ifVisible);
+	}
+
+	getTable(){
+		return this._column.table;
+	}
+
+	move(to, after){
+		var toColumn = this._column.table.columnManager.findColumn(to);
+
+		if(toColumn){
+			this._column.table.columnManager.moveColumn(this._column, toColumn, after);
+		}else{
+			console.warn("Move Error - No matching column found:", toColumn);
+		}
+	}
+
+	getNextColumn(){
+		var nextCol = this._column.nextColumn();
+
+		return nextCol ? nextCol.getComponent() : false;
+	}
+
+	getPrevColumn(){
+		var prevCol = this._column.prevColumn();
+
+		return prevCol ? prevCol.getComponent() : false;
+	}
+
+	updateDefinition(updates){
+		return this._column.updateDefinition(updates);
+	}
+
+	getWidth(){
+		return this._column.getWidth();
+	}
+
+	setWidth(width){
+		var result;
+
+		if(width === true){
+			result =  this._column.reinitializeWidth(true);
+		}else{
+			result =  this._column.setWidth(width);
+		}
+
+		this._column.table.columnManager.rerenderColumns(true);
+
+		return result;
+	}
+}

package/src/js/core/column/defaults/options.js

@@ -0,0 +1,18 @@
+export default {
+	"title": undefined,
+	"field": undefined,
+	"columns": undefined,
+	"visible": undefined,
+	"hozAlign": undefined,
+	"vertAlign": undefined,
+	"width": undefined,
+	"minWidth": 40,
+	"maxWidth": undefined,
+	"maxInitialWidth": undefined,
+	"cssClass": undefined,
+	"variableHeight": undefined,
+	"headerVertical": undefined,
+	"headerHozAlign": undefined,
+	"headerWordWrap": false,
+	"editableTitle": undefined,
+};

package/src/js/core/defaults/options.js

@@ -0,0 +1,66 @@
+export default {
+
+	debugEventsExternal:false, //flag to console log events
+	debugEventsInternal:false, //flag to console log events
+	debugInvalidOptions:true, //allow toggling of invalid option warnings
+	debugInvalidComponentFuncs:true, //allow toggling of invalid component warnings
+	debugInitialization:true, //allow toggling of pre initialization function call warnings
+	debugDeprecation:true, //allow toggling of deprecation warnings
+
+	height:false, //height of tabulator
+	minHeight:false, //minimum height of tabulator
+	maxHeight:false, //maximum height of tabulator
+
+	columnHeaderVertAlign:"top", //vertical alignment of column headers
+
+	popupContainer:false,
+
+	columns:[],//store for colum header info
+	columnDefaults:{}, //store column default props
+	rowHeader:false,
+
+	data:false, //default starting data
+
+	autoColumns:false, //build columns from data row structure
+	autoColumnsDefinitions:false,
+
+	nestedFieldSeparator:".", //separator for nested data
+
+	footerElement:false, //hold footer element
+
+	index:"id", //filed for row index
+
+	textDirection:"auto",
+
+	addRowPos:"bottom", //position to insert blank rows, top|bottom
+
+	headerVisible:true, //hide header
+
+	renderVertical:"virtual",
+	renderHorizontal:"basic",
+	renderVerticalBuffer:0, // set virtual DOM buffer size
+
+	scrollToRowPosition:"top",
+	scrollToRowIfVisible:true,
+
+	scrollToColumnPosition:"left",
+	scrollToColumnIfVisible:true,
+
+	rowFormatter:false,
+	rowFormatterPrint:null,
+	rowFormatterClipboard:null,
+	rowFormatterHtmlOutput:null,
+
+	rowHeight:null,
+
+	placeholder:false,
+
+	dataLoader:true,
+	dataLoaderLoading:false,
+	dataLoaderError:false,
+	dataLoaderErrorTimeout:3000,
+	dataSendParams:{},
+	dataReceiveParams:{},
+
+	dependencies:{},
+};

package/src/js/core/modules/core.js

@@ -0,0 +1,3 @@
+export {default as LayoutModule} from '../../modules/Layout/Layout.js';
+export {default as LocalizeModule} from '../../modules/Localize/Localize.js';
+export {default as CommsModule} from '../../modules/Comms/Comms.js';

package/src/js/core/modules/optional.js

@@ -0,0 +1,37 @@
+export {default as AccessorModule} from '../../modules/Accessor/Accessor.js';
+export {default as AjaxModule} from '../../modules/Ajax/Ajax.js';
+export {default as ClipboardModule} from '../../modules/Clipboard/Clipboard.js';
+export {default as ColumnCalcsModule} from '../../modules/ColumnCalcs/ColumnCalcs.js';
+export {default as DataTreeModule} from '../../modules/DataTree/DataTree.js';
+export {default as DownloadModule} from '../../modules/Download/Download.js';
+export {default as EditModule} from '../../modules/Edit/Edit.js';
+export {default as ExportModule} from '../../modules/Export/Export.js';
+export {default as FilterModule} from '../../modules/Filter/Filter.js';
+export {default as FormatModule} from '../../modules/Format/Format.js';
+export {default as FrozenColumnsModule} from '../../modules/FrozenColumns/FrozenColumns.js';
+export {default as FrozenRowsModule} from '../../modules/FrozenRows/FrozenRows.js';
+export {default as GroupRowsModule} from '../../modules/GroupRows/GroupRows.js';
+export {default as HistoryModule} from '../../modules/History/History.js';
+export {default as HtmlTableImportModule} from '../../modules/HtmlTableImport/HtmlTableImport.js';
+export {default as ImportModule} from '../../modules/Import/Import.js';
+export {default as InteractionModule} from '../../modules/Interaction/Interaction.js';
+export {default as KeybindingsModule} from '../../modules/Keybindings/Keybindings.js';
+export {default as MenuModule} from '../../modules/Menu/Menu.js';
+export {default as MoveColumnsModule} from '../../modules/MoveColumns/MoveColumns.js';
+export {default as MoveRowsModule} from '../../modules/MoveRows/MoveRows.js';
+export {default as MutatorModule} from '../../modules/Mutator/Mutator.js';
+export {default as PageModule} from '../../modules/Page/Page.js';
+export {default as PersistenceModule} from '../../modules/Persistence/Persistence.js';
+export {default as PopupModule} from '../../modules/Popup/Popup.js';
+export {default as PrintModule} from '../../modules/Print/Print.js';
+export {default as ReactiveDataModule} from '../../modules/ReactiveData/ReactiveData.js';
+export {default as ResizeColumnsModule} from '../../modules/ResizeColumns/ResizeColumns.js';
+export {default as ResizeRowsModule} from '../../modules/ResizeRows/ResizeRows.js';
+export {default as ResizeTableModule} from '../../modules/ResizeTable/ResizeTable.js';
+export {default as ResponsiveLayoutModule} from '../../modules/ResponsiveLayout/ResponsiveLayout.js';
+export {default as SelectRowModule} from '../../modules/SelectRow/SelectRow.js';
+export {default as SelectRangeModule} from '../../modules/SelectRange/SelectRange.js';
+export {default as SortModule} from '../../modules/Sort/Sort.js';
+export {default as SpreadsheetModule} from '../../modules/Spreadsheet/Spreadsheet.js';
+export {default as TooltipModule} from '../../modules/Tooltip/Tooltip.js';
+export {default as ValidateModule} from '../../modules/Validate/Validate.js';

package/src/js/core/rendering/Renderer.js

@@ -0,0 +1,204 @@
+import CoreFeature from '../CoreFeature.js';
+import Helpers from '../tools/Helpers.js';
+
+export default class Renderer extends CoreFeature{
+	constructor(table){
+		super(table);
+
+		this.elementVertical = table.rowManager.element;
+		this.elementHorizontal = table.columnManager.element;
+		this.tableElement =  table.rowManager.tableElement;
+
+		this.verticalFillMode = "fit"; // used by row manager to determine how to size the render area ("fit" - fits container to the contents, "fill" - fills the container without resizing it)
+	}
+
+
+	///////////////////////////////////
+	/////// Internal Bindings /////////
+	///////////////////////////////////
+
+	initialize(){
+		//initialize core functionality
+	}
+
+	clearRows(){
+		//clear down existing rows layout
+	}
+
+	clearColumns(){
+		//clear down existing columns layout
+	}
+
+
+	reinitializeColumnWidths(columns){
+		//resize columns to fit data
+	}
+
+
+	renderRows(){
+		//render rows from a clean slate
+	}
+
+	renderColumns(){
+		//render columns from a clean slate
+	}
+
+	rerenderRows(callback){
+		// rerender rows and keep position
+		if(callback){
+			callback();
+		}
+	}
+
+	rerenderColumns(update, blockRedraw){
+		//rerender columns
+	}
+
+	renderRowCells(row){
+		//render the cells in a row
+	}
+
+	rerenderRowCells(row, force){
+		//rerender the cells in a row
+	}
+
+	scrollColumns(left, dir){
+		//handle horizontal scrolling
+	}
+
+	scrollRows(top, dir){
+		//handle vertical scrolling
+	}
+
+	resize(){
+		//container has resized, carry out any needed recalculations (DO NOT RERENDER IN THIS FUNCTION)
+	}
+
+	scrollToRow(row){
+		//scroll to a specific row
+	}
+
+	scrollToRowNearestTop(row){
+		//determine weather the row is nearest the top or bottom of the table, return true for top or false for bottom
+	}
+
+	visibleRows(includingBuffer){
+		//return the visible rows
+		return [];
+	}
+
+	///////////////////////////////////
+	//////// Helper Functions /////////
+	///////////////////////////////////
+
+	rows(){
+		return this.table.rowManager.getDisplayRows();
+	}
+
+	styleRow(row, index){
+		var rowEl = row.getElement();
+
+		if(index % 2){
+			rowEl.classList.add("tabulator-row-even");
+			rowEl.classList.remove("tabulator-row-odd");
+		}else{
+			rowEl.classList.add("tabulator-row-odd");
+			rowEl.classList.remove("tabulator-row-even");
+		}
+	}
+
+	///////////////////////////////////
+	/////// External Triggers /////////
+	/////// (DO NOT OVERRIDE) /////////
+	///////////////////////////////////
+
+	clear(){
+		//clear down existing layout
+		this.clearRows();
+		this.clearColumns();
+	}
+
+	render(){
+		//render from a clean slate
+		this.renderRows();
+		this.renderColumns();
+	}
+
+	rerender(callback){
+		// rerender and keep position
+		this.rerenderRows();
+		this.rerenderColumns();
+	}
+
+	scrollToRowPosition(row, position, ifVisible){
+		var rowIndex = this.rows().indexOf(row),
+		rowEl = row.getElement(),
+		offset = 0;
+
+		return new Promise((resolve, reject) => {
+			if(rowIndex > -1){
+
+				if(typeof ifVisible === "undefined"){
+					ifVisible = this.table.options.scrollToRowIfVisible;
+				}
+
+				//check row visibility
+				if(!ifVisible){
+					if(Helpers.elVisible(rowEl)){
+						offset = Helpers.elOffset(rowEl).top - Helpers.elOffset(this.elementVertical).top;
+						
+						if(offset > 0 && offset < this.elementVertical.clientHeight - rowEl.offsetHeight){
+							resolve();
+							return false;
+						}
+					}
+				}
+
+				if(typeof position === "undefined"){
+					position = this.table.options.scrollToRowPosition;
+				}
+
+				if(position === "nearest"){
+					position = this.scrollToRowNearestTop(row) ? "top" : "bottom";
+				}
+
+				//scroll to row
+				this.scrollToRow(row);
+
+				//align to correct position
+				switch(position){
+					case "middle":
+					case "center":
+
+						if(this.elementVertical.scrollHeight - this.elementVertical.scrollTop == this.elementVertical.clientHeight){
+							this.elementVertical.scrollTop = this.elementVertical.scrollTop + (rowEl.offsetTop - this.elementVertical.scrollTop) - ((this.elementVertical.scrollHeight - rowEl.offsetTop) / 2);
+						}else{
+							this.elementVertical.scrollTop = this.elementVertical.scrollTop - (this.elementVertical.clientHeight / 2);
+						}
+
+						break;
+
+					case "bottom":
+
+						if(this.elementVertical.scrollHeight - this.elementVertical.scrollTop == this.elementVertical.clientHeight){
+							this.elementVertical.scrollTop = this.elementVertical.scrollTop - (this.elementVertical.scrollHeight - rowEl.offsetTop) + rowEl.offsetHeight;
+						}else{
+							this.elementVertical.scrollTop = this.elementVertical.scrollTop - this.elementVertical.clientHeight + rowEl.offsetHeight;
+						}
+
+						break;
+
+					case "top":
+						this.elementVertical.scrollTop = rowEl.offsetTop;					
+						break;
+				}
+
+				resolve();
+
+			}else{
+				console.warn("Scroll Error - Row not visible");
+				reject("Scroll Error - Row not visible");
+			}
+		});
+	}
+}

package/src/js/core/rendering/renderers/BasicHorizontal.js

@@ -0,0 +1,27 @@
+import Renderer from '../Renderer.js';
+
+export default class BasicHorizontal extends Renderer{
+	constructor(table){
+		super(table);
+	}
+	
+	renderRowCells(row, inFragment) {
+		const rowFrag = document.createDocumentFragment();
+		row.cells.forEach((cell) => {
+			rowFrag.appendChild(cell.getElement());
+		});
+		row.element.appendChild(rowFrag);
+		
+		if(!inFragment){
+			row.cells.forEach((cell) => {
+				cell.cellRendered();
+			});
+		}
+	}
+	
+	reinitializeColumnWidths(columns){
+		columns.forEach(function(column){
+			column.reinitializeWidth();
+		});
+	}
+}

package/src/js/core/rendering/renderers/BasicVertical.js

@@ -0,0 +1,103 @@
+import Renderer from '../Renderer.js';
+import Helpers from '../../tools/Helpers.js';
+
+export default class BasicVertical extends Renderer{
+	constructor(table){
+		super(table);
+		
+		this.verticalFillMode = "fill";
+		
+		this.scrollTop = 0;
+		this.scrollLeft = 0;
+		
+		this.scrollTop = 0;
+		this.scrollLeft = 0;
+	}
+	
+	clearRows(){
+		var element = this.tableElement;
+		
+		// element.children.detach();
+		while(element.firstChild) element.removeChild(element.firstChild);
+		
+		element.scrollTop = 0;
+		element.scrollLeft = 0;
+		
+		element.style.minWidth = "";
+		element.style.minHeight = "";
+		element.style.display = "";
+		element.style.visibility = "";
+	}
+	
+	renderRows() {
+		var element = this.tableElement,
+		onlyGroupHeaders = true,
+		tableFrag = document.createDocumentFragment(),
+		rows = this.rows();
+		
+		rows.forEach((row, index) => {
+			this.styleRow(row, index);
+			row.initialize(false, true);
+			
+			if (row.type !== "group") {
+				onlyGroupHeaders = false;
+			}
+			
+			tableFrag.appendChild(row.getElement());
+		});
+		
+		element.appendChild(tableFrag);
+		
+		rows.forEach((row) => {
+			row.rendered();
+			
+			if(!row.heightInitialized) {
+				row.calcHeight(true);
+			}
+		});
+		
+		rows.forEach((row) => {
+			if(!row.heightInitialized) {
+				row.setCellHeight();
+			}
+		});
+		
+		if(onlyGroupHeaders){
+			element.style.minWidth = this.table.columnManager.getWidth() + "px";
+		}else{
+			element.style.minWidth = "";
+		}
+	}
+	
+	
+	rerenderRows(callback){	
+		this.clearRows();
+		
+		if(callback){
+			callback();
+		}
+		
+		this.renderRows();
+
+		if(!this.rows().length){
+			this.table.rowManager.tableEmpty();
+		}
+	}
+	
+	scrollToRowNearestTop(row){
+		var rowTop = Helpers.elOffset(row.getElement()).top;
+		
+		return !(Math.abs(this.elementVertical.scrollTop - rowTop) > Math.abs(this.elementVertical.scrollTop + this.elementVertical.clientHeight - rowTop));
+	}
+	
+	scrollToRow(row){
+		var rowEl = row.getElement();
+		
+		this.elementVertical.scrollTop = Helpers.elOffset(rowEl).top - Helpers.elOffset(this.elementVertical).top + this.elementVertical.scrollTop;
+	}
+	
+	visibleRows(includingBuffer){
+		return this.rows();
+	}
+	
+}