@peter.naydenov/shortcuts 2.2.0 → 3.0.0

package/src/main.js

@@ -3,6 +3,7 @@
 /**
  *  Shortcuts
  *  ========
+ * 
  *  Create shortcuts for your web application based on keyboard and mouse events.
  *  Repository: https://github.com/PeterNaydenov/shortcuts
  * 
@@ -11,6 +12,7 @@
  *  - First version was published on August 14th, 2023
  *  - Method 'emit' was added on September 30st, 2023
  *  - Version 2.0.0 was published on October 16th, 2023
+ *  - Version 3.0.0. Plugin system. Published on March 5th, 2024
  */
 
 
@@ -18,11 +20,16 @@
 import notice  from '@peter.naydenov/notice'   // Docs: https://github.com/PeterNaydenov/notice
 import methods from './methods/index.js'
 
+// Plugins
+import pluginKey from './plugins/key/index.js'
+import pluginClick from './plugins/click/index.js'
+
 
 
 
 
 function main ( options = {} ) {
+
     const
           ev = notice ()  // Event emitter instance
         , inAPI = {}      // API for internal methods
@@ -30,17 +37,8 @@ function main ( options = {} ) {
         , state = {
                       currentContext : { name: null, note: null } // Context data container
                     , shortcuts      : {}   // shortcuts = { contextName : { shortcut :  callback[] } }
-                    , listenOptions  : {
-                                          mouseWait     : options.mouseWait ? options.mouseWait : 320   // 320 ms
-                                        , maxClicks     : 1  // The maximum number of clicks in a sequence. Controlled automatically by 'changeContext' function.
-                                        , keyWait       : options.keyWait ? options.keyWait : 480   // 480 ms
-                                        , maxSequence   : 1  // How many keys can be pressed in a sequence. Controlled automatically by 'changeContext' function.
-                                        , clickTarget   : options.clickTarget ? options.clickTarget :  'click' // Data-attribute name for click target ( data-click )
-                                        , listenFor     : (options.listenFor && Array.isArray(options.listenFor)) ? options.listenFor : [ 'mouse', 'keyboard' ] // What to listen for: ['mouse'], ['keyboard'], ['mouse', 'keyboard']
-                                        , keyIgnore     : null   // Timer for ignoring key presses after max sequence or null. Not a public option.
-                                    }
-                    , exposeShortcut : (options.onShortcut && ( typeof options.onShortcut === 'function')) ? options.onShortcut : false
-                    , streamKeys     : (options.streamKeys && ( typeof options.streamKeys === 'function')) ? options.streamKeys : false
+                    , plugins        : [] // Array of active plugins
+                    , exposeShortcut : (options.onShortcut && ( typeof options.onShortcut === 'function')) ? options.onShortcut : false   // Keyboard shortcut log function
               } // state
         , dependencies = { 
                               ev
@@ -50,6 +48,58 @@ function main ( options = {} ) {
                         }
         ;
 
+
+
+    // ----------------------  > PLUGIN METHODS < ---------------------- //
+    /**
+     * @function enablePlugin
+     * @description Enable a plugin
+     * @returns {void}
+     */
+    API.enablePlugin = ( plugin,options={}) => {
+                const 
+                      name = plugin.name
+                    , ix = inAPI._systemAction ( name, 'none' )
+                    ;
+
+                if ( ix === -1 ) {   // If plugin is not registered
+                            let plugApp;   // Started instance of the plugin
+                            plugApp = plugin ( dependencies, state, options )
+                            state.plugins.push ( plugApp )
+                    }
+      } // enable func.
+
+
+
+    /**
+     * @function disablePlugin
+     * @description Disable a plugin
+     * @returns {void}
+     */
+    API.disablePlugin = pluginName => { 
+                const ix = inAPI._systemAction ( pluginName, 'destroy' );
+                if ( ix !== -1 )   state.plugins = state.plugins.filter ( (plugin, i) => i !== ix )
+      } // disable func.
+
+
+    /**
+     * @function mutePlugin
+     * @description Mute a plugin
+     * @returns number - Index of the plugin in the plugins array ( -1 if not found ).
+     */
+    API.mutePlugin = pluginName => inAPI._systemAction ( pluginName, 'mute'   )
+
+    /**
+     * @function unmute
+     * @description Unmute a plugin
+     * @returns number - Index of the plugin in the plugins array ( -1 if not found ).
+     */
+    API.unmutePlugin = pluginName => inAPI._systemAction ( pluginName, 'unmute' )
+
+
+    
+
+    // ----------------------  > PUBLIC METHODS < ---------------------- //
     /**
      * @function getContext
      * @description Get current context name
@@ -78,7 +128,10 @@ function main ( options = {} ) {
        * @param {string} [name='*' ] - Shortcut name that should be paused. Default is '*' - all shortcuts in current context.
        * @returns {void}
        */
-    API.pause = (name='*') => ev.stop ( inAPI._readShortcut(name) )
+    API.pause = (name='*') => {
+                        let pausedEvent = inAPI._readShortcutWithPlugins ( name );
+                        ev.stop ( pausedEvent )
+                  }
 
     /**
        * @function resume
@@ -86,7 +139,10 @@ function main ( options = {} ) {
        * @param {string} [name='*' ] - Shortcut name that should be resumed. Default is '*' - all shortcuts in current context.
        * @returns {void}
        */
-    API.resume = (name='*') => ev.start ( inAPI._readShortcut(name) )
+    API.resume = (name='*') => {
+                        const resumedEvent = inAPI._readShortcutWithPlugins ( name )
+                        ev.start ( resumedEvent )
+                  }
 
     /**
      * @function emit
@@ -95,14 +151,17 @@ function main ( options = {} ) {
      * @param {any} [args] - Arguments for callback function
      * @returns {void}
      **/
-    API.emit = (name,...args) => ev.emit ( inAPI._readShortcut(name), dependencies.extra, ...args )
+    API.emit = (name,...args) =>  ev.emit ( inAPI._readShortcutWithPlugins ( name ), ...args )
+      
 
     /**
      * @function listContexts
      * @description List all context names
      * @returns {string[]} - Array of context names
      */
-    API.listContexts = () => Object.keys ( shortcuts )
+    API.listContexts = () => Object.keys ( state.shortcuts )
+
+
 
     /**
      * @function setDependencies
@@ -110,7 +169,7 @@ function main ( options = {} ) {
      * @param {object} deps - Enumerate external dependencies
      * @returns {void}
      */
-    API.setDependencies = (deps) => dependencies.extra = { ...dependencies.extra, ...deps }
+    API.setDependencies = deps => dependencies.extra = { ...dependencies.extra, ...deps }
 
     /**
      * @function getDependencies
@@ -125,24 +184,16 @@ function main ( options = {} ) {
                 if ( name.startsWith('_') ) inAPI [ name ] = method ( dependencies, state )
                 else                          API [ name ] = method ( dependencies, state )
         })
-  
-    inAPI._listen ()
+
     return API
 } // main func.
 
 
 
-main.getDefaults = () => ({
-                          mouseWait     : 320     // 320 ms
-                        , keyWait       : 480     // 480 ms
-                        , clickTarget   : 'click' // Data-attribute name for click target ( data-click )
-                        , listenFor     : [ 'mouse', 'keyboard' ]
-                        , onShortcut    : false   // Shortcut log function or false 
-                        , streamKeys    : false   // Stream keys function or false
-                    })
-
-
-
-export default main
+export { main as shortcuts }
+export { 
+            pluginKey
+          , pluginClick
+        }
 
 

package/src/methods/_normalizeWithPlugins.js

@@ -0,0 +1,25 @@
+function _normalizeWithPlugins ( dependencies, state ) {
+/**
+ * @function _normalizeWithPlugins
+ * @description Function used by plugins during the enable process to normalize the existing and related to the plugin shortcut names.
+ * @param {function} _normalizeShortcutName - Plugin internal 'normalize' function.
+ * @returns {void}
+ */
+return function _normalizeWithPlugins ( _normalizeShortcutName ) {
+  const shortcuts = state.shortcuts;
+  Object.keys ( shortcuts ).forEach ( contextName => {
+                        Object.entries (shortcuts[contextName]).forEach ( ([shortcutName, callbackList]) => {
+                                                const name = _normalizeShortcutName ( shortcutName )
+                                                if ( name !== shortcutName ) {
+                                                                delete shortcuts[contextName][shortcutName]
+                                                                shortcuts[contextName][name] = callbackList
+                                                        }
+                                        })
+                })
+}} // _normalizeWithPlugins func.
+
+
+
+export default _normalizeWithPlugins
+
+

package/src/methods/_readShortcutWithPlugins.js

@@ -0,0 +1,24 @@
+'use strict'
+function _readShortcutWithPlugins ( dependencies, state ) {
+/**
+ * @function _readShortcutWithPlugins
+ * @description Searches for belonging plugin and call the plugin method to normalize the shortcut name.
+ * @param {string} shortcut - The shortcut to read.
+ * @returns {string} - The normalized shortcut name.
+ */
+return function _readShortcutWithPlugins ( shortcut ) {
+    const 
+          {  inAPI } = dependencies
+        , pluginName = shortcut.split(':')[0]
+        , ix = inAPI._systemAction ( pluginName, 'none' )  // Find a index. Don't call any method.
+        ;
+        let pausedEvent = shortcut;
+        if ( ix !== -1 )    pausedEvent = state.plugins[ix].shortcutName ( shortcut )
+        return pausedEvent
+}} // _readShortcutWithPlugins func.
+
+
+
+export default _readShortcutWithPlugins
+
+

package/src/methods/_systemAction.js

@@ -0,0 +1,25 @@
+'use strict'
+
+function _systemAction ( dependencies, state ) {
+/**
+ * @function _systemAction
+ * @description Call a specifc plugin method.
+ * @param {string} pluginName - The name of the plugin.
+ * @param {string} fn - The name of the method to call.
+ * @param {any} params - The parameters to pass to the method.
+ */
+return function _systemAction ( pluginName, fn, params=null ) {   // Specific plugin command: Mute, unmute, pause, resume, destroy
+    return state.plugins.findIndex ( plugin => {
+                  if ( plugin.getPrefix() === pluginName ) {  
+                              if ( plugin[fn] )   plugin[fn]( params )
+                              return true
+                      }
+                  return false
+              })
+}} // _systemAction func.
+
+
+
+export default _systemAction
+
+

package/src/methods/changeContext.js

@@ -3,13 +3,22 @@
 function changeContext ( dependencies, state ) {
 const 
           { 
-               shortcuts
-             , listenOptions 
-             , currentContext
+                shortcuts
+              , currentContext
           } = state
         , { ev } = dependencies
         ;
 
+
+
+function expose () {
+                ev.on ( '*', (...args) => {
+                                if ( state.exposeShortcut )   state.exposeShortcut ( ...args )
+                        })
+        } // expose func.
+
+
+
 /**
  * @function changeContext
  * @description Change current context with shortcuts belonging to it.
@@ -19,14 +28,6 @@ const
 return function changeContext ( contextName = false ) {
         const current = currentContext.name;
         
-        listenOptions.maxSequence = 1
-        listenOptions.maxClicks = 1
-        
-        if ( listenOptions.keyIgnore >= 0 ) {   
-                        clearTimeout ( listenOptions.keyIgnore )
-                        listenOptions.keyIgnore = null
-                }
-
         if ( !contextName ) {   // Switch off all shortcuts if contextName is not defined
                         ev.reset ()
                         currentContext.name = null
@@ -34,26 +35,19 @@ return function changeContext ( contextName = false ) {
                 }
         if ( current === contextName ) return   // Do nothing if contextName is the same as current
         if ( !shortcuts [ contextName ] ) {   // If contextName is not defined
-                        ev.emit ( 'shortcuts-error', `Context '${ contextName }' does not exist` )
+                        ev.emit ( '@shortcuts-error', `Context '${ contextName }' does not exist` )
                         return
                 }
         if ( shortcuts[current] ) {
                         ev.reset ()   // Disable all shortcuts from current context
                 }
-        Object.entries ( shortcuts [ contextName ]).forEach ( ([shortcutName, list ]) => {   // Enable new context shortcuts and set a listenOptions 'maxSequence' and 'maxClicks'       
-                        let isMouseEv = shortcutName.includes ( 'MOUSE-CLICK-' );
-                        if ( isMouseEv ) {   // Set mouse max clicks
-                                        let [ , , , count ] = shortcutName.split('-')
-                                        let c = parseInt ( count );   // Number of clicks
-                                        if ( listenOptions.maxClicks < c )   listenOptions.maxClicks = c
-                                }
-                        else {   // Set key max sequence
-                                        let sequenceArraySize = shortcutName.split(',').length;
-                                        if ( listenOptions.maxSequence < sequenceArraySize )   listenOptions.maxSequence = sequenceArraySize
-                                }
-                        list.forEach ( fn => ev.on ( shortcutName, fn )   )    // Enable new context shortcuts
-                })   
-        currentContext.name = contextName        
+
+        currentContext.name = contextName 
+        state.plugins.forEach ( plugin => plugin.contextChange ( contextName )    )        // Inform plugins for context change
+        Object.entries ( shortcuts[contextName] ).forEach ( ([shortcutName, list ]) => {   // Enable new context shortcuts
+                        list.forEach ( fn => ev.on ( shortcutName, fn )    )
+                })
+        expose ()
 }} // changeContext func.
 
 

package/src/methods/index.js

@@ -1,9 +1,6 @@
-import _findTarget      from './_findTarget.js'
-import _listen         from './_listen.js'
-import _readKeyEvent   from './_readKeyEvent.js'
-import _readMouseEvent from './_readMouseEvent.js'
-import _readShortcut   from './_readShortcut.js'
-import _specialChars   from './_specialChars.js'
+import _normalizeWithPlugins    from './_normalizeWithPlugins.js'
+import _readShortcutWithPlugins from './_readShortcutWithPlugins.js'
+import _systemAction            from './_systemAction.js'
 
 import load           from './load.js'
 import unload         from './unload.js'
@@ -14,13 +11,10 @@ import listShortcuts  from './listShortcuts.js'
 
 export default {
 // Internal methods
-    _findTarget
-  , _listen
-  , _readKeyEvent
-  , _readMouseEvent
-  , _readShortcut
-  , _specialChars
-
+   _normalizeWithPlugins
+ , _readShortcutWithPlugins
+ , _systemAction
+    
 // Public methods
   , changeContext
   , listShortcuts

package/src/methods/load.js

@@ -2,32 +2,39 @@
 
 function load ( dependencies, state ) {
 const 
-          { shortcuts } = state
+          { shortcuts, plugins } = state
         , {
-                inAPI : { _readShortcut }
-                , API : { changeContext, getContext }
-        } = dependencies;
+                API : { changeContext, getContext }
+          } = dependencies;
 /**
  *  Load a context with shortcuts object
- *  @param {Object} obj - Context description object: { contextName : { shortcut : callback[] }
+ *  @param {Object} shortcutsUpdate - Context description object: { contextName : { shortcut : callback[] }
  *  @returns {void}
  */
-return function load ( obj ) {
+return function load ( shortcutsUpdate ) {
     const
            currentContextName = getContext ()
-         , contextList = Object.keys ( obj )
+         , pluginPrefixList = plugins.map ( plugin => plugin.getPrefix().toUpperCase()   )
          ;
     let hasChanges = false;
-    contextList.forEach ( contextName => {
-                    const description = Object.entries ( obj [ contextName ] );
-                    if ( contextName === currentContextName ) hasChanges = true;
+    
+    Object.entries ( shortcutsUpdate ).forEach ( ([contextName, contextShortcuts]) => {
+                    if ( contextName === currentContextName ) hasChanges = true;   // If changes in current context will need to reload it
                     shortcuts [ contextName ] = {}
-                    description.forEach ( ([ title, callbackList ]) => {
-                                    const name = _readShortcut ( title );
+                    Object.entries ( contextShortcuts ).forEach ( ([ title, callbackList ]) => {
+                                    let 
+                                          name = title
+                                        , test = title.toUpperCase().trim()
+                                        ;
+                                    let pluginIndexList = pluginPrefixList.map ( (prefix,i) => test.startsWith ( prefix ) ? i : null ).filter ( i => i !== null );
+                                    if ( pluginIndexList.length ) {
+                                                let id = pluginIndexList[0];
+                                                name = plugins[id].shortcutName ( title )
+                                        }
                                     if ( callbackList instanceof Function ) callbackList = [ callbackList ]
                                     shortcuts [contextName][ name ] = callbackList
-                            }) // shortcuts.forEach
-        }) // contextList.forEach
+                            }) // contextShortcuts.forEach
+        }) // shortcutsUpdate.forEach
      if ( hasChanges ) {  // Reload context shortcuts after loading process if context was active
                 changeContext ()
                 changeContext ( currentContextName )

package/src/plugins/click/_findTarget.js

@@ -0,0 +1,20 @@
+'use strict'
+
+function _findTarget ( dependencies, state, target ) {
+    
+    const { listenOptions : {clickTarget}} = state;
+
+    let t = target;
+    if ( t === document      )   return null
+    if ( t === document.body )   return null
+
+    if ( t.dataset[clickTarget] ) return t
+    if ( t.nodeName === 'A'     ) return t
+    return   _findTarget ( dependencies, state, t.parentNode ) 
+} // _findTarget func.
+
+
+
+export default _findTarget
+
+

package/src/plugins/click/_listenDOM.js

@@ -0,0 +1,117 @@
+'use strict'
+
+
+function _listenDOM ( dependencies, state ) {
+        const { 
+                   ev
+                , _findTarget 
+                , _readClickEvent
+                , mainDependencies
+                        } = dependencies
+        const { listenOptions, currentContext } = state
+        const { mouseWait } = listenOptions
+
+        let 
+             mouseTarget = null // Dom element or null
+           , mouseDomEvent = null
+           , mouseTimer = null  // Timer for mouse sequence or null
+           , mouseIgnore = null // Timer for ignoring mouse clicks or null
+           , count    = 0
+           ;
+
+        function mouseSequenceEnd () {   // Execute when mouse sequence ends
+                        const 
+                                  mouseEvent = _readClickEvent ( mouseDomEvent, count )
+                                , data = { 
+                                          target : mouseTarget
+                                        , targetProps : mouseTarget ? mouseTarget.getBoundingClientRect() : null
+                                        , x       : mouseDomEvent.clientX
+                                        , y       : mouseDomEvent.clientY
+                                        , context : currentContext.name
+                                        , note    : currentContext.note
+                                        , event   : mouseDomEvent
+                                        , dependencies : mainDependencies.extra
+                                        , type   : 'click'
+                                }
+                                ;
+
+                        ev.emit ( mouseEvent, data )
+                        // Reset:
+                        mouseTimer = null
+                        mouseIgnore = null
+                        mouseTarget = null
+                        mouseDomEvent = null
+                        count = 0
+                } // mouseSequenceEnd func.
+
+
+
+        function listenLeftClick ( event ) {
+                        let targetMax = listenOptions.maxClicks;  // Maximum number of clicks per target
+                        clearTimeout ( mouseTimer )
+                        if ( mouseIgnore ) {
+                                    clearTimeout ( mouseIgnore )
+                                    mouseIgnore = setTimeout ( () => mouseIgnore=null, mouseWait )
+                                    return
+                            }
+                        mouseTarget = _findTarget ( dependencies, state, event.target )
+                        if ( mouseTarget && mouseTarget.dataset.hasOwnProperty('quickClick'))   targetMax = 1
+                        if ( mouseTarget && mouseTarget.tagName === 'A'                     )   targetMax = 1
+                        mouseDomEvent = event
+                        count++
+                        if ( count >= targetMax ) {
+                                    mouseSequenceEnd ()
+                                    if ( targetMax > 1 )   mouseIgnore = setTimeout ( () => mouseIgnore=null, mouseWait )
+                                    return
+                            }
+                        mouseTimer = setTimeout ( mouseSequenceEnd, mouseWait )
+            } // listenLeftClick func.
+
+
+
+        function listenRightClick ( event ) {
+                        let targetMax = listenOptions.maxClicks;  // Maximum number of clicks per target
+                        clearTimeout ( mouseTimer )
+                        if ( mouseIgnore ) {
+                                    clearTimeout ( mouseIgnore )
+                                    mouseIgnore = setTimeout ( () => mouseIgnore=null, mouseWait )
+                                    return
+                            }
+                        mouseTarget = _findTarget ( dependencies, state, event.target )
+                        if ( mouseTarget && mouseTarget.dataset.hasOwnProperty('quickClick'))   targetMax = 1
+                        if ( mouseTarget && mouseTarget.tagName === 'A'                     )   targetMax = 1
+                        mouseDomEvent = event
+                        count++
+                        if ( count >= targetMax ) {  
+                                    mouseSequenceEnd ()
+                                    if ( targetMax > 1 )   mouseIgnore = setTimeout ( () => mouseIgnore=null, mouseWait )
+                                    return
+                            }
+                        mouseTimer = setTimeout ( mouseSequenceEnd, mouseWait )
+            } // listenRightClick func.
+
+
+
+            
+        function start () {
+                        if ( state.active  )   return
+                          window.addEventListener ( 'contextmenu', listenRightClick )
+                        document.addEventListener ( 'click'      , listenLeftClick  )
+                        state.active = true
+                } // start func.
+
+        function stop () {
+                        if ( !state.active )   return
+                         window.removeEventListener  ( 'contextmenu', listenRightClick )
+                        document.removeEventListener ( 'click'      , listenLeftClick  )
+                        state.active = false
+                } // stop func.
+                
+        return { start, stop }
+} // _listenDOM func.
+
+
+
+export default _listenDOM
+
+

package/src/plugins/click/_normalizeShortcutName.js

@@ -0,0 +1,44 @@
+'use strict'
+
+function _normalizeShortcutName ( name ) {
+            const 
+                  upperCase = name.toUpperCase ()
+                , regex = /CLICK\s*\:/i
+                , isClickShortcut = regex.test(upperCase)
+                , mouseNames = [ 'LEFT', 'MIDDLE', 'RIGHT' ]
+                , modifiers = [ 'ALT', 'SHIFT', 'CTRL' ]
+                ;   
+            let
+                  btn = null
+                , usedModifiers = []
+                , counter = 0
+                , sliceIndex = upperCase.indexOf ( ':' )
+                ;
+
+            // Click event format: CLICK:LEFT-2-ALT-SHIFT-CTRL
+
+            if ( !isClickShortcut )   return name
+            let shortcutArray = upperCase.slice(sliceIndex+1).trim().split('-').map ( x => x.trim() );
+            shortcutArray.forEach ( item => {
+                        if ( mouseNames.includes ( item )) { 
+                                btn = item
+                                return
+                            }
+                        if ( modifiers.includes ( item )) { 
+                                usedModifiers.push ( item )
+                                return
+                            }
+                        if ( !isNaN ( item )) { 
+                                counter = item
+                                return
+                            }
+                    }) // forEach
+                               
+            return `CLICK:${btn}-${counter}${usedModifiers.length>0?'-':''}${usedModifiers.sort().join('-')}` 
+} // _normalizeShortcutName func.
+
+
+
+export default _normalizeShortcutName
+
+

package/src/plugins/click/_readClickEvent.js

@@ -0,0 +1,24 @@
+'use strict'
+
+function _readClickEvent ( event, count ) {
+    let
+          { shiftKey, altKey, ctrlKey, key, button } = event
+        , mouseNames = [ 'LEFT', 'MIDDLE', 'RIGHT' ]
+        , mouseEvent = `CLICK:${mouseNames[button]}-${count}`
+        , mods = []
+        ;
+    
+    // res.push ( mouseEvent )
+    if ( ctrlKey )   mods.push ( 'CTRL' )
+    if ( shiftKey )  mods.push ( 'SHIFT' )
+    if ( altKey )    mods.push ( 'ALT' )
+
+    if ( mods.length > 0 )   return `${mouseEvent}${mods.length>0?'-':''}${mods.sort().join('-')}`
+    else                     return `${mouseEvent}`
+} // _readClickEvent func.
+
+
+
+export default _readClickEvent
+
+

package/src/plugins/click/_registerShortcutEvents.js

@@ -0,0 +1,30 @@
+'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 isClickEv = regex.test ( shortcutName );
+                if ( !isClickEv ) return
+                count++
+                
+                let [ ,numberClicks ] = shortcutName.slice(6).split('-');
+                if ( listenOptions.maxClicks < numberClicks )   listenOptions.maxClicks = numberClicks
+        })
+return count
+} // _registerShortcutEvents func.
+
+
+
+export default _registerShortcutEvents
+
+