@peter.naydenov/cuts 2.0.1 → 2.0.3

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

@@ -0,0 +1,58 @@
+'use strict'
+
+/**
+ * @function _registerShortcutEvents
+ * @description Register click shortcut events and handle setup
+ * @param {Object} dependencies - Dependencies object containing regex
+ * @param {Object} pluginState - Plugin state containing listenOptions, currentContext, shortcuts, etc.
+ * @returns {number} - Number of registered shortcuts
+ * 
+ * @typedef {Object} ClickSetupData
+ * @property {Object} dependencies - Extra dependencies object
+ * @property {Object} defaults - Default options (clone of pluginState.defaultOptions)
+ * @property {Object} options - Plugin state listenOptions (reference to pluginState.listenOptions)
+ */
+function _registerShortcutEvents ( dependencies, pluginState ) {
+let count = 0;
+let hasSetup = false;
+const df = pluginState.defaultOptions;
+const 
+          { regex } = dependencies
+        , { 
+                  listenOptions
+                , currentContext : { name:contextName }
+                , shortcuts 
+            } = pluginState
+        ;
+
+if ( contextName == null )   return count
+Object.entries ( shortcuts[contextName] ).forEach ( ([shortcutName, list ]) => {   // Enable new context shortcuts and set a listenOptions 'maxSequence'      
+                const isClickEv = regex.test ( shortcutName );
+                if ( !isClickEv ) return
+                if ( shortcutName === 'CLICK:SETUP' ) {
+                                hasSetup = true
+                                const updateOptions = list.reduce ( ( res, fn ) => {
+                                                const r = fn ({ 
+                                                                dependencies : dependencies.extra, 
+                                                                defaults     : structuredClone(pluginState.defaultOptions),
+                                                                options      : listenOptions 
+                                                        })
+                                                return Object.assign ( res, r )
+                                        }, df )
+                                Object.assign ( pluginState.listenOptions, updateOptions )
+                                return
+                    }
+                count++
+                const [ button,numberClicks ] = shortcutName.slice(6).split('-');
+                if ( button === 'LEFT'  && pluginState.maxLeftClicks < numberClicks  )   pluginState.maxLeftClicks = numberClicks
+                if ( button === 'RIGHT' && pluginState.maxRightClicks < numberClicks )   pluginState.maxRightClicks = numberClicks
+        })
+if ( !hasSetup )   Object.assign ( pluginState.listenOptions, df )
+return count
+} // _registerShortcutEvents func.
+
+
+
+export default _registerShortcutEvents
+
+

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

@@ -0,0 +1,67 @@
+'use strict'
+
+
+
+import _findTarget              from "./_findTarget"
+import _listenDOM              from "./_listenDOM"
+import _normalizeShortcutName  from "./_normalizeShortcutName"
+import _readClickEvent         from "./_readClickEvent"
+import _registerShortcutEvents from "./_registerShortcutEvents"
+
+
+
+
+/**
+ * @function pluginClick
+ * @description Plugin for mouse click shortcuts
+ * @param {function} setupPlugin - Plugin setup function from the library
+ * @param {Object} [options={}] - Plugin options
+ * @param {number} [options.mouseWait=320] - Time to wait for click sequence in ms
+ * @param {string[]} [options.clickTarget=['data-click', 'href']] - Array of attribute names for click targets
+ * @param {function} [options.streamKeys] - Function to stream key presses
+ * @returns {PluginAPI} Plugin API
+ */
+function pluginClick ( setupPlugin, options = {}) {
+        const 
+                  deps = {
+                                _findTarget
+                             , _readClickEvent
+                             , regex : /CLICK\s*\:/i
+                        }
+                , pluginState = {
+                                  active : false
+                                , maxLeftClicks : 1  // How many clicks can be pressed in a sequence. Controlled automatically by '_registerShortcutEvents' function.
+                                , maxRightClicks: 1  // How many right clicks can be pressed in a sequence. Controlled automatically by '_registerShortcutEvents' function.
+                                , defaultOptions : {
+                                          mouseWait   : 320     // 320 ms
+                                        , clickTarget : ['data-click', 'href' ]   // Attribute names as click targets
+                                    }
+                                , listenOptions  : {
+                                                      mouseWait     : 320   // 320 ms
+                                                    , clickTarget   : [ 'data-click', 'href' ]  // Attribute names as click targets
+                                                }
+                                , streamKeys     : (options.streamKeys && ( typeof options.streamKeys === 'function')) ? options.streamKeys : false   // Keyboard stream function
+                            } // pluginState
+                ;
+
+        function resetState () {
+                  // TODO: No reset available at the moment
+            } // resetState func.
+        deps.resetState = resetState
+                
+        return setupPlugin ({
+                                prefix: 'click'
+                              , _normalizeShortcutName
+                              , _registerShortcutEvents
+                              , _listenDOM
+
+                              , pluginState
+                              , deps
+                      })
+} // pluginClick func.
+
+
+
+export default pluginClick
+
+

package/test-e2e/node_modules/@peter.naydenov/shortcuts/src/plugins/form/_defaults.js

@@ -0,0 +1,28 @@
+/**
+ * @typedef {Object} _defaults
+ * @property {function} watch - Function that returns CSS selector for form elements to watch
+ * @property {function} define - Function that determines the type of form element
+ */
+
+/**
+ * @const {_defaults}
+ * @description Default configuration for form plugin
+ */
+const _defaults = {
+      watch : () => 'input, select, textarea, button, a'
+    , define: ({ target }) => {
+            if ( target.type === 'checkbox' || target.type === 'radio' ) {
+                    return 'checkbox'
+                }
+            if ( target.type == 'button' || target.type=='submit' ) {
+                    return 'button'
+                }
+            return 'input'
+        } // define
+} // defaults
+
+
+
+export default _defaults
+
+

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

@@ -0,0 +1,127 @@
+'use strict'
+
+
+
+/**
+ * @function _listenDOM
+ * @description Set up DOM event listeners for form events
+ * @param {Object} dependencies - Dependencies object containing ev
+ * @param {Object} state - Plugin state containing listenOptions and currentContext
+ * @returns {Object} - Object containing start and stop methods
+ * 
+ * @typedef {Object} FormEventData
+ * @property {Element} target - The DOM element that triggered the form event
+ * @property {string} context - Current context name
+ * @property {string|null} note - Current context note
+ * @property {Event} event - The original DOM event
+ * @property {Object} dependencies - Extra dependencies object
+ * @property {Object} options - Plugin state listenOptions (reference to pluginState.listenOptions)
+ * @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 ('form-in', 'form-out', 'form-instant')
+ */
+function _listenDOM ( dependencies, state ) {
+        const { ev } = dependencies;
+        let timeout = null; 
+
+        function setupData ( dependencies, state, event, type) {
+                const 
+                      { left, top, width, height } = event.target.getBoundingClientRect ()
+                    , scrollX = window.scrollX
+                    , scrollY = window.scrollY
+                    ;
+                return {
+                          target : event.target
+                        , context : state.currentContext.name
+                        , note    : state.currentContext.note
+                        , event   
+                        , dependencies : dependencies.extra
+                        , options : state.listenOptions
+                        , 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
+                    }
+        } // setupData func.
+
+        function listenFocusIn ( event ) { // Timing: in
+                const 
+                      { callbacks, typeFn } = state
+                    , target = event.target
+                    , prop = setupData ( dependencies, state, event, "form-in" )
+                    , type = typeFn ( prop )
+                    , key = `${type}/in`
+                    ;
+                if ( callbacks[key] == null )  return
+                ev.emit ( key, prop, callbacks[key] )
+           } // focusIn func.
+
+        function listenFocusOut ( event ) {  // Timing: out
+                const
+                      { callbacks, typeFn } = state
+                    , prop   = setupData ( dependencies, state, event, "form-out" )
+                    , type   = typeFn ( prop )
+                    , key    = `${type}/out`
+                    ;
+                if ( callbacks[key] == null )  return
+                ev.emit ( key,  prop, callbacks[key] )
+            } // focusOut func.
+
+
+        function listenInput ( event ) {   // Timing: instant
+                const 
+                      { callbacks, typeFn } = state
+                    , prop   = setupData ( dependencies, state, event, "form-instant" )
+                    , type   = typeFn ( prop )
+                    , wait   = state.wait[`${type}`]
+                    , key    = `${type}/instant`
+                    ;
+                if ( callbacks[key] == null )  return
+                if ( wait === 0 ) {
+                        ev.emit ( key, prop, callbacks[key] )
+                        return
+                    }
+                const fn = () => ev.emit ( key, prop, callbacks[key] )
+                clearTimeout ( timeout )
+                timeout = setTimeout ( fn, wait )
+            } // input func.
+
+
+        function start () {
+                if ( state.active )  return
+                document.addEventListener ( 'focusin', listenFocusIn );
+                document.addEventListener ( 'focusout', listenFocusOut );
+                document.addEventListener ( 'input', listenInput );
+                state.active = true
+            } // start func.
+
+
+        function stop () {
+                if ( !state.active ) return
+                document.removeEventListener ( 'focusin', listenFocusIn );
+                document.removeEventListener ( 'focusout', listenFocusOut );
+                document.removeEventListener ( 'input', listenInput );
+                state.active = false
+                // Clear any pending timeout to prevent state pollution between tests
+                if ( timeout ) {
+                        clearTimeout ( timeout )
+                        timeout = null
+                }
+            } // stop func.
+
+        return { start, stop }
+} // _listenDOM func.
+
+
+
+export default _listenDOM
+
+

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

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

package/test-e2e/node_modules/@peter.naydenov/shortcuts/src/plugins/form/_registerShortcutEvents.js

@@ -0,0 +1,147 @@
+'use strict'
+
+/**
+ * @function _registerShortcutEvents
+ * @description Register form shortcut events and handle setup
+ * @param {Object} dependencies - Dependencies object containing regex, _defaults, ev
+ * @param {Object} pluginState - Plugin state containing currentContext, shortcuts, callbacks, etc.
+ * @returns {number|false} - Number of registered shortcuts or false if no actions
+ * 
+ * @typedef {Object} FormWatchData
+ * @property {Object} dependencies - Extra dependencies object
+ * @property {string} context - Current context name
+ * @property {string|null} note - Current context note
+ * @property {Object} options - Plugin state listenOptions (reference to pluginState.listenOptions)
+ * 
+ * @typedef {Object} FormDefineData
+ * @property {Element} target - The DOM element being watched
+ * @property {string} context - Current context name
+ * @property {string|null} note - Current context note
+ * @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 {Object} options - Plugin state listenOptions (reference to pluginState.listenOptions)
+ * 
+ * @typedef {Object} FormActionData
+ * @property {Object} dependencies - Extra dependencies object
+ * @property {Object} options - Plugin state listenOptions (reference to pluginState.listenOptions)
+ */
+function _registerShortcutEvents ( dependencies, pluginState ) {
+const 
+          { regex, _defaults, ev } = dependencies
+        , { 
+                  currentContext : { name: contextName, note }
+                , shortcuts 
+                , callbacks
+                , ERROR_EVENT_NAME
+                , defaultOptions 
+           } = pluginState
+        ;
+        let watch=[], define=[], action=[], count = 0;
+        if ( contextName == null )   return false
+        Object.entries ( shortcuts[contextName] ).forEach ( ([shortcutName, list ]) => {   
+                        const isFormEv = regex.test ( shortcutName );
+                        if ( !isFormEv ) return
+                        if ( shortcutName.includes('SETUP' )) {
+                                        const updateOptions = list.reduce ( ( res, fn ) => {
+                                                        const r = fn ({ 
+                                                                        dependencies : dependencies.extra, 
+                                                                        defaults     : structuredClone ( pluginState.defaultOptions ),
+                                                                        options      : pluginState.listenOptions
+                                                                })
+                                                        return Object.assign ( res, r )
+                                                }, defaultOptions )
+                                        Object.assign ( pluginState.listenOptions, updateOptions )
+                                        return
+                                } 
+                        if ( shortcutName === 'FORM:WATCH' )    watch = list
+                        if ( shortcutName === 'FORM:DEFINE' )   define = list
+                        if ( shortcutName === 'FORM:ACTION' )   action = list
+                        
+                })
+        
+        if ( action.length === 0 )   return count
+   
+        const setTypes = new Set ();
+        if ( define.length === 0 )  define = [ _defaults.define ]
+        if ( watch.length === 0  )  watch  = [ _defaults.watch ] 
+        const watchList = watch.map ( el => el ({ 
+                                                  dependencies : dependencies.extra 
+                                                , context : contextName 
+                                                , note
+                                                , options : pluginState.listenOptions
+                                        })   )
+                                        .reduce ( ( res, el) => {
+                                                res.push ( el ) 
+                                                return res
+                                        }, [])
+        pluginState.watchList = document.querySelectorAll ( watchList )
+        pluginState.watchList.forEach ( el => {
+                                        const 
+                                                  { left, top, width, height } = el.getBoundingClientRect ()
+                                                , scrollX = window.scrollX
+                                                , scrollY = window.scrollY
+                                                ;
+                                        return setTypes.add ( define[0]({
+                                                                  target : el
+                                                                , context : contextName
+                                                                , note
+                                                                , dependencies : dependencies.extra
+                                                                , options : pluginState.listenOptions
+                                                                , viewport : {
+                                                                                X: scrollX
+                                                                              , Y: scrollY
+                                                                              , width: window.innerWidth
+                                                                              , height: window.innerHeight
+                                                                        }
+                                                                , sizes : { width , height }
+                                                                , position : { x:left, y:top }
+                                                                , pagePosition : { x:left+scrollX, y:top+scrollY }
+                                                                }) 
+                                                ) // setTypes
+                        }) // forEach watchList 
+
+        pluginState.typeFn = define[0] ? define[0] : _defaults.define
+     
+        action.forEach ( act => {
+                        if ( !(act instanceof Function)) {  
+                                ev.emit ( ERROR_EVENT_NAME, `The 'form:action' should be a function.` )
+                                return false
+                           }
+                        
+                        const list = act ({ 
+                                 dependencies : dependencies.extra,
+                                 options      : pluginState.listenOptions
+                         })
+                        
+                        if ( !(list instanceof Array) ) {
+                                ev.emit ( ERROR_EVENT_NAME, `Warning: The 'form:action' function should RETURN an array.` )
+                                return false
+                           }
+                        list.forEach ( ({fn, type, timing, wait=0 }) => {
+                                        if ( setTypes.has ( type) && fn instanceof Function ) {
+                                                const key = `${type}/${timing}`
+                                                const hasProperty = callbacks.hasOwnProperty ( key );
+                                                hasProperty ? 
+                                                                callbacks[key].push ( fn ) :
+                                                                callbacks[key] = [ fn ]
+                                                if ( !hasProperty ) {
+                                                                ev.on ( key, ( props, callbacks ) => {   // Register the 'type/timing' as an event
+                                                                                callbacks.forEach ( cb => { if ( cb instanceof Function )   cb ( props )   })
+                                                                        }) 
+                                                        }  
+                                        } // if function
+                                        if ( timing === 'instant' )   pluginState.wait[`${type}`] = wait
+                                }) // for each act
+                }) // for each action
+        count = Object.keys ( pluginState.callbacks ).length
+        return count
+} // _registerShortcutEvents func.
+
+
+
+export default _registerShortcutEvents
+
+

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

@@ -0,0 +1,58 @@
+'use strict'
+
+
+
+// import all plugin files here
+import _listenDOM from './_listenDOM.js'
+import _normalizeShortcutName from './_normalizeShortcutName.js'
+import _registerShortcutEvents from './_registerShortcutEvents.js'
+import _defaults from './_defaults.js'
+
+
+
+/**
+ * @function pluginForm
+ * @description Plugin for form element shortcuts
+ * @param {function} setupPlugin - Plugin setup function from the library
+ * @param {Object} [options={}] - Plugin options
+ * @returns {PluginAPI} Plugin API
+ */
+function pluginForm ( setupPlugin, options={} ) {
+
+    const 
+                 deps = {
+                               _defaults
+                             , regex : /FORM\s*\:/i
+                        }
+                , pluginState = {
+                                  callbacks      : {} // Functions callbacks arranged by 'type/timing' : [ callback, ...otherCallbacks ]
+                                , typeFn         : '' // Type definition function
+                                , watchList      : [] // list of watched elements
+                                , wait           : {} // wait time for 'instant' mode. Define by 'type'. 
+                                                      // Example: { 'input': 200 }, will update from 'input' type every 200ms
+                                                      // where 'input' is type received by 'define' function
+                                , defaultOptions : {}
+                                , listenOptions  : {}
+                            } // pluginState
+                ;
+    function resetState () {
+            pluginState.callbacks = {}
+            pluginState.typeFn    = ''
+            pluginState.watchList = []
+            pluginState.wait      = {}
+      } // resetState func.
+    deps.resetState = resetState
+
+    return setupPlugin ({
+                        prefix : 'form'
+                      , _normalizeShortcutName
+                      , _registerShortcutEvents
+                      , _listenDOM
+                      
+                      , pluginState
+                      , deps
+                  })
+} // pluginForm func.
+
+
+export default pluginForm

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

@@ -0,0 +1,26 @@
+'use strict'
+
+/**
+ * @function _findTarget
+ * @description Find the appropriate hover 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 hoverTarget array
+ * @param {Element} target - DOM element to start searching from
+ * @returns {Element|false} - Target element or false if not found
+ */
+function _findTarget ( dependencies, state, target ) {
+    const { listenOptions : {hoverTarget}} = state;
+
+    const t = target;
+    if ( t === document.body )   return false
+    if ( t === document      )   return false
+    const found = hoverTarget.some ( attr => ( t.hasAttribute ( attr ) ) )
+    if ( found ) return t
+    return   _findTarget ( dependencies, state, t.parentNode ) 
+} // _findTarget func.
+
+
+
+export default _findTarget
+
+