@peter.naydenov/shortcuts 2.2.0 → 3.0.1

package/src/plugins/click/index.js

@@ -0,0 +1,74 @@
+'use strict'
+
+import _findTarget              from "./_findTarget"
+import _listenDOM              from "./_listenDOM"
+import _normalizeShortcutName  from "./_normalizeShortcutName"
+import _readClickEvent         from "./_readClickEvent"
+import _registerShortcutEvents from "./_registerShortcutEvents"
+
+
+
+
+function pluginClick ( dependencies, state, options ) {
+        let 
+                  { currentContext, shortcuts } = state
+                , { inAPI } = dependencies
+                , deps = {
+                                ev: dependencies.ev
+                             , _findTarget
+                             , _readClickEvent
+                             , mainDependencies : dependencies
+                             , regex : /CLICK\s*\:/i
+                        }
+                , pluginState = {
+                                  currentContext
+                                , shortcuts
+                                , listenOptions  : {
+                                                      mouseWait     : options.mouseWait ? options.mouseWait : 320   // 320 ms
+                                                    , maxClicks     : 1  // How many clicks can be pressed in a sequence. Controlled automatically by '_registerShortcutEvents' function.
+                                                    , clickTarget   : options.clickTarget ? options.clickTarget :  'click' // Data-attribute name for click target ( data-click )
+                                                }
+                            } // pluginState
+                ; 
+
+        // Read shortcuts names from all context entities and normalize entries related to the plugin
+        inAPI._normalizeWithPlugins ( _normalizeShortcutName )
+        
+        let 
+             mouseListener = _listenDOM ( deps, pluginState )
+           , countShortcuts = _registerShortcutEvents ( deps, pluginState )
+           ;
+      
+        if ( countShortcuts > 0 )   mouseListener.start ()
+       
+        let pluginAPI = {
+                               getPrefix      : () => 'click'
+                             , shortcutName  : key => {   // Format a key string according plugin needs
+                                                        return _normalizeShortcutName ( key )
+                                                }
+                             , contextChange : () => {
+                                                countShortcuts = _registerShortcutEvents ( deps, pluginState )
+                                                if ( countShortcuts < 1 ) {  // Remove DOM listener if there are no shortcuts in the current context
+                                                                mouseListener.stop ()
+                                                    } 
+                                                if ( countShortcuts > 0 ) {  // Add DOM listener if there are shortcuts in the current context
+                                                                mouseListener.start ()
+                                                    }
+                                        }
+                            , mute    : () => mouseListener.stop ()
+                            , unmute  : () => mouseListener.start ()
+                            , destroy : () => {
+                                                mouseListener.stop ()
+                                                pluginState = null
+                                                pluginAPI = null
+                                        }
+                        }; // pluginAPI
+        Object.freeze ( pluginAPI )
+        return pluginAPI
+} // pluginClick func.
+
+
+
+export default pluginClick
+
+

package/src/plugins/key/_listenDOM.js

@@ -0,0 +1,138 @@
+'use strict'
+
+
+
+function _listenDOM ( dependencies, state ) {
+// Listen for input signals and generate event titles  
+    const { 
+                ev
+                , _specialChars
+                , _readKeyEvent
+                , mainDependencies
+            } = dependencies
+        , {
+                  currentContext
+                , streamKeys
+                , listenOptions
+            } = state
+        , {
+                  keyWait
+            } = listenOptions
+        ;
+    
+    let 
+          r = []
+        , keyTimer = null    // Timer for key sequence or null
+        , sequence = true
+        , ignore   = false   // Use to trigger a single callback without adding the key to the sequence.
+        ;
+
+
+    
+    const  
+           waitKeys   = () => sequence = false  
+        ,  endKeys    = () => sequence = true  
+        , ignoreKeys  = () => ignore   = true
+        , waitingKeys = () => sequence === false
+        ;
+    
+
+
+    function keySequenceEnd () {   // Execute when key sequence ends
+                    let res =  r.map ( x => ([x.join('+')])   )
+                    const data = {
+                                      wait: waitKeys
+                                    , end:endKeys
+                                    , ignore:ignoreKeys
+                                    , isWaiting:waitingKeys
+                                    , note: currentContext.note
+                                    , context: currentContext.name
+                                    , dependencies : mainDependencies.extra
+                                    , type : 'key'
+                            };
+                    if ( !sequence ) {
+                            let signal = res.at(-1);
+                            ev.emit ( signal, data )    
+                            if ( ignore ) {
+                                        res = res.slice ( 0, -1 )
+                                        ignore = false
+                                }
+                        }
+                            
+                    if ( sequence ) {
+                            const signal = `KEY:${res.join(',')}`
+                            ev.emit ( signal, data )   
+                            // Reset:
+                            r = []
+                            keyTimer = null
+                        }
+        } // keySequeceEnd func.
+
+
+    
+    function listenForSpecialKeys ( event ) { // Listen for special keyboard keys
+                clearTimeout ( keyTimer )
+                if ( _specialChars.hasOwnProperty(event.code) )   r.push ( _readKeyEvent ( event, _specialChars ))
+                else                                             return
+                if ( streamKeys )   streamKeys ({ key:event.key, context:currentContext.name, note:currentContext.note, dependencies:dependencies.extra })
+                if ( listenOptions.keyIgnore ) {
+                            clearTimeout ( listenOptions.keyIgnore )
+                            listenOptions.keyIgnore = setTimeout ( () => listenOptions.keyIgnore=null, keyWait )
+                            return 
+                    }
+                if ( sequence && r.length === listenOptions.maxSequence ) {      
+                            keySequenceEnd ()
+                            listenOptions.keyIgnore = setTimeout ( () => listenOptions.keyIgnore=null, keyWait )
+                            return
+                    }
+                if ( sequence   )   keyTimer = setTimeout ( keySequenceEnd, keyWait )
+                else                keySequenceEnd ()
+        } // listenForSpecialKeys func.
+
+    
+
+    function listenForRegularKeys ( event ) {  // Listen for regular keyboard keys
+                if ( _specialChars.hasOwnProperty(event.code) )   return            
+                clearTimeout ( keyTimer )
+                if ( streamKeys )   streamKeys ({ key:event.key, context:currentContext.name, note:currentContext.note, dependencies:dependencies.extra })
+                if ( listenOptions.keyIgnore ) {
+                            clearTimeout ( listenOptions.keyIgnore )
+                            listenOptions.keyIgnore = setTimeout ( () => listenOptions.keyIgnore=null, keyWait )
+                            return 
+                    }
+                r.push ( _readKeyEvent ( event, _specialChars ))
+                if ( sequence && r.length === listenOptions.maxSequence ) {
+                            keySequenceEnd ()
+                            listenOptions.keyIgnore = setTimeout ( () => listenOptions.keyIgnore=null, keyWait )
+                            return
+                    }
+                if ( sequence )   keyTimer = setTimeout ( keySequenceEnd, keyWait )
+                else              keySequenceEnd ()
+        } // listenForRegularKeys func.
+
+
+
+    function start () {
+                        if ( state.active ) return
+                        document.addEventListener ( 'keydown' , listenForSpecialKeys )
+                        document.addEventListener ( 'keypress', listenForRegularKeys )
+                        state.active = true
+        } 
+
+
+    function stop () {
+                        if ( !state.active ) return
+                        document.removeEventListener ( 'keydown' , listenForSpecialKeys )
+                        document.removeEventListener ( 'keypress', listenForRegularKeys )
+                        state.active = false
+        }
+    
+    return { start, stop }
+
+} // _listenDOM func.
+
+
+
+export default _listenDOM
+
+

package/src/plugins/key/_normalizeShortcutName.js

@@ -0,0 +1,31 @@
+'use strict'
+
+function _normalizeShortcutName ( name ) {
+            const 
+                  upperCase = name.toUpperCase ()
+                , regex = /KEY\s*\:/i
+                , isKeyboardShortcut = regex.test ( upperCase )
+                , sliceIndex = upperCase.indexOf ( ':' )
+                ;
+
+            if ( !isKeyboardShortcut )   return name
+            let shortcut = upperCase
+                               .slice(sliceIndex+1)
+                               .split(',')
+                               .map ( key => key.trim() )
+                               .map ( key => {
+                                            return key
+                                                     .split ( '+' )
+                                                     .map ( key => key.trim() )
+                                                     .sort()
+                                                     .join ( '+' )
+                                        })
+                               .join(',');
+            return `KEY:${shortcut}`   
+} // _normalizeShortcutName func.
+
+
+
+export default _normalizeShortcutName
+
+

package/src/{methods → plugins/key}/_readKeyEvent.js

@@ -1,7 +1,6 @@
 'use strict'
 
-function _readKeyEvent () {
-return function _readKeyEvent ( event, _specialChars ) {
+function _readKeyEvent ( event, _specialChars ) {
     let
           { shiftKey, altKey, ctrlKey } = event
         , falseKeys = [ 'ControlLeft','ControlRight', 'ShiftLeft', 'ShiftRight', 'AltLeft', 'AltRight', 'Meta' ]
@@ -18,7 +17,7 @@ return function _readKeyEvent ( event, _specialChars ) {
     if ( _specialChars.hasOwnProperty ( key ) )  res.push ( _specialChars[key].toUpperCase () )
     else if (       !falseKeys.includes(key)  )  res.push ( key.toUpperCase () )
     return res.sort ()
-}} // _readKeyEvent func.
+} // _readKeyEvent func.
 
 
 

package/src/plugins/key/_registerShortcutEvents.js

@@ -0,0 +1,28 @@
+'use strict'
+
+function _registerShortcutEvents ( dependencies, pluginState ) {
+let count = 0;
+const 
+          { regex } = dependencies
+        , { 
+                  listenOptions
+                , currentContext : { name: contextName }
+                , shortcuts 
+           } = pluginState
+        ;
+if ( contextName == null )   return 0
+Object.entries ( shortcuts[contextName] ).forEach ( ([shortcutName, list ]) => {   // Enable new context shortcuts and set a listenOptions 'maxSequence'      
+                let isKeyboardEv = regex.test ( shortcutName );
+                if ( !isKeyboardEv ) return
+                count++
+                let sequenceArraySize = shortcutName.slice(4).split(',').length;
+                if ( listenOptions.maxSequence < sequenceArraySize )   listenOptions.maxSequence = sequenceArraySize
+        })
+return count
+} // _registerShortcutEvents func.
+
+
+
+export default _registerShortcutEvents
+
+

package/src/plugins/key/index.js

@@ -0,0 +1,76 @@
+'use strict'
+
+// import all plugin files here
+import _listenDOM              from './_listenDOM.js'
+import _normalizeShortcutName  from './_normalizeShortcutName.js'
+import _readKeyEvent           from './_readKeyEvent.js'
+import _registerShortcutEvents from './_registerShortcutEvents.js'
+import _specialChars           from './_specialChars.js'
+
+
+
+function pluginKey ( dependencies, state, options={} ) {
+        let 
+                  { currentContext, shortcuts, exposeShortcut } = state
+                , { inAPI } = dependencies
+                , deps = {
+                             ev: dependencies.ev
+                             , _specialChars
+                             , _readKeyEvent
+                             , mainDependencies : dependencies
+                             , regex : /KEY\s*\:/i
+                        }
+                , pluginState = {
+                            currentContext
+                          , shortcuts
+                          , active : false
+                          , listenOptions  : {
+                                                  keyWait       : options.keyWait ? options.keyWait : 480   // 480 ms
+                                                , maxSequence   : 1  // How many keys can be pressed in a sequence. Controlled automatically by 'changeContext' function.
+                                                , keyIgnore     : null   // Timer for ignoring key presses after max sequence or null. Not a public option.
+                                        }
+                          , streamKeys     : (options.streamKeys && ( typeof options.streamKeys === 'function')) ? options.streamKeys : false   // Keyboard stream function
+                          , exposeShortcut
+                }; // state
+                
+        // Read shortcuts names from all context entities and normalize entries related to the plugin
+        inAPI._normalizeWithPlugins ( _normalizeShortcutName )
+                
+        let 
+             keysListener   = _listenDOM ( deps, pluginState )
+           , countShortcuts = _registerShortcutEvents ( deps, pluginState )
+           ;
+           
+        if ( countShortcuts > 0 )   keysListener.start ()
+       
+        let pluginAPI = {
+                               getPrefix      : () => 'key'
+                             , shortcutName  : key => {   // Format a key string according plugin needs
+                                                     return _normalizeShortcutName ( key )   
+                                                }
+                             , contextChange : contextName  => {
+                                                countShortcuts = _registerShortcutEvents ( deps, pluginState )
+                                                if ( countShortcuts < 1 ) {  // Remove DOM listener if there are no shortcuts in the current context
+                                                                keysListener.stop ()
+                                                        }
+                                                if ( countShortcuts > 0 ) { // Add DOM listener if there are shortcuts in the current context
+                                                                keysListener.start ()
+                                                        }
+                                        }
+                             , mute          : () => keysListener.stop ()
+                             , unmute        : () => keysListener.start ()
+                             , destroy       : () => {
+                                                        keysListener.stop ()
+                                                        pluginState = null
+                                                        pluginAPI = null
+                                                }
+                        };
+        Object.freeze ( pluginAPI )
+        return pluginAPI
+} // pluginKey func.
+
+
+
+export default pluginKey
+
+