tabulator-tables 6.5.0 → 6.5.1

package/src/js/core/tools/InteractionMonitor.js

@@ -0,0 +1,329 @@
+import CoreFeature from '../CoreFeature.js';
+import Row from '../row/Row.js';
+
+export default class InteractionManager extends CoreFeature {
+	
+	constructor (table){
+		super(table);
+		
+		this.el = null;
+		
+		this.abortClasses = ["tabulator-headers", "tabulator-table"];
+		
+		this.previousTargets = {};
+		
+		this.listeners = [
+			"click",
+			"dblclick",
+			"contextmenu",
+			"mouseenter",
+			"mouseleave",
+			"mouseover",
+			"mouseout",
+			"mousemove",
+			"mouseup",
+			"mousedown",
+			"touchstart",
+			"touchend",
+		];
+		
+		this.componentMap = {
+			"tabulator-cell":"cell",
+			"tabulator-row":"row",
+			"tabulator-group":"group",
+			"tabulator-col":"column",
+		};
+		
+		this.pseudoTrackers = {
+			"row":{
+				subscriber:null,
+				target:null,
+			},
+			"cell":{
+				subscriber:null,
+				target:null,
+			},
+			"group":{
+				subscriber:null,
+				target:null,
+			},
+			"column":{
+				subscriber:null,
+				target:null,
+			},
+		};
+		
+		this.pseudoTracking = false;
+	}
+	
+	initialize(){
+		this.el = this.table.element;
+		
+		this.buildListenerMap();
+		this.bindSubscriptionWatchers();
+	}
+	
+	buildListenerMap(){
+		var listenerMap = {};
+		
+		this.listeners.forEach((listener) => {
+			listenerMap[listener] = {
+				handler:null,
+				components:[],
+			};
+		});
+		
+		this.listeners = listenerMap;
+	}
+	
+	bindPseudoEvents(){
+		Object.keys(this.pseudoTrackers).forEach((key) => {
+			this.pseudoTrackers[key].subscriber = this.pseudoMouseEnter.bind(this, key);
+			this.subscribe(key + "-mouseover", this.pseudoTrackers[key].subscriber);
+		});
+		
+		this.pseudoTracking = true;
+	}
+	
+	pseudoMouseEnter(key, e, target){
+		if(this.pseudoTrackers[key].target !== target){
+			
+			if(this.pseudoTrackers[key].target){
+				this.dispatch(key + "-mouseleave", e, this.pseudoTrackers[key].target);
+			}
+			
+			this.pseudoMouseLeave(key, e);
+			
+			this.pseudoTrackers[key].target = target;
+			
+			this.dispatch(key + "-mouseenter", e, target);
+		}
+	}
+	
+	pseudoMouseLeave(key, e){
+		var leaveList = Object.keys(this.pseudoTrackers),
+		linkedKeys = {
+			"row":["cell"],
+			"cell":["row"],
+		};
+		
+		leaveList = leaveList.filter((item) => {
+			var links = linkedKeys[key];
+			return item !== key && (!links || (links && !links.includes(item)));
+		});
+		
+		
+		leaveList.forEach((key) => {
+			var target = this.pseudoTrackers[key].target;
+			
+			if(this.pseudoTrackers[key].target){
+				this.dispatch(key + "-mouseleave", e, target);
+				
+				this.pseudoTrackers[key].target = null;
+			}
+		});
+	}
+	
+	
+	bindSubscriptionWatchers(){
+		var listeners = Object.keys(this.listeners),
+		components = Object.values(this.componentMap);
+		
+		for(let comp of components){
+			for(let listener of listeners){
+				let key = comp + "-" + listener;
+				
+				this.subscriptionChange(key, this.subscriptionChanged.bind(this, comp, listener));
+			}
+		}
+		
+		this.subscribe("table-destroy", this.clearWatchers.bind(this));
+	}
+	
+	subscriptionChanged(component, key, added){
+		var listener = this.listeners[key].components,
+		index = listener.indexOf(component),
+		changed = false;
+		
+		if(added){
+			if(index === -1){
+				listener.push(component);
+				changed = true;
+			}
+		}else{
+			if(!this.subscribed(component + "-" + key)){
+				if(index > -1){
+					listener.splice(index, 1);
+					changed = true;
+				}
+			}
+		}
+		
+		if((key === "mouseenter" || key === "mouseleave") && !this.pseudoTracking){
+			this.bindPseudoEvents();
+		}
+		
+		if(changed){
+			this.updateEventListeners();
+		}
+	}
+	
+	updateEventListeners(){
+		for(let key in this.listeners){
+			let listener = this.listeners[key];
+			
+			if(listener.components.length){
+				if(!listener.handler){
+					listener.handler = this.track.bind(this, key);
+					this.el.addEventListener(key, listener.handler);
+					// this.el.addEventListener(key, listener.handler, {passive: true})
+				}
+			}else{
+				if(listener.handler){
+					this.el.removeEventListener(key, listener.handler);
+					listener.handler = null;
+				}
+			}
+		}
+	}
+	
+	track(type, e){
+		var path = (e.composedPath && e.composedPath()) || e.path;
+		
+		var targets = this.findTargets(path);
+		targets = this.bindComponents(type, targets);
+		
+		this.triggerEvents(type, e, targets);
+		
+		if(this.pseudoTracking && (type == "mouseover" || type == "mouseleave") && !Object.keys(targets).length){
+			this.pseudoMouseLeave("none", e);
+		}
+	}
+	
+	findTargets(path){
+		var targets = {};
+		
+		let componentMap = Object.keys(this.componentMap);
+		
+		for (let el of path) {
+			let classList = el.classList ? [...el.classList] : [];
+			
+			let abort = classList.filter((item) => {
+				return this.abortClasses.includes(item);
+			});
+			
+			if(abort.length){
+				break;
+			}
+			
+			let elTargets = classList.filter((item) => {
+				return componentMap.includes(item);
+			});
+			
+			for (let target of elTargets) {
+				if(!targets[this.componentMap[target]]){
+					targets[this.componentMap[target]] = el;
+				}
+			}
+		}
+
+		if(targets.group && targets.group === targets.row){
+			delete targets.row;
+		}
+
+		return targets;
+	}
+	
+	bindComponents(type, targets){
+		//ensure row component is looked up before cell
+		var keys = Object.keys(targets).reverse(),
+		listener = this.listeners[type],
+		matches = {},
+		output = {},
+		targetMatches = {};
+	
+		for(let key of keys){
+			let component,
+			target = targets[key],
+			previousTarget = this.previousTargets[key];
+			
+			if(previousTarget && previousTarget.target === target){
+				component = previousTarget.component;
+			}else{
+				switch(key){
+					case "row":
+					case "group":
+						if(listener.components.includes("row") || listener.components.includes("cell") || listener.components.includes("group")){
+							let rows = this.table.rowManager.getVisibleRows(true);
+						
+							component = rows.find((row) => {
+								return row.getElement() === target;
+							});
+						
+							if(targets["row"] && targets["row"].parentNode && targets["row"].parentNode.closest(".tabulator-row")){
+								targets[key] = false;
+							}
+						}
+						break;
+					
+					case "column":
+						if(listener.components.includes("column")){
+							component = this.table.columnManager.findColumn(target);
+						}
+						break;
+					
+					case "cell":
+						if(listener.components.includes("cell")){
+							if(matches["row"] instanceof Row){
+								component = matches["row"].findCell(target);
+							}else{	
+								if(targets["row"]){
+									console.warn("Event Target Lookup Error - The row this cell is attached to cannot be found, has the table been reinitialized without being destroyed first?");
+								}
+							}
+						}
+						break;
+				}
+			}
+			
+			if(component){
+				matches[key] = component;
+				targetMatches[key] = {
+					target:target,
+					component:component,
+				};
+			}
+		}
+		
+		this.previousTargets = targetMatches;
+
+		//reverse order keys are set in so events trigger in correct sequence
+		Object.keys(targets).forEach((key) => {
+			let value = matches[key];
+			output[key] = value;
+		});
+		
+		return output;
+	}
+	
+	triggerEvents(type, e, targets){
+		var listener = this.listeners[type];
+
+		for(let key in targets){
+			if(targets[key] && listener.components.includes(key)){
+				this.dispatch(key + "-" + type, e, targets[key]);
+			}
+		}
+	}
+	
+	clearWatchers(){
+		for(let key in this.listeners){
+			let listener = this.listeners[key];
+			
+			if(listener.handler){
+				this.el.removeEventListener(key, listener.handler);
+				listener.handler = null;
+			}
+		}
+	}
+}

package/src/js/core/tools/InternalEventBus.js

@@ -0,0 +1,162 @@
+export default class InternalEventBus {
+
+	constructor(debug){
+		this.events = {};
+		this.subscriptionNotifiers = {};
+
+		this.dispatch = debug ? this._debugDispatch.bind(this) : this._dispatch.bind(this);
+		this.chain = debug ? this._debugChain.bind(this) : this._chain.bind(this);
+		this.confirm = debug ? this._debugConfirm.bind(this) : this._confirm.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, priority = 10000){
+		if(!this.events[key]){
+			this.events[key] = [];
+		}
+
+		this.events[key].push({callback, priority});
+
+		this.events[key].sort((a, b) => {
+			return a.priority - b.priority;
+		});
+
+		this._notifySubscriptionChange(key, true);
+	}
+
+	unsubscribe(key, callback){
+		var index;
+
+		if(this.events[key]){
+			if(callback){
+				index = this.events[key].findIndex((item) => {
+					return item.callback === callback;
+				});
+
+				if(index > -1){
+					this.events[key].splice(index, 1);
+				}else{
+					console.warn("Cannot remove event, no matching event found:", key, callback);
+					return;
+				}
+			}
+		}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;
+	}
+
+	_chain(key, args, initialValue, fallback){
+		var value = initialValue;
+
+		if(!Array.isArray(args)){
+			args = [args];
+		}
+
+		if(this.subscribed(key)){
+			this.events[key].forEach((subscriber, i) => {
+				value = subscriber.callback.apply(this, args.concat([value]));
+			});
+
+			return value;
+		}else{
+			return typeof fallback === "function" ? fallback() : fallback;
+		}
+	}
+
+	_confirm(key, args){
+		var confirmed = false;
+
+		if(!Array.isArray(args)){
+			args = [args];
+		}
+
+		if(this.subscribed(key)){
+			this.events[key].forEach((subscriber, i) => {
+				if(subscriber.callback.apply(this, args)){
+					confirmed = true;
+				}
+			});
+		}
+
+		return confirmed;
+	}
+
+	_notifySubscriptionChange(key, subscribed){
+		var notifiers = this.subscriptionNotifiers[key];
+
+		if(notifiers){
+			notifiers.forEach((callback)=>{
+				callback(subscribed);
+			});
+		}
+	}
+
+	_dispatch(){
+		var args = Array.from(arguments),
+		key = args.shift();
+
+		if(this.events[key]){
+			this.events[key].forEach((subscriber) => {
+				subscriber.callback.apply(this, args);
+			});
+		}
+	}
+
+	_debugDispatch(){
+		var args = Array.from(arguments),
+		key = args[0];
+
+		args[0] = "InternalEvent:" + key;
+
+		if(this.debug === true || this.debug.includes(key)){
+			console.log(...args);
+		}
+
+		return this._dispatch(...arguments);
+	}
+
+	_debugChain(){
+		var args = Array.from(arguments),
+		key = args[0];
+
+		args[0] = "InternalEvent:" + key;
+
+		if(this.debug === true || this.debug.includes(key)){
+			console.log(...args);
+		}
+
+		return this._chain(...arguments);
+	}
+
+	_debugConfirm(){
+		var args = Array.from(arguments),
+		key = args[0];
+
+		args[0] = "InternalEvent:" + key;
+
+		if(this.debug === true || this.debug.includes(key)){
+			console.log(...args);
+		}
+
+		return this._confirm(...arguments);
+	}
+}

package/src/js/core/tools/ModuleBinder.js

@@ -0,0 +1,153 @@
+import * as coreModules from '../modules/core.js';
+import TableRegistry from './TableRegistry.js';
+
+export default class ModuleBinder extends TableRegistry {
+	
+	static moduleBindings = {};
+	static moduleExtensions = {};
+	static modulesRegistered = false;
+	
+	static defaultModules = false;
+	
+	constructor(){
+		super();
+	}
+	
+	static initializeModuleBinder(defaultModules){
+		if(!ModuleBinder.modulesRegistered){
+			ModuleBinder.modulesRegistered = true;
+			ModuleBinder._registerModules(coreModules, true);
+			
+			if(defaultModules){
+				ModuleBinder._registerModules(defaultModules);
+			}
+		}
+	}
+	
+	static _extendModule(name, property, values){
+		if(ModuleBinder.moduleBindings[name]){
+			var source = ModuleBinder.moduleBindings[name][property];
+			
+			if(source){
+				if(typeof values == "object"){
+					for(let key in values){
+						source[key] = values[key];
+					}
+				}else{
+					console.warn("Module Error - Invalid value type, it must be an object");
+				}
+			}else{
+				console.warn("Module Error - property does not exist:", property);
+			}
+		}else{
+			console.warn("Module Error - module does not exist:", name);
+		}
+	}
+	
+	static _registerModules(modules, core){
+		var mods = Object.values(modules);
+		
+		if(core){
+			mods.forEach((mod) => {
+				mod.prototype.moduleCore = true;
+			});
+		}
+		
+		ModuleBinder._registerModule(mods);
+	}
+	
+	static _registerModule(modules){
+		if(!Array.isArray(modules)){
+			modules = [modules];
+		}
+		
+		modules.forEach((mod) => {
+			ModuleBinder._registerModuleBinding(mod);
+			ModuleBinder._registerModuleExtensions(mod);
+		});
+	}
+	
+	static _registerModuleBinding(mod){
+		if(mod.moduleName){
+			ModuleBinder.moduleBindings[mod.moduleName] = mod;
+		}else{
+			console.error("Unable to bind module, no moduleName defined", mod.moduleName);
+		}
+	}
+	
+	static _registerModuleExtensions(mod){
+		var extensions = mod.moduleExtensions;
+		
+		if(mod.moduleExtensions){
+			for (let modKey in extensions) {
+				let ext = extensions[modKey];
+				
+				if(ModuleBinder.moduleBindings[modKey]){
+					for (let propKey in ext) {
+						ModuleBinder._extendModule(modKey, propKey, ext[propKey]);
+					}
+				}else{
+					if(!ModuleBinder.moduleExtensions[modKey]){
+						ModuleBinder.moduleExtensions[modKey] = {};
+					}
+					
+					for (let propKey in ext) {
+						if(!ModuleBinder.moduleExtensions[modKey][propKey]){
+							ModuleBinder.moduleExtensions[modKey][propKey] = {};
+						}
+
+						Object.assign(ModuleBinder.moduleExtensions[modKey][propKey], ext[propKey]);
+					}
+				}
+			}
+		}
+
+		ModuleBinder._extendModuleFromQueue(mod);
+	}
+	
+	static _extendModuleFromQueue(mod){
+		var extensions = ModuleBinder.moduleExtensions[mod.moduleName];
+		
+		if(extensions){
+			for (let propKey in extensions) {
+				ModuleBinder._extendModule(mod.moduleName, propKey, extensions[propKey]);
+			}
+		}
+	}
+	
+	//ensure that module are bound to instantiated function
+	_bindModules(){
+		var orderedStartMods = [],
+		orderedEndMods = [],
+		unOrderedMods = [];
+		
+		this.modules = {};
+		
+		for(var name in ModuleBinder.moduleBindings){
+			let mod = ModuleBinder.moduleBindings[name];
+			let module = new mod(this);
+			
+			this.modules[name] = module;
+			
+			if(mod.prototype.moduleCore){
+				this.modulesCore.push(module);
+			}else{
+				if(mod.moduleInitOrder){
+					if(mod.moduleInitOrder < 0){
+						orderedStartMods.push(module);
+					}else{
+						orderedEndMods.push(module);
+					}
+					
+				}else{
+					unOrderedMods.push(module);
+				}
+			}
+		}
+		
+		orderedStartMods.sort((a, b) => a.moduleInitOrder > b.moduleInitOrder ? 1 : -1);
+		orderedEndMods.sort((a, b) => a.moduleInitOrder > b.moduleInitOrder ? 1 : -1);
+		
+		this.modulesRegular = orderedStartMods.concat(unOrderedMods.concat(orderedEndMods));
+	}
+}

package/src/js/core/tools/OptionsList.js

@@ -0,0 +1,45 @@
+export default class OptionsList {
+	constructor(table, msgType, defaults = {}){
+		this.table = table;
+		this.msgType = msgType;
+		this.registeredDefaults = Object.assign({}, defaults);
+	}
+	
+	register(option, value){
+		this.registeredDefaults[option] = value;
+	}
+	
+	generate(defaultOptions, userOptions = {}){
+		var output = Object.assign({}, this.registeredDefaults),
+		warn = this.table.options.debugInvalidOptions || userOptions.debugInvalidOptions === true;
+		
+		Object.assign(output, defaultOptions);
+		
+		for (let key in userOptions){
+			if(!output.hasOwnProperty(key)){
+				if(warn){
+					console.warn("Invalid " + this.msgType + " option:", key);
+				}
+
+				output[key] = userOptions.key;
+			}
+		}
+	
+		
+		for (let key in output){
+			if(key in userOptions){
+				output[key] = userOptions[key];
+			}else{
+				if(Array.isArray(output[key])){
+					output[key] = Object.assign([], output[key]);
+				}else if(typeof output[key] === "object" && output[key] !== null){
+					output[key] = Object.assign({}, output[key]);
+				}else if (typeof output[key] === "undefined"){
+					delete output[key];
+				}
+			}
+		}
+		
+		return output;
+	}
+}