tabulator-tables 6.5.0 → 6.5.1

package/src/js/core/tools/DataLoader.js

@@ -0,0 +1,128 @@
+import CoreFeature from '../CoreFeature.js';
+
+export default class DataLoader extends CoreFeature{
+	constructor(table){
+		super(table);
+		
+		this.requestOrder = 0; //prevent requests coming out of sequence if overridden by another load request
+		this.loading = false;
+	}
+	
+	initialize(){}
+	
+	load(data, params, config, replace, silent, columnsChanged){
+		var requestNo = ++this.requestOrder;
+
+		if(this.table.destroyed){
+			return Promise.resolve();
+		}
+		
+		this.dispatchExternal("dataLoading", data);
+		
+		//parse json data to array
+		if (data && (data.indexOf("{") == 0 || data.indexOf("[") == 0)){
+			data = JSON.parse(data);
+		}
+		
+		if(this.confirm("data-loading", [data, params, config, silent])){
+			this.loading = true;
+			
+			if(!silent){
+				this.alertLoader();
+			}
+			
+			//get params for request
+			params = this.chain("data-params", [data, config, silent], params || {}, params || {});
+			
+			params = this.mapParams(params, this.table.options.dataSendParams);
+			
+			var result = this.chain("data-load", [data, params, config, silent], false, Promise.resolve([]));
+			
+			return result.then((response) => {
+				if(!this.table.destroyed){
+					if(!Array.isArray(response) && typeof response == "object"){
+						response = this.mapParams(response, this.objectInvert(this.table.options.dataReceiveParams));
+					}
+					
+					var rowData = this.chain("data-loaded", [response], null, response);
+					
+					if(requestNo == this.requestOrder){
+						this.clearAlert();
+						
+						if(rowData !== false){
+							this.dispatchExternal("dataLoaded", rowData);
+							this.table.rowManager.setData(rowData,  replace, typeof columnsChanged === "undefined" ? !replace : columnsChanged);
+						}
+					}else{
+						console.warn("Data Load Response Blocked - An active data load request was blocked by an attempt to change table data while the request was being made");
+					}
+				}else{
+					console.warn("Data Load Response Blocked - Table has been destroyed");
+				}
+			}).catch((error) => {
+				console.error("Data Load Error: ", error);
+				this.dispatchExternal("dataLoadError", error);
+				
+				if(!silent){
+					this.alertError();
+				}
+				
+				setTimeout(() => {
+					this.clearAlert();
+				}, this.table.options.dataLoaderErrorTimeout);
+			})
+				.finally(() => {
+					this.loading = false;
+				});
+		}else{
+			this.dispatchExternal("dataLoaded", data);
+			
+			if(!data){
+				data = [];
+			}
+			
+			this.table.rowManager.setData(data, replace, typeof columnsChanged === "undefined" ? !replace : columnsChanged);
+			return Promise.resolve();
+		}
+	}
+	
+	mapParams(params, map){
+		var output = {};
+		
+		for(let key in params){
+			output[map.hasOwnProperty(key) ? map[key] : key] = params[key];
+		}
+		
+		return output;
+	}
+	
+	objectInvert(obj){
+		var output = {};
+		
+		for(let key in obj){
+			output[obj[key]] = key;
+		}
+		
+		return output;
+	}
+	
+	blockActiveLoad(){
+		this.requestOrder++;
+	}
+	
+	alertLoader(){
+		var shouldLoad = typeof this.table.options.dataLoader === "function" ? this.table.options.dataLoader() : this.table.options.dataLoader;
+		
+		if(shouldLoad){
+			this.table.alertManager.alert(this.table.options.dataLoaderLoading || this.langText("data|loading"));
+		}
+	}
+	
+	alertError(){
+		this.table.alertManager.alert(this.table.options.dataLoaderError || this.langText("data|error"), "error");
+	}
+	
+	clearAlert(){
+		this.table.alertManager.clear();
+	}
+}

package/src/js/core/tools/DependencyRegistry.js

@@ -0,0 +1,82 @@
+import CoreFeature from '../CoreFeature.js';
+
+export default class DependencyRegistry extends CoreFeature{
+	
+	constructor(table){
+		super(table);
+		
+		this.deps = {};
+		
+		this.props = {
+			
+		};
+	}
+	
+	initialize(){
+		this.deps = Object.assign({}, this.options("dependencies"));
+	}
+	
+	lookup(key, prop, silent){
+		if(Array.isArray(key)){
+			for (const item of key) {
+				var match = this.lookup(item, prop, true);
+
+				if(match){
+					break;
+				}
+			}
+
+			if(match){
+				return match;
+			}else{
+				this.error(key);
+			}
+		}else{
+			if(prop){
+				return this.lookupProp(key, prop, silent);
+			}else{
+				return this.lookupKey(key, silent);
+			}
+		}
+	}
+	
+	lookupProp(key, prop, silent){
+		var dependency;
+		
+		if(this.props[key] && this.props[key][prop]){
+			return this.props[key][prop];
+		}else{
+			dependency = this.lookupKey(key, silent);
+			
+			if(dependency){
+				if(!this.props[key]){
+					this.props[key] = {};
+				}
+				
+				this.props[key][prop] = dependency[prop] || dependency;
+				return this.props[key][prop];
+			}
+		}
+	}
+	
+	lookupKey(key, silent){
+		var dependency;
+		
+		if(this.deps[key]){
+			dependency = this.deps[key];
+		}else if(window[key]){
+			this.deps[key] = window[key];
+			dependency = this.deps[key];
+		}else{
+			if(!silent){
+				this.error(key);
+			}
+		}
+		
+		return dependency;
+	}
+
+	error(key){
+		console.error("Unable to find dependency", key, "Please check documentation and ensure you have imported the required library into your project");
+	}
+}

package/src/js/core/tools/DeprecationAdvisor.js

@@ -0,0 +1,51 @@
+import CoreFeature from '../CoreFeature.js';
+
+export default class DeprecationAdvisor extends CoreFeature{
+	
+	constructor(table){
+		super(table);
+	}
+	
+	_warnUser(){
+		if(this.options("debugDeprecation")){
+			console.warn(...arguments);
+		}
+	}
+	
+	check(oldOption, newOption, convert){
+		var msg = "";
+		
+		if(typeof this.options(oldOption) !== "undefined"){
+			msg = "Deprecated Setup Option - Use of the %c" + oldOption + "%c option is now deprecated";
+			
+			if(newOption){
+				msg = msg + ", Please use the %c" + newOption + "%c option instead";
+				this._warnUser(msg, 'font-weight: bold;', 'font-weight: normal;', 'font-weight: bold;', 'font-weight: normal;');
+
+				if(convert){
+					this.table.options[newOption] = this.table.options[oldOption];
+				}
+			}else{
+				this._warnUser(msg, 'font-weight: bold;', 'font-weight: normal;');
+			}
+			
+			return false;
+		}else{
+			return true;
+		}
+	}
+	
+	checkMsg(oldOption, msg){
+		if(typeof this.options(oldOption) !== "undefined"){
+			this._warnUser("%cDeprecated Setup Option - Use of the %c" + oldOption + " %c option is now deprecated, " + msg, 'font-weight: normal;', 'font-weight: bold;', 'font-weight: normal;');
+			
+			return false;
+		}else{
+			return true;
+		}
+	}
+	
+	msg(msg){
+		this._warnUser(msg);
+	}
+}

package/src/js/core/tools/ExternalEventBus.js

@@ -0,0 +1,105 @@
+export default class ExternalEventBus {
+
+	constructor(table, optionsList, debug){
+		this.table = table;
+		this.events = {};
+		this.optionsList = optionsList || {};
+		this.subscriptionNotifiers = {};
+
+		this.dispatch = debug ? this._debugDispatch.bind(this) : this._dispatch.bind(this);
+		this.debug = debug;
+	}
+
+	subscriptionChange(key, callback){
+		if(!this.subscriptionNotifiers[key]){
+			this.subscriptionNotifiers[key] = [];
+		}
+
+		this.subscriptionNotifiers[key].push(callback);
+
+		if(this.subscribed(key)){
+			this._notifySubscriptionChange(key, true);
+		}
+	}
+
+	subscribe(key, callback){
+		if(!this.events[key]){
+			this.events[key] = [];
+		}
+
+		this.events[key].push(callback);
+
+		this._notifySubscriptionChange(key, true);
+	}
+
+	unsubscribe(key, callback){
+		var index;
+
+		if(this.events[key]){
+			if(callback){
+				index = this.events[key].findIndex((item) => {
+					return item === callback;
+				});
+
+				if(index > -1){
+					this.events[key].splice(index, 1);
+				}else{
+					console.warn("Cannot remove event, no matching event found:", key, callback);
+					return;
+				}
+			}else{
+				delete this.events[key];
+			}
+		}else{
+			console.warn("Cannot remove event, no events set on:", key);
+			return;
+		}
+
+		this._notifySubscriptionChange(key, false);
+	}
+
+	subscribed(key){
+		return this.events[key] && this.events[key].length;
+	}
+
+	_notifySubscriptionChange(key, subscribed){
+		var notifiers = this.subscriptionNotifiers[key];
+
+		if(notifiers){
+			notifiers.forEach((callback)=>{
+				callback(subscribed);
+			});
+		}
+	}
+
+	_dispatch(){
+		var args = Array.from(arguments),
+		key = args.shift(),
+		result;
+
+		if(this.events[key]){
+			this.events[key].forEach((callback, i) => {
+				let callResult = callback.apply(this.table, args);
+
+				if(!i){
+					result = callResult;
+				}
+			});
+		}
+
+		return result;
+	}
+
+	_debugDispatch(){
+		var args = Array.from(arguments),
+		key = args[0];
+
+		args[0] = "ExternalEvent:" + args[0];
+
+		if(this.debug === true || this.debug.includes(key)){
+			console.log(...args);
+		}
+
+		return this._dispatch(...arguments);
+	}
+}

package/src/js/core/tools/Helpers.js

@@ -0,0 +1,66 @@
+export default class Helpers{
+
+	static elVisible(el){
+		return !(el.offsetWidth <= 0 && el.offsetHeight <= 0);
+	}
+
+	static elOffset(el){
+		var box = el.getBoundingClientRect();
+
+		return {
+			top: box.top + window.pageYOffset - document.documentElement.clientTop,
+			left: box.left + window.pageXOffset - document.documentElement.clientLeft
+		};
+	}
+
+	static retrieveNestedData(separator, field, data){
+		var structure = separator ? field.split(separator) : [field],
+		length = structure.length,
+		output;
+
+		for(let i = 0; i < length; i++){
+
+			data = data[structure[i]];
+
+			output = data;
+
+			if(!data){
+				break;
+			}
+		}
+
+		return output;
+	}
+
+	static deepClone(obj, clone, list = []){
+		var objectProto = {}.__proto__,
+		arrayProto = [].__proto__;
+
+		if (!clone){
+			clone = Object.assign(Array.isArray(obj) ? [] : {}, obj);
+		}
+
+		for(var i in obj) {
+			let subject = obj[i],
+			match, copy;
+
+			if(subject != null && typeof subject === "object" && (subject.__proto__ === objectProto || subject.__proto__ === arrayProto)){
+				match = list.findIndex((item) => {
+					return item.subject === subject;
+				});
+
+				if(match > -1){
+					clone[i] = list[match].copy;
+				}else{
+					copy = Object.assign(Array.isArray(subject) ? [] : {}, subject);
+
+					list.unshift({subject, copy});
+
+					clone[i] = this.deepClone(subject, copy, list);
+				}
+			}
+		}
+
+		return clone;
+	}
+}