tabulator-tables 5.2.7 → 5.3.2

package/src/js/core/CoreFeature.js

@@ -49,8 +49,8 @@ export default class CoreFeature{
 		return this.table.modules.layout.getMode();
 	}
 
-	layoutRefresh(){
-		return this.table.modules.layout.layout();
+	layoutRefresh(force){
+		return this.table.modules.layout.layout(force);
 	}
 
 
@@ -114,7 +114,21 @@ export default class CoreFeature{
 		return this.table.options[key];
 	}
 
+	//////////////////////////////////////////
+	/////////// Deprecation Checks ///////////
+	//////////////////////////////////////////
+
+	deprecationCheck(oldOption, newOption){
+		return this.table.deprecationAdvisor.check(oldOption, newOption);
+	}
 
+	deprecationCheckMsg(oldOption, msg){
+		return this.table.deprecationAdvisor.checkMsg(oldOption, msg);
+	}
+
+	deprecationMsg(msg){
+		return this.table.deprecationAdvisor.msg(msg);
+	}
 	//////////////////////////////////////////
 	//////////////// Modules /////////////////
 	//////////////////////////////////////////

package/src/js/core/FooterManager.js

@@ -39,17 +39,17 @@ export default class FooterManager extends CoreFeature{
 
 			switch(typeof this.table.options.footerElement){
 				case "string":
-				if(this.table.options.footerElement[0] === "<"){
-					this.containerElement.innerHTML = this.table.options.footerElement;
-				}else{
-					this.external = true;
-					this.containerElement = document.querySelector(this.table.options.footerElement);
-				}
-				break;
+					if(this.table.options.footerElement[0] === "<"){
+						this.containerElement.innerHTML = this.table.options.footerElement;
+					}else{
+						this.external = true;
+						this.containerElement = document.querySelector(this.table.options.footerElement);
+					}
+					break;
 
 				default:
-				this.element = this.table.options.footerElement;
-				break;
+					this.element = this.table.options.footerElement;
+					break;
 			}
 		}
 	}
@@ -97,6 +97,6 @@ export default class FooterManager extends CoreFeature{
 	}
 
 	redraw(){
-		this.dispatch("footer-redraw")
+		this.dispatch("footer-redraw");
 	}
 }

package/src/js/core/Module.js

@@ -10,7 +10,7 @@ class Module extends CoreFeature{
 	}
 
 	initialize(){
-		// setup module when table is initialized, to be overriden in module
+		// setup module when table is initialized, to be overridden in module
 	}
 
 
@@ -36,9 +36,9 @@ class Module extends CoreFeature{
 				this.table.initGuard(name);
 
 				return func(...args);
-			}
+			};
 		}else{
-			console.warn("Unable to bind table function, name already in use", name)
+			console.warn("Unable to bind table function, name already in use", name);
 		}
 	}
 
@@ -51,12 +51,12 @@ class Module extends CoreFeature{
 	///////////////////////////////////
 
 	registerDataHandler(handler, priority){
-		this.table.rowManager.registerDataPipelineHandler(handler, priority)
+		this.table.rowManager.registerDataPipelineHandler(handler, priority);
 		this._handler = handler;
 	}
 
 	registerDisplayHandler(handler, priority){
-		this.table.rowManager.registerDisplayPipelineHandler(handler, priority)
+		this.table.rowManager.registerDisplayPipelineHandler(handler, priority);
 		this._handler = handler;
 	}
 
@@ -75,15 +75,15 @@ class Module extends CoreFeature{
 	///////////////////////////////////
 
 	footerAppend(element){
-		return this.table.footerManager.append(element)
+		return this.table.footerManager.append(element);
 	}
 
 	footerPrepend(element){
-		return this.table.footerManager.prepend(element)
+		return this.table.footerManager.prepend(element);
 	}
 
 	footerRemove(element){
-		return this.table.footerManager.remove(element)
+		return this.table.footerManager.remove(element);
 	} 
 
 	///////////////////////////////////

package/src/js/core/RowManager.js

@@ -32,8 +32,6 @@ export default class RowManager extends CoreFeature{
 		this.scrollTop = 0;
 		this.scrollLeft = 0;
 		
-		this.rowNumColumn = false; //hold column component for row number column
-		
 		this.redrawBlock = false; //prevent redraws to allow multiple data manipulations before continuing
 		this.redrawBlockRestoreConfig = false; //store latest redraw function calls for when redraw is needed
 		this.redrawBlockRenderInPosition = false; //store latest redraw function calls for when redraw is needed
@@ -92,17 +90,8 @@ export default class RowManager extends CoreFeature{
 		return this.tableElement;
 	}
 	
-	//return position of row in table
-	getRowPosition(row, active){
-		if(active){
-			return this.activeRows.indexOf(row);
-		}else{
-			return this.rows.indexOf(row);
-		}
-	}
-	
 	initialize(){
-		this.initializePlaceholder()
+		this.initializePlaceholder();
 		this.initializeRenderer();
 		
 		//initialize manager
@@ -123,7 +112,7 @@ export default class RowManager extends CoreFeature{
 				
 				this.dispatch("scroll-horizontal", left, leftDir);
 				this.dispatchExternal("scrollHorizontal", left, leftDir);
-
+				
 				this._positionPlaceholder();
 			}
 			
@@ -155,8 +144,10 @@ export default class RowManager extends CoreFeature{
 				});
 				
 				return match || false;
+			}else if(subject === null){
+				return false;
 			}
-		}else if(typeof subject == "undefined" || subject === null){
+		}else if(typeof subject == "undefined"){
 			return false;
 		}else{
 			//subject should be treated as the index of the row
@@ -179,12 +170,10 @@ export default class RowManager extends CoreFeature{
 		return match || false;
 	}
 	
-	getRowFromPosition(position, active){
-		if(active){
-			return this.activeRows[position];
-		}else{
-			return this.rows[position];
-		}
+	getRowFromPosition(position){
+		return this.getDisplayRows().find((row) => {
+			return row.getPosition() === position && row.isDisplayed();
+		});
 	}
 	
 	scrollToRow(row, position, ifVisible){
@@ -284,7 +273,7 @@ export default class RowManager extends CoreFeature{
 			this.reRenderInPosition();
 		}
 		
-		this.regenerateRowNumbers();
+		this.regenerateRowPositions();
 		
 		this.dispatchExternal("rowDeleted", row.getComponent());
 		
@@ -304,8 +293,7 @@ export default class RowManager extends CoreFeature{
 	
 	//add multiple rows
 	addRows(data, pos, index){
-		var length = 0,
-		rows = [];
+		var rows = [];
 		
 		return new Promise((resolve, reject) => {
 			pos = this.findAddRowPos(pos);
@@ -314,8 +302,6 @@ export default class RowManager extends CoreFeature{
 				data = [data];
 			}
 			
-			length = data.length - 1;
-			
 			if((typeof index == "undefined" && pos) || (typeof index !== "undefined" && !pos)){
 				data.reverse();
 			}
@@ -328,7 +314,7 @@ export default class RowManager extends CoreFeature{
 			
 			this.refreshActiveData(false, false, true);
 			
-			this.regenerateRowNumbers();
+			this.regenerateRowPositions();
 			
 			if(rows.length){
 				this._clearPlaceholder();
@@ -434,7 +420,7 @@ export default class RowManager extends CoreFeature{
 		
 		this.moveRowActual(from, to, after);
 		
-		this.regenerateRowNumbers();
+		this.regenerateRowPositions();
 		
 		this.dispatch("row-moved", from, to, after);
 		this.dispatchExternal("rowMoved", from.getComponent());
@@ -591,23 +577,23 @@ export default class RowManager extends CoreFeature{
 	
 	registerDataPipelineHandler(handler, priority){
 		if(typeof priority !== "undefined"){
-			this.dataPipeline.push({handler, priority})
+			this.dataPipeline.push({handler, priority});
 			this.dataPipeline.sort((a, b) => {
 				return a.priority - b.priority;
 			});
 		}else{
-			console.error("Data pipeline handlers must have a priority in order to be registered")
+			console.error("Data pipeline handlers must have a priority in order to be registered");
 		}
 	}
 	
 	registerDisplayPipelineHandler(handler, priority){
 		if(typeof priority !== "undefined"){
-			this.displayPipeline.push({handler, priority})
+			this.displayPipeline.push({handler, priority});
 			this.displayPipeline.sort((a, b) => {
 				return a.priority - b.priority;
 			});
 		}else{
-			console.error("Display pipeline handlers must have a priority in order to be registered")
+			console.error("Display pipeline handlers must have a priority in order to be registered");
 		}
 	}
 	
@@ -616,84 +602,84 @@ export default class RowManager extends CoreFeature{
 		var table = this.table,
 		stage = "",
 		index = 0,
-		cascadeOrder = ["all", "dataPipeline", "display", "displayPipeline", "end"],
-		displayIndex;
+		cascadeOrder = ["all", "dataPipeline", "display", "displayPipeline", "end"];
 		
-		
-		if(typeof handler === "function"){
-			index = this.dataPipeline.findIndex((item) => {
-				return item.handler === handler;
-			});
-			
-			if(index > -1){
-				stage = "dataPipeline";
-				
-				if(skipStage){
-					if(index == this.dataPipeline.length - 1){
-						stage = "display";
-					}else{
-						index++;
-					}
-				}
-			}else{
-				index = this.displayPipeline.findIndex((item) => {
+		if(!this.table.destroyed){
+			if(typeof handler === "function"){
+				index = this.dataPipeline.findIndex((item) => {
 					return item.handler === handler;
 				});
 				
 				if(index > -1){
-					stage = "displayPipeline";
+					stage = "dataPipeline";
 					
 					if(skipStage){
-						if(index == this.displayPipeline.length - 1){
-							stage = "end";
+						if(index == this.dataPipeline.length - 1){
+							stage = "display";
 						}else{
 							index++;
 						}
 					}
 				}else{
-					console.error("Unable to refresh data, invalid handler provided", handler)
-					return;
+					index = this.displayPipeline.findIndex((item) => {
+						return item.handler === handler;
+					});
+					
+					if(index > -1){
+						stage = "displayPipeline";
+						
+						if(skipStage){
+							if(index == this.displayPipeline.length - 1){
+								stage = "end";
+							}else{
+								index++;
+							}
+						}
+					}else{
+						console.error("Unable to refresh data, invalid handler provided", handler);
+						return;
+					}
 				}
-			}
-		}else{
-			stage = handler || "all";
-			index = 0;
-		}
-		
-		if(this.redrawBlock){
-			if(!this.redrawBlockRestoreConfig || (this.redrawBlockRestoreConfig && ((this.redrawBlockRestoreConfig.stage === stage && index < this.redrawBlockRestoreConfig.index) || (cascadeOrder.indexOf(stage) < cascadeOrder.indexOf(this.redrawBlockRestoreConfig.stage))))){
-				this.redrawBlockRestoreConfig = {
-					handler: handler,
-					skipStage: skipStage,
-					renderInPosition: renderInPosition,
-					stage:stage,
-					index:index,
-				};
+			}else{
+				stage = handler || "all";
+				index = 0;
 			}
 			
-			return;
-		}else{
-			if(Helpers.elVisible(this.element)){
-				if(renderInPosition){
-					this.reRenderInPosition(this.refreshPipelines.bind(this, handler, stage, index, renderInPosition));
+			if(this.redrawBlock){
+				if(!this.redrawBlockRestoreConfig || (this.redrawBlockRestoreConfig && ((this.redrawBlockRestoreConfig.stage === stage && index < this.redrawBlockRestoreConfig.index) || (cascadeOrder.indexOf(stage) < cascadeOrder.indexOf(this.redrawBlockRestoreConfig.stage))))){
+					this.redrawBlockRestoreConfig = {
+						handler: handler,
+						skipStage: skipStage,
+						renderInPosition: renderInPosition,
+						stage:stage,
+						index:index,
+					};
+				}
+				
+				return;
+			}else{
+				if(Helpers.elVisible(this.element)){
+					if(renderInPosition){
+						this.reRenderInPosition(this.refreshPipelines.bind(this, handler, stage, index, renderInPosition));
+					}else{
+						this.refreshPipelines(handler, stage, index, renderInPosition);
+						
+						if(!handler){
+							this.table.columnManager.renderer.renderColumns();
+						}
+						
+						this.renderTable();
+						
+						if(table.options.layoutColumnsOnNewData){
+							this.table.columnManager.redraw(true);
+						}
+					}
 				}else{
 					this.refreshPipelines(handler, stage, index, renderInPosition);
-					
-					if(!handler){
-						this.table.columnManager.renderer.renderColumns();
-					}
-					
-					this.renderTable();
-					
-					if(table.options.layoutColumnsOnNewData){
-						this.table.columnManager.redraw(true);
-					}
 				}
-			}else{
-				this.refreshPipelines(handler, stage, index, renderInPosition);
+				
+				this.dispatch("data-refreshed");
 			}
-			
-			this.dispatch("data-refreshed");
 		}
 	}
 	
@@ -707,47 +693,46 @@ export default class RowManager extends CoreFeature{
 		//cascade through data refresh stages
 		switch(stage){
 			case "all":
-			//handle case where alldata needs refreshing
+			//handle case where all data needs refreshing
 			
 			case "dataPipeline":
 			
-			for(let i = index; i < this.dataPipeline.length; i++){
-				let result = this.dataPipeline[i].handler(this.activeRowsPipeline[i].slice(0));
+				for(let i = index; i < this.dataPipeline.length; i++){
+					let result = this.dataPipeline[i].handler(this.activeRowsPipeline[i].slice(0));
+					
+					this.activeRowsPipeline[i + 1] = result || this.activeRowsPipeline[i].slice(0);
+				}
+				
+				this.setActiveRows(this.activeRowsPipeline[this.dataPipeline.length]);
 				
-				this.activeRowsPipeline[i + 1] = result || this.activeRowsPipeline[i].slice(0);
-			}
-			
-			this.setActiveRows(this.activeRowsPipeline[this.dataPipeline.length]);
-			
-			this.regenerateRowNumbers();
-			
 			case "display":
-			index = 0;
-			this.resetDisplayRows();
-			
-			case "displayPipeline":
-			for(let i = index; i < this.displayPipeline.length; i++){
-				let result = this.displayPipeline[i].handler((i ? this.getDisplayRows(i - 1) : this.activeRows).slice(0), renderInPosition);
+				index = 0;
+				this.resetDisplayRows();
 				
-				this.setDisplayRows(result || this.getDisplayRows(i - 1).slice(0), i);
-			}
+			case "displayPipeline":
+				for(let i = index; i < this.displayPipeline.length; i++){
+					let result = this.displayPipeline[i].handler((i ? this.getDisplayRows(i - 1) : this.activeRows).slice(0), renderInPosition);
+
+					this.setDisplayRows(result || this.getDisplayRows(i - 1).slice(0), i);
+				}
 			
 			case "end":
-			//case to handle scenario when trying to skip past end stage
+				//case to handle scenario when trying to skip past end stage
+				this.regenerateRowPositions();
 		}
 	}
 	
-	//regenerate row numbers for row number formatter if in use
-	regenerateRowNumbers(){
-		if(this.rowNumColumn){
-			this.activeRows.forEach((row) => {
-				var cell = row.getCell(this.rowNumColumn);
-				
-				if(cell){
-					cell._generateContents();
-				}
-			});
-		}
+	//regenerate row positions
+	regenerateRowPositions(){
+		var rows = this.getDisplayRows();
+		var index = 1;
+		
+		rows.forEach((row) => {
+			if (row.type === "row"){
+				row.setPosition(index);
+				index++;
+			}
+		});
 	}
 	
 	setActiveRows(activeRows){
@@ -770,22 +755,11 @@ export default class RowManager extends CoreFeature{
 	
 	//set display row pipeline data
 	setDisplayRows(displayRows, index){
-		
-		var output = true;
-		
-		if(index && typeof this.displayRows[index] != "undefined"){
-			this.displayRows[index] = displayRows;
-			output = true;
-		}else{
-			this.displayRows.push(displayRows)
-			output = index = this.displayRows.length -1;
-		}
-		
+		this.displayRows[index] = displayRows;
+
 		if(index == this.displayRows.length -1){
 			this.displayRowsCount = this.displayRows[this.displayRows.length -1].length;
 		}
-		
-		return output;
 	}
 	
 	getDisplayRows(index){
@@ -806,7 +780,7 @@ export default class RowManager extends CoreFeature{
 		return rows;
 	}
 	
-	//repeat action accross display rows
+	//repeat action across display rows
 	displayRowIterator(callback){
 		this.activeRowsPipeline.forEach(callback);
 		this.displayRows.forEach(callback);
@@ -820,19 +794,19 @@ export default class RowManager extends CoreFeature{
 		
 		switch(type){
 			case "active":
-			rows = this.activeRows;
-			break;
+				rows = this.activeRows;
+				break;
 			
 			case "display":
-			rows = this.table.rowManager.getDisplayRows();
-			break;
-			
+				rows = this.table.rowManager.getDisplayRows();
+				break;
+				
 			case "visible":
-			rows = this.getVisibleRows(false, true);
-			break;
-			
+				rows = this.getVisibleRows(false, true);
+				break;
+				
 			default:
-			rows = this.chain("rows-retrieve", type, null, this.rows) || this.rows;
+				rows = this.chain("rows-retrieve", type, null, this.rows) || this.rows;
 		}
 		
 		return rows;
@@ -849,7 +823,13 @@ export default class RowManager extends CoreFeature{
 			}
 		}else{
 			this.dispatchExternal("renderStarted");
+			
 			this.renderer.rerenderRows(callback);
+
+			if(!this.fixedHeight){
+				this.adjustTableSize();
+			}
+			
 			this.dispatchExternal("renderComplete");
 		}
 	}
@@ -869,6 +849,8 @@ export default class RowManager extends CoreFeature{
 		}
 		
 		if(renderClass){
+			this.renderMode = this.table.options.renderVertical;
+			
 			this.renderer = new renderClass(this.table, this.element, this.tableElement);
 			this.renderer.initialize();
 			
@@ -878,7 +860,7 @@ export default class RowManager extends CoreFeature{
 				this.fixedHeight = false;
 			}
 		}else{
-			console.error("Unable to find matching renderer:", table.options.renderVertical);
+			console.error("Unable to find matching renderer:", this.table.options.renderVertical);
 		}
 	}
 	
@@ -898,7 +880,7 @@ export default class RowManager extends CoreFeature{
 			
 			if(this.firstRender){
 				this.firstRender = false;
-				this.layoutRefresh();
+				this.layoutRefresh(true);
 			}
 		}else{
 			this.renderEmptyScroll();
@@ -928,13 +910,14 @@ export default class RowManager extends CoreFeature{
 		}
 	}
 	
-	_clearTable(){
-		var element = this.tableElement;
-		
+	_clearTable(){	
 		this._clearPlaceholder();
 		
 		this.scrollTop = 0;
 		this.scrollLeft = 0;
+
+		// clear empty table placeholder min
+		this.tableElement.style.minWidth = "";
 		
 		this.renderer.clearRows();
 	}
@@ -983,14 +966,15 @@ export default class RowManager extends CoreFeature{
 	
 	//adjust the height of the table holder to fit in the Tabulator element
 	adjustTableSize(){
-		var initialHeight = this.element.clientHeight,
-		modExists;
+		var initialHeight = this.element.clientHeight, minHeight;
 		
 		if(this.renderer.verticalFillMode === "fill"){
 			let otherHeight =  Math.floor(this.table.columnManager.getElement().getBoundingClientRect().height + (this.table.footerManager && this.table.footerManager.active && !this.table.footerManager.external ? this.table.footerManager.getElement().getBoundingClientRect().height : 0));
 			
 			if(this.fixedHeight){
-				this.element.style.minHeight = "calc(100% - " + otherHeight + "px)";
+				minHeight = isNaN(this.table.options.minHeight) ? this.table.options.minHeight : this.table.options.minHeight + "px";
+				
+				this.element.style.minHeight = minHeight || "calc(100% - " + otherHeight + "px)";
 				this.element.style.height = "calc(100% - " + otherHeight + "px)";
 				this.element.style.maxHeight = "calc(100% - " + otherHeight + "px)";
 			}else{
@@ -1010,11 +994,11 @@ export default class RowManager extends CoreFeature{
 				}
 			}
 		}
-
+		
 		this._positionPlaceholder();
 	}
 	
-	//renitialize all rows
+	//reinitialize all rows
 	reinitialize(){
 		this.rows.forEach(function(row){
 			row.reinitialize(true);
@@ -1032,7 +1016,7 @@ export default class RowManager extends CoreFeature{
 		this.redrawBlock = false;
 		
 		if(this.redrawBlockRestoreConfig){
-			this.refreshActiveData(this.redrawBlockRestoreConfig.handler, this.redrawBlockRestoreConfig.skipStage, this.redrawBlockRestoreConfig.renderInPosition)
+			this.refreshActiveData(this.redrawBlockRestoreConfig.handler, this.redrawBlockRestoreConfig.skipStage, this.redrawBlockRestoreConfig.renderInPosition);
 			
 			this.redrawBlockRestoreConfig = false;
 		}else{
@@ -1046,8 +1030,7 @@ export default class RowManager extends CoreFeature{
 	
 	//redraw table
 	redraw (force){
-		var pos = 0,
-		left = this.scrollLeft;
+		var left = this.scrollLeft;
 		
 		this.adjustTableSize();