@peter.naydenov/cuts 2.0.2 → 2.0.3

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

@@ -0,0 +1,67 @@
+'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
+ * @description Plugin for keyboard shortcuts
+ * @param {function} setupPlugin - Plugin setup function from the library
+ * @param {Object} [options={}] - Plugin options
+ * @param {number} [options.keyWait=480] - Time to wait for key sequence in ms
+ * @param {function} [options.streamKeys] - Function to stream key presses
+ * @returns {PluginAPI} Plugin API
+ */
+function pluginKey ( setupPlugin, options = {} ) {
+        const 
+                  deps = {
+                               _specialChars
+                             , _readKeyEvent
+                             , regex : /KEY\s*\:/i
+                        }
+                , pluginState = {
+                            active : false
+                          , 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.
+                          , defaultOptions : {
+                                        keyWait : 480 // 480 ms
+                                } 
+                          , listenOptions  : {
+                                        // Filled from 'key: setup' event in the context
+                                        // or getting from the plugin the defaults
+                                        keyWait : 480 // 480 ms // TODO: WHY is need initialization? Register function should fullfill it
+                                }
+                          , streamKeys     : (options.streamKeys && ( typeof options.streamKeys === 'function')) ? options.streamKeys : false   // Keyboard stream function
+                        } // state
+                ;
+        
+        function resetState () {
+                    pluginState.active = false
+                    pluginState.keyIgnore = null
+                    pluginState.maxSequence = 1
+            } // resetState func.
+        deps.resetState = resetState
+
+        return setupPlugin ( {
+                                prefix : 'key'
+                              , _normalizeShortcutName  
+                              , _registerShortcutEvents 
+                              , _listenDOM              
+                              , pluginState          
+                              , deps                    
+                        })
+} // pluginKey func.
+
+
+
+export default pluginKey
+
+

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

@@ -0,0 +1,141 @@
+
+
+/**
+ * @function _listenDOM
+ * @description Set up DOM event listeners for scroll events
+ * @param {Object} dependencies - Dependencies object containing ev, resetState, extra
+ * @param {Object} state - Plugin state containing listenOptions and currentContext
+ * @returns {Object} - Object containing start and stop methods
+ * 
+ * @typedef {Object} ScrollEventData
+ * @property {number} x - Current scroll X position
+ * @property {number} y - Current scroll Y position
+ * @property {string} direction - Scroll direction ('up', 'down', 'left', 'right')
+ * @property {string} context - Current context name
+ * @property {string|null} note - Current context note
+ * @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 {string} type - Event type ('scroll')
+ */
+function _listenDOM ( dependencies, state ) {
+    const { 
+              ev
+            , resetState
+            , extra 
+          } = dependencies;
+    let 
+          waitForScroll = null    // Timeout for reducing scroll events 
+        , waitForEndScroll = null // Timeout for setting scroll end event
+        ;
+
+function listenForScroll ( event ) {
+        const
+              x = event.clientX
+            , y = event.clientY
+            , {
+                    lastPosition
+                  , lastDirection
+                  , listenOptions
+                  , currentContext
+                } = state
+            , {
+                      scrollWait
+                    , endScrollWait
+                    , minSpace
+                } = listenOptions
+            ;
+
+        
+
+        if ( !lastPosition ) return; // No previous position to compare
+
+        let direction = null;
+        const
+              currentX = window.scrollX
+            , currentY = window.scrollY
+            , verticalChange   = Math.abs ( currentY - lastPosition.y )
+            , horizontalChange = Math.abs ( currentX - lastPosition.x )
+            ;
+
+        // Reduce scroll events by space
+        if ( verticalChange < minSpace && horizontalChange < minSpace )   return
+        
+        const directions = [];
+        
+        // Check vertical scroll
+        if ( verticalChange >= minSpace ) {
+                if ( currentY > lastPosition.y )   directions.push('down')
+                else                               directions.push('up')
+        }
+        
+        // Check horizontal scroll
+        if ( horizontalChange >= minSpace ) {
+                if ( currentX > lastPosition.x )   directions.push('right')
+                else                               directions.push('left')
+        }
+        
+        // Use first direction for single direction compatibility
+        direction = directions[0] || null;
+
+        const getData = (dir) => ({
+                          x: currentX
+                        , y: currentY
+                        , direction: dir
+                        , context: currentContext.name
+                        , note: currentContext.note
+                        , dependencies: extra
+                        , options: state.listenOptions
+                        , viewport : {                // Viewport scroll positions and sizes
+                                  X: currentX
+                                , Y: currentY
+                                , width: window.innerWidth
+                                , height: window.innerHeight
+                            }
+                        , type: 'scroll'
+                })
+
+        // Emit events for each direction detected
+        directions.forEach(dir => {
+                        const signal = `SCROLL:${dir.toUpperCase()}`
+                        ev.emit ( signal, getData(dir) )
+                })
+        
+        // Set up end scroll timeout (only once)
+        clearTimeout ( waitForScroll )
+        clearTimeout ( waitForEndScroll )
+        const finalDirection = directions[directions.length - 1] || null
+        waitForScroll    = setTimeout ( () => {}, scrollWait ) // Keep for compatibility
+        waitForEndScroll = setTimeout ( () => ev.emit ( 'SCROLL:END', getData(finalDirection) ), endScrollWait )
+
+        // Update last position
+        state.lastPosition = { x: currentX, y: currentY }
+        state.lastDirection = direction
+
+    } // listenForScroll func.
+
+
+function start () {
+        if ( state.active ) return
+        // Initialize last position
+        state.lastPosition = { x: window.scrollX, y: window.scrollY }
+        window.addEventListener ( 'scroll' , listenForScroll )
+        state.active = true
+    }
+
+
+function stop () {
+        if ( !state.active ) return
+        window.removeEventListener ( 'scroll' , listenForScroll )
+        resetState ()
+    }
+
+return { start, stop }
+
+} // _listenDOM func.
+
+
+
+export default _listenDOM
+
+

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

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

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

@@ -0,0 +1,50 @@
+/**
+ * @function _registerShortcutEvents
+ * @description Register scroll shortcut events and handle setup
+ * @param {Object} dependencies - Dependencies object containing regex
+ * @param {Object} pluginState - Plugin state containing currentContext, shortcuts
+ * @returns {number} - Number of registered shortcuts
+ * 
+ * @typedef {Object} ScrollSetupData
+ * @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
+        , {
+                  currentContext : { name: contextName }
+                , shortcuts
+           } = pluginState
+        ;
+    if ( contextName == null )   return count   // No context
+    Object.entries ( shortcuts[contextName] ).forEach ( ([shortcutName, list ]) => {
+                        const isScrollEv = regex.test ( shortcutName );
+                        if ( !isScrollEv ) return
+                        if ( shortcutName === 'SCROLL:SETUP' ) {
+                                      hasSetup = true
+                                      const updateOptions = list.reduce ( ( res, fn ) => {
+                                                      const r = fn ({ 
+                                                                      dependencies : dependencies.extra, 
+                                                                      defaults     : structuredClone(pluginState.defaultOptions),
+                                                                      options      : pluginState.listenOptions 
+                                                              })
+                                                      return Object.assign ( res, r )
+                                              }, df )
+                                      Object.assign ( pluginState.listenOptions, updateOptions )
+                                      return
+                              }
+                        count++
+                })
+    if ( !hasSetup )   Object.assign ( pluginState.listenOptions, df )
+    return count
+} // _registerShortcutEvents func.
+
+
+export default _registerShortcutEvents
+
+

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

@@ -0,0 +1,61 @@
+'use strict'
+
+import _listenDOM from "./_listenDOM"
+import _normalizeShortcutName from "./_normalizeShortcutName"
+import _registerShortcutEvents from "./_registerShortcutEvents"
+
+
+
+/**
+ * @function pluginScroll
+ * @description Plugin for scroll event shortcuts
+ * @param {function} setupPlugin - Plugin setup function from the library
+ * @param {Object} [options={}] - Plugin options
+ * @param {number} [options.scrollWait=50] - Delay between scroll events in ms
+ * @param {number} [options.endScrollWait=400] - Delay when scroll was stopped in ms
+ * @param {number} [options.minSpace=40] - Minimum distance between scroll events in px
+ * @returns {PluginAPI} Plugin API
+ */
+function pluginScroll ( setupPlugin, options={} ) {
+    // up, down, left, right
+        const 
+                 deps = {
+                          regex : /SCROLL\s*\:/i
+                        }
+                , pluginState = {
+                                  active : false        // Is plugin active?
+                                , lastPosition  : null  // Last scroll position
+                                , lastDirection : null  // Last scroll direction
+                                , defaultOptions : {
+                                                scrollWait    : 50  // 50 ms. Delay between scroll events 
+                                              , endScrollWait : 400 // 400 ms. When scroll was stopped.
+                                              , minSpace      : 40  // 40 px. Minimum distance between scroll events
+                                    }
+                                , listenOptions  : {
+                                                scrollWait    : 50  // 50 ms. Delay between scroll events 
+                                              , endScrollWait : 400 // 400 ms. When scroll was stopped.
+                                              , minSpace      : 40  // 40 px. Minimum distance between scroll events
+                                        }
+                            } // pluginState
+                ;
+        
+        function resetState () {
+                        pluginState.active = false
+            } // resetState func.
+        deps.resetState = resetState
+
+        return setupPlugin ( {
+                                  prefix : 'scroll'
+                                , _normalizeShortcutName
+                                , _registerShortcutEvents
+                                , _listenDOM
+                                , pluginState
+                                , deps
+                        })
+} // pluginScroll func.
+
+
+
+export default pluginScroll
+
+

package/test-e2e/node_modules/@peter.naydenov/shortcuts/style.css

@@ -0,0 +1,97 @@
+:root {
+  font-family: Inter, system-ui, Avenir, Helvetica, Arial, sans-serif;
+  line-height: 1.5;
+  font-weight: 400;
+
+  color-scheme: light dark;
+  color: rgba(255, 255, 255, 0.87);
+  background-color: #242424;
+
+  font-synthesis: none;
+  text-rendering: optimizeLegibility;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+  -webkit-text-size-adjust: 100%;
+}
+
+a {
+  font-weight: 500;
+  color: #646cff;
+  text-decoration: inherit;
+}
+a:hover {
+  color: #535bf2;
+}
+
+body {
+  margin: 0;
+  display: flex;
+  place-items: center;
+  min-width: 320px;
+  min-height: 100vh;
+}
+
+h1 {
+  font-size: 3.2em;
+  line-height: 1.1;
+}
+
+#app {
+  max-width: 1280px;
+  margin: 0 auto;
+  padding: 2rem;
+  text-align: center;
+}
+
+.logo {
+  height: 6em;
+  padding: 1.5em;
+  will-change: filter;
+  transition: filter 300ms;
+}
+.logo:hover {
+  filter: drop-shadow(0 0 2em #646cffaa);
+}
+.logo.vanilla:hover {
+  filter: drop-shadow(0 0 2em #f7df1eaa);
+}
+
+.card {
+  padding: 2em;
+}
+
+.read-the-docs {
+  color: #888;
+}
+
+button {
+  border-radius: 8px;
+  border: 1px solid transparent;
+  padding: 0.6em 1.2em;
+  font-size: 1em;
+  font-weight: 500;
+  font-family: inherit;
+  background-color: #1a1a1a;
+  cursor: pointer;
+  transition: border-color 0.25s;
+}
+button:hover {
+  border-color: #646cff;
+}
+button:focus,
+button:focus-visible {
+  outline: 4px auto -webkit-focus-ring-color;
+}
+
+@media (prefers-color-scheme: light) {
+  :root {
+    color: #213547;
+    background-color: #ffffff;
+  }
+  a:hover {
+    color: #747bff;
+  }
+  button {
+    background-color: #f9f9f9;
+  }
+}