fragment-tools 0.1.13 → 0.1.15

package/src/client/app/triggers/Keyboard.js

@@ -1,95 +1,104 @@
-import Trigger from "./Trigger";
-import Keyboard from "../inputs/Keyboard";
-import { wildcard, getContext } from "./shared";
-import { addToMapArray, removeFromMapArray } from "../utils";
+import Trigger from './Trigger';
+import Keyboard from '../inputs/Keyboard';
+import { wildcard, getContext } from './shared';
+import { addToMapArray, removeFromMapArray } from '../utils';
 
 const pressedKeys = new Map();
 const upKeys = new Map();
 const downKeys = new Map();
 
 export const removeHotListeners = (context) => {
-    function removeHotFrom(collection) {
-        for (let trigger of collection) {
-            const [key, triggers] = trigger;
-            
-            collection.set(key, triggers.filter((trigger) => trigger.context !== context));
-        }
-    }
-
-    removeHotFrom(pressedKeys);
-    removeHotFrom(upKeys);
-    removeHotFrom(downKeys);
+	function removeHotFrom(collection) {
+		for (let trigger of collection) {
+			const [key, triggers] = trigger;
+
+			collection.set(
+				key,
+				triggers.filter((trigger) => trigger.context !== context),
+			);
+		}
+	}
+
+	removeHotFrom(pressedKeys);
+	removeHotFrom(upKeys);
+	removeHotFrom(downKeys);
 };
 
 function createEventListener(collection) {
-    return (event) => {
-        const { key, target } = event;
-
-        if (!target.classList.contains('input')) {
-            const triggers = [
-                ...(collection.has(key) ? collection.get(key) : []),
-                ...(collection.has(wildcard) ? collection.get(wildcard) : []),
-            ];
-
-            triggers.forEach(trigger => {
-                if (!Keyboard.enabled) return;
-                
-                trigger.run(event);
-            });
-        }
-    };
+	return (event) => {
+		const { key, target } = event;
+
+		if (!target.classList.contains('input')) {
+			const triggers = [
+				...(collection.has(key) ? collection.get(key) : []),
+				...(collection.has(wildcard) ? collection.get(wildcard) : []),
+			];
+
+			triggers.forEach((trigger) => {
+				if (!Keyboard.enabled) return;
+
+				trigger.run(event);
+			});
+		}
+	};
 }
 
 function createTrigger(eventName, collection) {
-    return (key, fn, options = {}) => {
-        if (typeof key === "function") {
-            if (typeof fn === "object") {
-                options = {
-                    ...options,
-                    ...fn,
-                };
-            }
-
-            fn = key;
-            key = "*";
-
-            if (options.key) {
-                key = options.key;
-            }
-        }
-
-        const { hot, enabled, ...params } = options;
-        const context = getContext();
-
-        const keys = Array.isArray(key) ? key : [...key.split(',').map(k => k !== " " ? k.trim() : k)];
-        
-        const trigger = new Trigger({
-            inputType: 'Keyboard',
-            eventName,
-            fn,
-            context,
-            params: {...params, key: keys },
-            hot,
-            enabled,
-            destroy: () => {
-                keys.forEach((key) => {
-                    removeFromMapArray(collection, key, (item) => item.id === trigger.id);
-                });
-            }
-        });
-
-        keys.forEach(key => {
-            addToMapArray(collection, key, trigger);
-        });
-
-        return trigger;
-    };
-};
+	return (key, fn, options = {}) => {
+		if (typeof key === 'function') {
+			if (typeof fn === 'object') {
+				options = {
+					...options,
+					...fn,
+				};
+			}
+
+			fn = key;
+			key = '*';
+
+			if (options.key) {
+				key = options.key;
+			}
+		}
+
+		const { hot, enabled, ...params } = options;
+		const context = getContext();
+
+		const keys = Array.isArray(key)
+			? key
+			: [...`${key}`.split(',').map((k) => (k !== ' ' ? k.trim() : k))];
+
+		const trigger = new Trigger({
+			inputType: 'Keyboard',
+			eventName,
+			fn,
+			context,
+			params: { ...params, key: keys },
+			hot,
+			enabled,
+			destroy: () => {
+				keys.forEach((key) => {
+					removeFromMapArray(
+						collection,
+						key,
+						(item) => item.id === trigger.id,
+					);
+				});
+			},
+		});
+
+		keys.forEach((key) => {
+			addToMapArray(collection, key, trigger);
+		});
+
+		return trigger;
+	};
+}
 
-window.addEventListener("keypress", createEventListener(pressedKeys));
-window.addEventListener("keyup", createEventListener(upKeys));
-window.addEventListener("keydown", createEventListener(downKeys));
+window.addEventListener('keypress', createEventListener(pressedKeys));
+window.addEventListener('keyup', createEventListener(upKeys));
+window.addEventListener('keydown', createEventListener(downKeys));
 
 export const onKeyPress = createTrigger('onKeyPress', pressedKeys);
-export const onKeyDown = createTrigger('onKeyDown', downKeys); 
+export const onKeyDown = createTrigger('onKeyDown', downKeys);
 export const onKeyUp = createTrigger('onKeyUp', upKeys);

package/src/client/app/triggers/MIDI.js

@@ -1,7 +1,7 @@
-import Trigger from "./Trigger";
-import MIDI from "../inputs/MIDI.js";
-import { addToMapArray, removeFromMapArray } from "../utils";
-import { wildcard, getContext } from "./shared";
+import Trigger from './Trigger';
+import MIDI from '../inputs/MIDI.js';
+import { addToMapArray, removeFromMapArray } from '../utils';
+import { wildcard, getContext } from './shared';
 
 const noteons = new Map();
 const noteoffs = new Map();
@@ -11,33 +11,36 @@ const controlchanges = new Map();
 
 /**
  * Remove listeners from a specific context
- * @param {string} context 
+ * @param {string} context
  */
 export const removeHotListeners = (context) => {
-    function removeHotFrom(collection) {
-        for (let trigger of collection) {
-            const [key, triggers] = trigger;
-            
-            collection.set(key, triggers.filter((trigger) => trigger.context !== context));
-        }
-    }
-
-    removeHotFrom(noteons);
-    removeHotFrom(noteoffs);
-    removeHotFrom(numberons);
-    removeHotFrom(numberoffs);
-    removeHotFrom(controlchanges);
+	function removeHotFrom(collection) {
+		for (let trigger of collection) {
+			const [key, triggers] = trigger;
+
+			collection.set(
+				key,
+				triggers.filter((trigger) => trigger.context !== context),
+			);
+		}
+	}
+
+	removeHotFrom(noteons);
+	removeHotFrom(noteoffs);
+	removeHotFrom(numberons);
+	removeHotFrom(numberoffs);
+	removeHotFrom(controlchanges);
 };
 
 /**
  * Check all registered listeners for a specific key
- * @param {Map} collection 
- * @param {function} getKey 
+ * @param {Map} collection
+ * @param {function} getKey
  * @returns {function} listener
  */
 function createEventListener(collection, getKey = (event) => event.key) {
-    return (event) => {
-        const key = getKey(event);
+	return (event) => {
+		const key = getKey(event);
 		const { id } = event.srcElement;
 
 		const triggers = [
@@ -46,78 +49,101 @@ function createEventListener(collection, getKey = (event) => event.key) {
 		];
 
 		if (MIDI.enabled && id === MIDI.selectedInputID) {
-			triggers.forEach(trigger => {
+			triggers.forEach((trigger) => {
 				trigger.run(event);
 			});
 		}
-    };
+	};
 }
 
 /**
  * Create a registering function for a specific event
- * @param {string} eventName 
- * @param {Map} collection 
- * @returns {function} createListener 
+ * @param {string} eventName
+ * @param {Map} collection
+ * @returns {function} createListener
  */
 function createTrigger(eventName, collection) {
-    return (key, fn, options = {}) => {
-        if (typeof key === "function") {
-            if (typeof fn === "object") {
-                options = {
-                    ...options,
-                    ...fn,
-                };
-            }
-
-            fn = key;
-            key = "*";
-
-            if (options.key) {
-                key = options.key;
-            }
-        }
-
-        const { hot, enabled, ...params } = options;
-        let keys = Array.isArray(key) ? key : [...key.split(',').map(k => k.trim())];
-
-        if (["onControlChange", "onNumberOn", "onNumberOff"].includes(eventName)) {
-            keys = keys.map((k) => Number(k));
-        }
-
-        if (!MIDI.enabled) {
-            MIDI.request();
-        }
-
-        const context = getContext();
-
-        const trigger = new Trigger({
-            inputType: 'MIDI',
-            eventName,
-            fn,
-            params: {...params, key: keys },
-            hot,
-            context,
-            enabled,
-            destroy : () => {
-                keys.forEach((key) => {
-                    removeFromMapArray(collection, key, (item) => item.id === trigger.id);
-                });
-            }
-        });
-
-        keys.forEach(k => {
-            addToMapArray(collection, k, trigger);
-        });
-
-        return trigger;
-    };
-};
+	return (key, fn, options = {}) => {
+		if (typeof key === 'function') {
+			if (typeof fn === 'object') {
+				options = {
+					...options,
+					...fn,
+				};
+			}
+
+			fn = key;
+			key = '*';
+
+			if (options.key) {
+				key = options.key;
+			}
+		}
+
+		const { hot, enabled, ...params } = options;
+		let keys = Array.isArray(key)
+			? key
+			: [...`${key}`.split(',').map((k) => k.trim())];
+
+		if (
+			['onControlChange', 'onNumberOn', 'onNumberOff'].includes(eventName)
+		) {
+			keys = keys.map((k) => (!isNaN(Number(k)) ? Number(k) : k));
+		}
+
+		if (!MIDI.enabled) {
+			MIDI.request();
+		}
+
+		const context = getContext();
+
+		const trigger = new Trigger({
+			inputType: 'MIDI',
+			eventName,
+			fn,
+			params: { ...params, key: keys },
+			hot,
+			context,
+			enabled,
+			destroy: () => {
+				keys.forEach((key) => {
+					removeFromMapArray(
+						collection,
+						key,
+						(item) => item.id === trigger.id,
+					);
+				});
+			},
+		});
+
+		keys.forEach((k) => {
+			addToMapArray(collection, k, trigger);
+		});
+
+		return trigger;
+	};
+}
 
-MIDI.addEventListener("noteon", createEventListener(noteons, (event) => event.note.name));
-MIDI.addEventListener("noteoff", createEventListener(noteoffs, (event) => event.note.name));
-MIDI.addEventListener("noteon", createEventListener(numberons, (event) => event.note.number));
-MIDI.addEventListener("noteoff", createEventListener(numberoffs, (event) => event.note.number));
-MIDI.addEventListener("controlchange", createEventListener(controlchanges, (event) => event.note.number));
+MIDI.addEventListener(
+	'noteon',
+	createEventListener(noteons, (event) => event.note.name),
+);
+MIDI.addEventListener(
+	'noteoff',
+	createEventListener(noteoffs, (event) => event.note.name),
+);
+MIDI.addEventListener(
+	'noteon',
+	createEventListener(numberons, (event) => event.note.number),
+);
+MIDI.addEventListener(
+	'noteoff',
+	createEventListener(numberoffs, (event) => event.note.number),
+);
+MIDI.addEventListener(
+	'controlchange',
+	createEventListener(controlchanges, (event) => event.note.number),
+);
 
 export const onNoteOn = createTrigger('onNoteOn', noteons);
 export const onNoteOff = createTrigger('onNoteOff', noteoffs);

package/src/client/app/triggers/Mouse.js

@@ -1,6 +1,6 @@
-import Trigger from "./Trigger";
-import { wildcard, getContext } from "./shared.js";
-import { addToMapArray, removeFromMapArray } from "../utils";
+import Trigger from './Trigger';
+import { wildcard, getContext } from './shared.js';
+import { addToMapArray, removeFromMapArray } from '../utils';
 
 window.mouseIsPressed = false;
 window.mouseX = 0;
@@ -12,83 +12,91 @@ const moves = new Map();
 const clicks = new Map();
 
 export const reset = (context) => {
-    downs.delete(context);
-    ups.delete(context);
-    moves.delete(context);
-    clicks.delete(context);
-}
+	downs.delete(context);
+	ups.delete(context);
+	moves.delete(context);
+	clicks.delete(context);
+};
 
 export const removeHotListeners = (context) => {
-    function removeHotFrom(collection) {
-        const triggers = collection.get(context);
+	function removeHotFrom(collection) {
+		const triggers = collection.get(context);
 
-        if (triggers && triggers.length > 0) {
-            const hotListeners = triggers.filter(t => t.hot);
-            const rest = triggers.filter(t => !t.hot);
+		if (triggers && triggers.length > 0) {
+			const hotListeners = triggers.filter((t) => t.hot);
+			const rest = triggers.filter((t) => !t.hot);
 
-            hotListeners.forEach(t => t.destroy());
+			hotListeners.forEach((t) => t.destroy());
 
-            collection.set(context, rest);
-        }
-    }
+			collection.set(context, rest);
+		}
+	}
 
-    removeHotFrom(downs);
-    removeHotFrom(ups);
-    removeHotFrom(moves);
-    removeHotFrom(clicks);
+	removeHotFrom(downs);
+	removeHotFrom(ups);
+	removeHotFrom(moves);
+	removeHotFrom(clicks);
 };
 
 const checkForTriggers = (collection, event, scope) => {
-    const triggers = [
-        ...(collection.has(scope) ? collection.get(scope) : []),
-        ...(collection.has(wildcard) ? collection.get(wildcard) : []),
-    ];
-
-    triggers.forEach(trigger => {
-        trigger.run(event)
-    });
-}
+	const triggers = [
+		...(collection.has(scope) ? collection.get(scope) : []),
+		...(collection.has(wildcard) ? collection.get(wildcard) : []),
+	];
+
+	triggers.forEach((trigger) => {
+		trigger.run(event);
+	});
+};
 
 /**
- * 
- * @param {Map} collection 
- * @returns 
+ *
+ * @param {Map} collection
+ * @returns
  */
 const createTrigger = (eventName, collection) => {
-    return (fn, { context, hot, enabled } = {}) => {
-        try {
-            if (!context) {
-                context = getContext();
-            }
-
-            const trigger = new Trigger({
-                inputType: 'Mouse',
-                eventName,
-                fn,
-                params: { context },
-                context,
-                hot,
-                enabled,
-                destroy: () => {
-                    removeFromMapArray(collection, context, (item) => item.id === trigger.id);
-                }
-            });
-
-            addToMapArray(collection, context, trigger);
-
-            return trigger;
-        } catch(error) {
-            console.error(error);
-            
-            return null;
-        }
-    }
+	return (fn, { context, hot, enabled } = {}) => {
+		try {
+			if (!context) {
+				context = getContext();
+			}
+
+			const trigger = new Trigger({
+				inputType: 'Mouse',
+				eventName,
+				fn,
+				params: { context },
+				context,
+				hot,
+				enabled,
+				destroy: () => {
+					removeFromMapArray(
+						collection,
+						context,
+						(item) => item.id === trigger.id,
+					);
+				},
+			});
+
+			addToMapArray(collection, context, trigger);
+
+			return trigger;
+		} catch (error) {
+			console.error(error);
+
+			return null;
+		}
+	};
 };
 
-export const checkForTriggersDown = (event, context) => checkForTriggers(downs, event, context);
-export const checkForTriggersMove = (event, context) => checkForTriggers(moves, event, context);
-export const checkForTriggersUp = (event, context) => checkForTriggers(ups, event, context);
-export const checkForTriggersClick = (event, context) => checkForTriggers(clicks, event, context);
+export const checkForTriggersDown = (event, context) =>
+	checkForTriggers(downs, event, context);
+export const checkForTriggersMove = (event, context) =>
+	checkForTriggers(moves, event, context);
+export const checkForTriggersUp = (event, context) =>
+	checkForTriggers(ups, event, context);
+export const checkForTriggersClick = (event, context) =>
+	checkForTriggers(clicks, event, context);
 
 export const onMouseDown = createTrigger('onMouseDown', downs);
 export const onMouseUp = createTrigger('onMouseUp', ups);