fragment-tools 0.1.13 → 0.1.14

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);