@peter.naydenov/cuts 2.0.1 → 2.0.3

package/test-e2e/node_modules/@peter.naydenov/shortcuts/src/methods/_readShortcutWithPlugins.js

@@ -0,0 +1,32 @@
+'use strict'
+/**
+ * @function _readShortcutWithPlugins
+ * @description Searches for belonging plugin and call the plugin method to normalize the shortcut name.
+ * @param {dependencies} dependencies - Dependencies object containing inAPI
+ * @param {state} state - State object containing plugins
+ * @returns {function} - Returns a function that processes shortcut names
+ */
+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].toLowerCase().trim()
+        , 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/test-e2e/node_modules/@peter.naydenov/shortcuts/src/methods/_setupPlugin.js

@@ -0,0 +1,93 @@
+/**
+ * @function _setupPlugin
+ * @description Setup a plugin with provided settings and dependencies
+ * @param {dependencies} dependencies - Dependencies object containing ev, extra, inAPI, API
+ * @param {state} state - State object containing currentContext, shortcuts, exposeShortcut, ERROR_EVENT_NAME
+ * @returns {function} - Returns a function that takes plugin settings and returns plugin API
+ */
+function _setupPlugin ( dependencies, state ) {
+    
+const { inAPI } = dependencies;
+
+const { 
+          currentContext
+        , shortcuts
+        , exposeShortcut 
+        , ERROR_EVENT_NAME
+    } = state
+
+/**
+ * @function _setupPlugin
+ * @description Setup a plugin with provided settings
+ * @param {Object} settings - Plugin configuration object
+ * @param {string} settings.prefix - Plugin prefix
+ * @param {function} settings._normalizeShortcutName - Normalize shortcut plugin method
+ * @param {function} settings._registerShortcutEvents - Register shortcut plugin method
+ * @param {function} settings._listenDOM - DOM listener plugin method
+ * @param {Object} settings.pluginState - Plugin state object
+ * @param {Object} settings.deps - Plugin dependencies object
+ * @returns {PluginAPI} - Plugin API object with methods
+ */
+return function _setupPlugin ( settings ) {
+    const {
+                   prefix                 // Plugin prefix (string)
+                , _normalizeShortcutName  // Normalize shortcut plugin method (function)
+                , _registerShortcutEvents // Register shortcut plugin method (function)
+                , _listenDOM              // DOM listener plugin method (function)
+
+                , pluginState             // Plugin state (object)
+                , deps                    // Plugin dependencies (object)
+            } = settings
+        , { resetState } = deps  // Reset plugin state (function)
+        ;
+
+    pluginState.currentContext = currentContext
+    pluginState.shortcuts = shortcuts
+    pluginState.exposeShortcut = exposeShortcut
+    pluginState.ERROR_EVENT_NAME = ERROR_EVENT_NAME
+
+    
+    
+    const plugDeps = {
+                ev: dependencies.ev
+              , extra: dependencies.extra
+              , ...deps
+        }
+    
+    // Read shortcuts names from all context entities and normalize entries related to the plugin
+    inAPI._normalizeWithPlugins ( _normalizeShortcutName )
+
+    let countShortcuts = _registerShortcutEvents ( plugDeps, pluginState );
+    const listener     = _listenDOM ( plugDeps, pluginState )   // DOM listener object with 'start' and 'stop' methods
+    if ( countShortcuts > 0 )   listener.start ()
+
+    const pluginAPI = {
+                              getPrefix       : () => prefix
+                            , shortcutName  : key => {   // Format a key string according plugin needs
+                                                        return _normalizeShortcutName ( key )
+                                                }
+                            , contextChange : () => {
+                                                resetState ()
+                                                countShortcuts = _registerShortcutEvents ( plugDeps, pluginState )
+                                                if ( countShortcuts < 1 ) {  // Remove DOM listener if there are no shortcuts in the current context
+                                                                listener.stop ()
+                                                    } 
+                                                if ( countShortcuts > 0 ) {  // Add DOM listener if there are shortcuts in the current context
+                                                                listener.start ()
+                                                    }
+                                        }
+                            , mute    : () => listener.stop ()
+                            , unmute  : () => listener.start ()
+                            , destroy : () => {
+                                                listener.stop ()
+                                                resetState ()
+                                        }
+                        }; // pluginAPI
+    Object.freeze ( pluginAPI )
+    return pluginAPI
+}} // _setupPlugin
+
+
+export default _setupPlugin
+
+

package/test-e2e/node_modules/@peter.naydenov/shortcuts/src/methods/_systemAction.js

@@ -0,0 +1,33 @@
+'use strict'
+
+/**
+ * @function _systemAction
+ * @description Call a specific plugin method.
+ * @param {dependencies} dependencies - Dependencies object containing inAPI
+ * @param {state} state - State object containing plugins array
+ * @returns {function} - Returns a function that executes plugin actions
+ */
+function _systemAction ( dependencies, state ) {
+/**
+ * @function _systemAction
+ * @description Call a specific plugin method.
+ * @param {string} pluginName - The name of the plugin
+ * @param {string} fn - The name of the method to call
+ * @param {any} [params=null] - The parameters to pass to the method
+ * @returns {number} - Index of the plugin in the plugins array (-1 if not found)
+ */
+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/test-e2e/node_modules/@peter.naydenov/shortcuts/src/methods/changeContext.js

@@ -0,0 +1,68 @@
+'use strict'
+
+/**
+ * @function changeContext
+ * @description Change current context with shortcuts belonging to it
+ * @param {dependencies} dependencies - Dependencies object containing ev
+ * @param {state} state - State object containing shortcuts, currentContext, ERROR_EVENT_NAME
+ * @returns {function} - Returns a function that changes context
+ */
+function changeContext ( dependencies, state ) {
+const 
+          { 
+                shortcuts
+              , currentContext
+              , ERROR_EVENT_NAME
+          } = 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
+ * @param {string|boolean} [contextName=false] - Name of context to change to. Default 'false' will switch off all shortcuts
+ * @returns {void}
+ */
+return function changeContext ( contextName = false ) {
+        const current = currentContext.name;
+        
+        if ( !contextName ) {   // Switch off all shortcuts if contextName is not defined
+                        ev.reset () 
+                        // All DOM/Mouse listeners provides trigger signal to notice(the event emitter).
+                        // If event emitter was reset, all DOM/Mouse listener signals will be ignored.
+                        currentContext.name = null
+                        return
+                }
+        if ( current === contextName ) return   // Do nothing if contextName is the same as current
+        if ( !shortcuts [ contextName ] ) {   // If contextName is not defined
+                        ev.emit ( ERROR_EVENT_NAME, `Context '${ contextName }' does not exist` )
+                        return
+                }
+        if ( shortcuts[current] ) {
+                        ev.reset ()   // Disable all shortcuts from current context
+                }
+
+        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
+                        if ( shortcutName.includes (':SETUP') )  return
+                        list.forEach ( fn => ev.on ( shortcutName, fn )    )
+                })
+        expose ()
+}} // changeContext func.
+
+
+
+export default changeContext
+
+

package/test-e2e/node_modules/@peter.naydenov/shortcuts/src/methods/index.js

@@ -0,0 +1,25 @@
+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'
+import changeContext  from './changeContext.js'
+import listShortcuts  from './listShortcuts.js'
+import _setupPlugin   from './_setupPlugin.js'
+
+
+
+export default {
+// Internal methods
+   _normalizeWithPlugins
+ , _readShortcutWithPlugins
+ , _setupPlugin
+ , _systemAction
+    
+// Public methods
+  , changeContext
+  , listShortcuts
+  , load
+  , unload
+}

package/test-e2e/node_modules/@peter.naydenov/shortcuts/src/methods/listShortcuts.js

@@ -0,0 +1,34 @@
+'use strict'
+
+function listShortcuts ( dependencies, state ) {
+const shortcuts = state.shortcuts;
+/**
+ *  @function listShortcuts
+ *  @description List all shortcuts in all contexts or in a specific context
+ *  @param {string|null} [contextName=null] - List of shortcuts for provided context name (optional)
+ *  @returns {string[]|contextShortcuts[]|null} - List of shortcuts for a specified context, list of contextShortcuts for all contexts, or null if context doesn't exist
+ */
+return function listShortcuts ( contextName=null ) {
+    
+    // Create a list of shortcuts for a specific context:
+    if ( contextName != null ) {
+                const context = shortcuts[contextName];
+                if ( context == null )   return null
+                return Object.entries ( context ).map ( ([shortcut, callbacks]) => shortcut )
+        }
+
+    // Create a list of allShortcuts for each context:
+    return  Object.keys ( shortcuts ).map ( contextName => {
+                        const result = {};
+                        result['context'] = contextName
+                        result['shortcuts'] = Object.entries ( shortcuts[contextName] ).map ( ([shortcut, callbacks]) => shortcut   )
+                        return result
+            }) // map
+
+}} // listShortcuts func.
+
+
+
+export default listShortcuts
+
+

package/test-e2e/node_modules/@peter.naydenov/shortcuts/src/methods/load.js

@@ -0,0 +1,58 @@
+'use strict'
+
+/**
+ * @function load
+ * @description Load a context with shortcuts object
+ * @param {dependencies} dependencies - Dependencies object containing API with changeContext and getContext
+ * @param {state} state - State object containing shortcuts and plugins
+ * @returns {function} - Returns a function that loads shortcuts
+ */
+function load ( dependencies, state ) {
+const 
+          { shortcuts, plugins } = state
+        , {
+                API : { changeContext, getContext }
+          } = dependencies;
+/**
+ * @function load
+ * @description Load a context with shortcuts object
+ * @param {Object} shortcutsUpdate - Context description object: { contextName : { shortcut : callback[] } }
+ * @returns {void}
+ */
+return function load ( shortcutsUpdate ) {
+    const
+           currentContextName = getContext ()
+         , pluginPrefixList = plugins.map ( plugin => plugin.getPrefix().toUpperCase()   )
+         ;
+    let hasChanges = false;
+    
+    Object.entries ( shortcutsUpdate ).forEach ( ([contextName, contextShortcuts]) => {
+                    // If changes in current context will need to reload it
+                    if ( contextName === currentContextName ) hasChanges = true;
+                    shortcuts [ contextName ] = {}
+
+                    Object.entries ( contextShortcuts ).forEach ( ([ title, payload ]) => {
+                                    let 
+                                          name = title
+                                        ; const test = title.toUpperCase().trim()
+                                        
+                                    const pluginIndexList = pluginPrefixList.map ( (prefix,i) => test.startsWith ( prefix ) ? i : null ).filter ( i => i !== null );
+                                    if ( pluginIndexList.length ) {
+                                                const id = pluginIndexList[0];
+                                                name = plugins[id].shortcutName ( title )
+                                        }
+                                    if ( payload instanceof Function ) payload = [ payload ]
+                                    shortcuts [contextName][ name ] = payload
+                            }) // contextShortcuts.forEach
+        }) // shortcutsUpdate.forEach
+     if ( hasChanges ) {  // Reload context shortcuts after loading process if context was active
+                changeContext ()
+                changeContext ( currentContextName )
+        }
+}} // load func.
+
+
+
+export default load
+
+

package/test-e2e/node_modules/@peter.naydenov/shortcuts/src/methods/unload.js

@@ -0,0 +1,38 @@
+'use strict'
+
+/**
+ * @function unload
+ * @description Unload a non-active context with shortcuts
+ * @param {dependencies} dependencies - Dependencies object containing ev
+ * @param {state} state - State object containing currentContext, shortcuts, ERROR_EVENT_NAME
+ * @returns {function} - Returns a function that unloads contexts
+ */
+function unload ( dependencies, state ) {
+const 
+     { currentContext, shortcuts, ERROR_EVENT_NAME } = state
+   , { ev } = dependencies
+   ;
+/**
+ * @function unload
+ * @description Unload a non-active context with shortcuts
+ * @param {string} contextName - Context name to unload
+ * @returns {void}
+ */
+return function unload ( contextName ) {
+        const current = currentContext.name;
+        if ( current === contextName ) {
+                    ev.emit ( ERROR_EVENT_NAME, `Context '${ contextName }' can't be removed during is current active context. Change the context first` )
+                    return
+            }
+        if ( !shortcuts [ contextName ] ) {
+                    ev.emit ( ERROR_EVENT_NAME, `Context '${ contextName }' does not exist` )
+                    return
+            }
+        delete shortcuts [ contextName ]
+}} // unload func.
+
+
+
+export default unload
+
+

package/test-e2e/node_modules/@peter.naydenov/shortcuts/src/plugins/click/_findTarget.js

@@ -0,0 +1,26 @@
+'use strict'
+
+/**
+ * @function _findTarget
+ * @description Find the appropriate click target element by checking if element has any of the target attributes
+ * @param {Object} dependencies - Dependencies object
+ * @param {Object} state - Plugin state containing listenOptions with clickTarget array
+ * @param {Element} target - DOM element to start searching from
+ * @returns {Element|null} - Target element or null if not found
+ */
+function _findTarget ( dependencies, state, target ) {
+    const { listenOptions : {clickTarget}} = state;
+
+    const t = target;
+    if ( t === document.body )   return null
+
+    const found = clickTarget.some ( attr => ( t.hasAttribute ( attr ) ) )
+    if ( found ) return t
+    return   _findTarget ( dependencies, state, t.parentNode ) 
+} // _findTarget func.
+
+
+
+export default _findTarget
+
+

package/test-e2e/node_modules/@peter.naydenov/shortcuts/src/plugins/click/_listenDOM.js

@@ -0,0 +1,165 @@
+'use strict'
+
+
+/**
+ * @function _listenDOM
+ * @description Set up DOM event listeners for click events
+ * @param {Object} dependencies - Dependencies object containing ev, _findTarget, _readClickEvent, extra, resetState
+ * @param {Object} state - Plugin state containing listenOptions and currentContext
+ * @returns {Object} - Object containing start and stop methods
+ * 
+ * @typedef {Object} ClickEventData
+ * @property {Element} target - The DOM element that was clicked
+ * @property {number} x - X coordinate of the click event
+ * @property {number} y - Y coordinate of the click event
+ * @property {string} context - Current context name
+ * @property {string|null} note - Current context note
+ * @property {Object} options - Plugin state listenOptions (reference to pluginState.listenOptions)
+ * @property {Event} event - The original DOM event
+ * @property {Object} dependencies - Extra dependencies object
+ * @property {Object} viewport - Viewport information with X, Y, width, height
+ * @property {Object} sizes - Element dimensions with width, height
+ * @property {Object} position - Element position relative to viewport with x, y
+ * @property {Object} pagePosition - Element position relative to page with x, y
+ * @property {string} type - Event type ('click')
+ */
+function _listenDOM ( dependencies, state ) {
+        const { 
+                   ev
+                , _findTarget 
+                , _readClickEvent
+                , extra
+                        } = dependencies
+        const { listenOptions, currentContext } = state
+
+        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
+                        if ( !mouseTarget ) return  // No valid target found                        
+                        const 
+                                { left, top, width, height } = mouseTarget.getBoundingClientRect ()
+                              , scrollX = window.scrollX
+                              , scrollY = window.scrollY
+                              ;
+                        
+                        const
+                                  mouseEvent = _readClickEvent ( mouseDomEvent, count )
+                                , data = {
+                                          target : mouseTarget
+                                        , x       : mouseDomEvent.clientX
+                                        , y       : mouseDomEvent.clientY
+                                        , context : currentContext.name
+                                        , note    : currentContext.note
+                                        , options : state.listenOptions
+                                        , event   : mouseDomEvent
+                                        , dependencies : extra
+                                        , viewport : {                                    // Viewport scroll positions and sizes
+                                                          X:scrollX
+                                                        , Y:scrollY 
+                                                        , width:window.innerWidth
+                                                        , height:window.innerHeight
+                                                }
+                                        , sizes    : { width, height }                     // Element sizes
+                                        , position : { x:left, y:top }                     // Position relative to viewport
+                                        , pagePosition : { x:left+scrollX, y:top+scrollY } // Position relative to page
+                                        , type   : 'click'
+                                }
+                                ;
+
+                        ev.emit ( mouseEvent, data )
+                        // Reset:
+                        mouseTimer = null
+                        mouseIgnore = null  // Timeout timer or null. Ignore mouse clicks until timer expires
+                        mouseTarget = null
+                        mouseDomEvent = null
+                        count = 0
+                } // mouseSequenceEnd func.
+
+
+
+        function listenLeftClick ( event ) {
+                        let targetMax = state.maxLeftClicks;  // Maximum number of clicks per target
+                        clearTimeout ( mouseTimer )
+                        if ( mouseIgnore ) {
+                                    clearTimeout ( mouseIgnore )
+                                    mouseIgnore = setTimeout ( () => mouseIgnore=null, listenOptions.mouseWait )
+                                    return
+                            }
+                        mouseTarget = _findTarget ( dependencies, state, event.target )
+                        if ( mouseTarget == null )   return
+                        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, listenOptions.mouseWait )
+                                    return
+                            }
+                        mouseTimer = setTimeout ( mouseSequenceEnd, listenOptions.mouseWait )
+            } // listenLeftClick func.
+
+
+
+        function listenRightClick ( event ) {
+                        let targetMax = state.maxRightClicks;  // Maximum number of clicks per target
+                        clearTimeout ( mouseTimer )
+                        if ( mouseIgnore ) {
+                                    clearTimeout ( mouseIgnore )
+                                    mouseIgnore = setTimeout ( () => mouseIgnore=null, listenOptions.mouseWait )
+                                    return
+                            }
+                        mouseTarget = _findTarget ( dependencies, state, event.target )
+                        if ( mouseTarget == null )   return
+                        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, listenOptions.mouseWait )
+                                    return
+                            }
+                        mouseTimer = setTimeout ( mouseSequenceEnd, listenOptions.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
+                        
+                        if ( mouseIgnore ) {
+                                clearTimeout ( mouseIgnore )
+                                mouseIgnore = null
+                            }
+                        // Reset all state variables to prevent pollution between tests
+                        mouseTarget = null
+                        mouseDomEvent = null
+                        count = 0
+                } // stop func.
+                
+        return { start, stop }
+} // _listenDOM func.
+
+
+
+export default _listenDOM
+
+

package/test-e2e/node_modules/@peter.naydenov/shortcuts/src/plugins/click/_normalizeShortcutName.js

@@ -0,0 +1,51 @@
+'use strict'
+
+/**
+ * @function _normalizeShortcutName
+ * @description Normalize click shortcut name to standard format
+ * @param {string} name - Raw shortcut name
+ * @returns {string} - Normalized shortcut name
+ */
+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
+                , counter = 0
+                ; const usedModifiers = []
+                , sliceIndex = upperCase.indexOf ( ':' )
+                ;
+
+            // Click event format: CLICK:LEFT-2-ALT-SHIFT-CTRL
+
+            if ( !isClickShortcut            )   return name
+            if ( upperCase.includes('SETUP') )   return 'CLICK:SETUP'
+            const 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/test-e2e/node_modules/@peter.naydenov/shortcuts/src/plugins/click/_readClickEvent.js

@@ -0,0 +1,24 @@
+'use strict'
+
+function _readClickEvent ( event, count ) {
+    const
+          { 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
+
+