@peter.naydenov/shortcuts 3.5.1 → 4.0.0

package/test/01-general.test.js

@@ -1,5 +1,5 @@
 import { beforeEach, afterEach, describe, it, expect } from 'vitest'
-import { userEvent } from '@vitest/browser/context'
+import { userEvent } from 'vitest/browser'
 import {
   getByLabelText,
   getByText,
@@ -56,7 +56,7 @@ const contextDefinition = {
                             , 'form : define' : () => 'input'
                             , 'form : action' : () => [
                                 {
-                                      fn : (e) => console.log ( e.target )
+                                      fn : (e) => e.target
                                     , type : 'input'
                                     , mode : 'in'
                                 }
@@ -66,7 +66,7 @@ const contextDefinition = {
 
 
                                     
-let short = shortcuts ();
+const short = shortcuts ();
 
 
 
@@ -74,7 +74,7 @@ describe ( "Shortcuts", () => {
 
         beforeEach ( async  () => {
                         short.load ( contextDefinition )
-                        let container = document.createElement ( 'div' )
+                        const container = document.createElement ( 'div' )
                         container.id = 'app'
                         document.body.appendChild ( container )
                         await html.publish ( Block, {}, 'app' )
@@ -119,42 +119,105 @@ describe ( "Shortcuts", () => {
         it ( 'List enabled plugins. Disable and enable plugins', async () => {
                      expect ( short.listPlugins () ).to.be.deep.equal ( [] )
                      // Enable list of plugins
-                     let myPlugins = [ pluginKey, pluginClick ]
+                     const myPlugins = [ pluginKey, pluginClick ]
                      myPlugins.forEach ( plugin =>  short.enablePlugin ( plugin )   )
                      expect ( short.listPlugins () ).to.be.deep.equal ( [ 'key', 'click' ] )
                      // Method disablePlugin require plugin name (prefix)
                      short.disablePlugin ( 'click' )
                      expect ( short.listPlugins () ).to.be.deep.equal ( [ 'key' ] )
-                     // Method enablePlugin require the plugin as a function
-                     short.enablePlugin ( pluginClick )
-                     expect ( short.listPlugins () ).to.be.deep.equal ( [ 'key', 'click' ] )
-            }) // it list enabled plugins
+                      // Method enablePlugin require the plugin as a function
+                      short.enablePlugin ( pluginClick )
+                      expect ( short.listPlugins () ).to.be.deep.equal ( [ 'key', 'click' ] )
+
+                      // Try to enable non-function plugins - should do nothing
+                      short.enablePlugin ( 'not a function' )
+                      expect ( short.listPlugins () ).to.be.deep.equal ( [ 'key', 'click' ] )
+                      short.enablePlugin ( 123 )
+                      expect ( short.listPlugins () ).to.be.deep.equal ( [ 'key', 'click' ] )
+                      short.enablePlugin ( {} )
+                      expect ( short.listPlugins () ).to.be.deep.equal ( [ 'key', 'click' ] )
+
+                      // Try to disable a plugin that is not enabled - should do nothing
+                      short.disablePlugin ( 'scroll' )
+                      expect ( short.listPlugins () ).to.be.deep.equal ( [ 'key', 'click' ] )
+             }) // it list enabled plugins
 
 
 
         it ( 'Unload non existing context', () => {
                       let change = false;
-                      let ls = short.listContexts ()
+                      const ls = short.listContexts ()
                       short.load ( {
                               local : {
-                                      'click : leff-1' : () => console.log ( 'nothing' ),
+                                      'click : leff-1' : () => 'nothing',
                                       '@shortcuts-error': () => change = true
                                   }
                           })
                       short.changeContext ( 'local' )
                       short.unload ( 'unknown' )
                       expect ( change ).to.be.true
-            }) // it unload non existing context
-        
-        
-        
-        it ( 'Emit custom event', () => {
-                            // TODO: Check arguments for the custom event handlers
+             }) // it unload non existing context
+
+
+
+         it ( 'Change to same context', () => {
+                       short.changeContext ( 'general' )
+                       expect ( short.getContext() ).to.be.equal ( 'general' )
+                       // Changing to the same context should do nothing
+                       short.changeContext ( 'general' )
+                       expect ( short.getContext() ).to.be.equal ( 'general' )
+                       // No error should be emitted
+                       expect ( c ).to.be.null
+              }) // it change to same context
+
+
+
+          it ( 'Switch off all shortcuts', () => {
+                        short.enablePlugin ( pluginKey )
+                        short.changeContext ( 'general' )
+                        expect ( short.getContext() ).to.be.equal ( 'general' )
+
+                        // Switch off all shortcuts
+                        short.changeContext ( false )
+                        expect ( short.getContext() ).to.be.null
+
+                        // Try to trigger a shortcut - should not work
+                        // But since it's key plugin, hard to test without DOM events
+                        // Just check context is null
+                        expect ( short.getContext() ).to.be.null
+               }) // it switch off all shortcuts
+
+
+
+          it ( 'Set note with invalid types', () => {
+                        short.changeContext ( 'general' )
+                        // Set valid note
+                        short.setNote ( 'valid note' )
+                        expect ( short.getNote() ).to.be.equal ( 'valid note' )
+
+                        // Try invalid types - should not change
+                        short.setNote ( 123 )
+                        expect ( short.getNote() ).to.be.equal ( 'valid note' )
+
+                        short.setNote ( {} )
+                        expect ( short.getNote() ).to.be.equal ( 'valid note' )
+
+                        short.setNote ( [] )
+                        expect ( short.getNote() ).to.be.equal ( 'valid note' )
+
+                        // Valid null should work
+                        short.setNote ( null )
+                        expect ( short.getNote() ).to.be.null
+              }) // it set note with invalid types
+
+
+
+          it ( 'Emit custom event', () => {
                             let result = null;
                             short.enablePlugin ( pluginClick )
                             const myAllContext = { 
                                                     myAll: {
-                                                            'click : leff-1' : () =>  console.log ( 'nothing' )
+                                                            'click : leff-1' : () => 'nothing'
                                                             , 'yo' : ({msg}) => result = msg
                                                         }}
                             short.load ( myAllContext )
@@ -170,15 +233,21 @@ describe ( "Shortcuts", () => {
         it ( 'List shortcuts', () => {
                       short.enablePlugin ( pluginKey )
 
-                      let general =  short.listShortcuts ('general');
+                      const general =  short.listShortcuts ('general');
                       expect ( general ).to.be.an ( 'array' )
                       expect ( general ).to.have.lengthOf ( 2 )
                       expect ( general ).to.include ( 'KEY:A+SHIFT' )
                       
-                      let fail = short.listShortcuts ( 'somethingNotExisting' );
-                      expect ( fail ).to.be.null
-                  
-                      let all = short.listShortcuts ();
+                       const fail = short.listShortcuts ( 'somethingNotExisting' );
+                       expect ( fail ).to.be.null
+
+                       // Edge cases for invalid context types
+                       expect ( short.listShortcuts ( 123 ) ).to.be.null
+                       expect ( short.listShortcuts ( {} ) ).to.be.null
+                       expect ( short.listShortcuts ( [] ) ).to.be.null
+                       expect ( short.listShortcuts ( undefined ) ).to.be.an ( 'array' )  // undefined == null, so lists all
+
+                       const all = short.listShortcuts ();
                       expect ( all ).to.be.an ( 'array' )
                    
                       expect ( all ).to.have.lengthOf ( 4 )

package/test/02-key.test.js

@@ -1,5 +1,5 @@
 import { beforeEach, afterEach, describe, it, expect } from 'vitest'
-import { userEvent } from '@vitest/browser/context'
+import { userEvent } from 'vitest/browser'
 import {
   getByLabelText,
   getByText,
@@ -30,6 +30,7 @@ let
        a = false
      , b = false
      , c = null
+     , container
      ;
 
 const contextDefinition = {
@@ -55,7 +56,7 @@ const contextDefinition = {
                             , 'form : define' : () => 'input'
                             , 'form : action' : () => [
                                 {
-                                      fn : (e) => console.log ( e.target )
+                                      fn : (e) => e.target
                                     , type : 'input'
                                     , mode : 'in'
                                 }
@@ -63,7 +64,7 @@ const contextDefinition = {
                     }
       }
 
-let short = shortcuts ();
+const short = shortcuts ();
 
 
 
@@ -71,26 +72,30 @@ let short = shortcuts ();
 
 describe ( 'Key plugin', () => {
 
-      beforeEach ( async  () => {
-                    short.load ( contextDefinition )
-                    let container = document.createElement ( 'div' )
-                    container.id = 'app'
-                    document.body.appendChild ( container )
-                    await html.publish ( Block, {}, 'app' )
-                    a = false, b = false
-          }) // beforeEach
+       beforeEach ( async  () => {
+                     short.load ( contextDefinition )
+                     container = document.createElement ( 'div' )
+                     container.id = 'app'
+                     document.body.appendChild ( container )
+                     await html.publish ( Block, {}, 'app' )
+                     a = false, b = false
+           }) // beforeEach
 
 
 
-      afterEach ( async  () => {
-                  short.reset ()
-                  a = false, b = false, c = null;
-          }) // afterEach
+       afterEach ( async  () => {
+                   short.reset ()
+                   short.disablePlugin ( 'key' )
+                   if (container && document.body.contains(container)) {
+                              document.body.removeChild(container);
+                        }
+                   a = false, b = false, c = null;
+           }) // afterEach
 
 
 
       it ( 'No "key" plugin installed', () => {
-                          let r = short.listShortcuts ('general');
+                          const r = short.listShortcuts ('general');
                           // Shortcut name is the same as it was set
                           expect ( r[0]).to.equal ( ' key : shift+a' ) 
           }) // it no 'key' plugin installed
@@ -146,7 +151,7 @@ describe ( 'Key plugin', () => {
                 short.load ({
                       'local': {
                                   'key: x,y,z' : ({ dependencies }) => {
-                                                    let { result } = dependencies;
+                                                    const { result } = dependencies;
                                                     result.push ( i++ )
                                                 }
                                 }
@@ -156,6 +161,7 @@ describe ( 'Key plugin', () => {
 
                 // Test 1: Plugin should work normally
                 await userEvent.keyboard ( 'xyz' )
+                await wait ( 480 ) 
                 await waitFor ( () => {
                           // We checking if the shortcut works
                           expect ( result ).to.have.lengthOf ( 2 )
@@ -171,9 +177,11 @@ describe ( 'Key plugin', () => {
                           expect ( i ).to.equal ( 1 )
                     }, { timeout: 1000, interval: 12 })
 
+                    
                 // Test 3: Unmute plugin - should work again
                 short.unmutePlugin ( 'key' )
                 await userEvent.keyboard ( 'xyz' )
+                await wait ( 480 )
                 await waitFor ( () => {
                           // Plugin is unmuted, should work again
                           expect ( result ).to.have.lengthOf ( 3 )
@@ -199,7 +207,7 @@ describe ( 'Key plugin', () => {
                 *            // Body of the handler. Do something...
                 *       }
                 */
-                let test = [];
+                const test = [];
                 let i = 0;
                 short.enablePlugin ( pluginKey )
                 short.setDependencies ({ test })
@@ -237,7 +245,7 @@ describe ( 'Key plugin', () => {
                 await wait ( 50 )  // Wait for key processing
                 await waitFor ( () => {
                             expect ( i ).to.be.equal ( 1 )
-                            let result = test[0];
+                            const result = test[0];
                             expect ( result.wait ).to.be.equal ( 'function' )
                             expect ( result.end ).to.be.equal ( 'function' )
                             expect ( result.ignore ).to.be.equal ( 'function' )
@@ -245,28 +253,221 @@ describe ( 'Key plugin', () => {
                             expect ( result.context ).to.be.equal ( 'local' )
                             expect ( result.type ).to.be.equal ( 'key' )
                       }, { timeout: 1000, interval: 12 })
-          }) // it arguments of key handler
-
-
-     it ( 'Pause and resume', async () => {
-                          short.enablePlugin ( pluginKey )
-                          expect ( b ).to.be.equal ( false )
-                          short.changeContext ( 'extra' )
-                          // Shortcut name will be normalized by the plugin
-                          short.pause ( 'key : p,r,o,b,a' )
-                          // Execute key sequence: 'p,r,o,b,a'
-                          await userEvent.keyboard ( 'proba' )
-                          await wait ( 500 )
-                          await waitFor ( () => {
-                                      expect ( b ).to.be.equal ( false )
+            }) // it arguments of key handler
+
+
+      
+      it ( 'Pause and resume', async () => {
+                           short.enablePlugin ( pluginKey )
+                           expect ( b ).to.be.equal ( false )
+                           short.changeContext ( 'extra' )
+                           // Shortcut name will be normalized by the plugin
+                           short.pause ( 'key : p,r,o,b,a' )
+                           // Execute key sequence: 'p,r,o,b,a'
+                           await userEvent.keyboard ( 'proba' )
+                           await wait ( 500 )
+                           await waitFor ( () => {
+                                       expect ( b ).to.be.equal ( false )
+                                 }, { timeout: 1000, interval: 30 })
+
+                           short.resume ( 'key : p,r,o,b,a' )
+                           await userEvent.keyboard ( 'proba' )
+                           await wait ( 500 )
+                           await waitFor ( () => {
+                                       expect ( b ).to.be.equal ( true )
                                 }, { timeout: 1000, interval: 30 })
-
-                          short.resume ( 'key : p,r,o,b,a' )
-                          await userEvent.keyboard ( 'proba' )
-                          await wait ( 500 )
-                          await waitFor ( () => {
-                                      expect ( b ).to.be.equal ( true )
-                               }, { timeout: 1000, interval: 30 })
             }) // it pause and resume
 
+
+      
+      it ( 'Wait and ignore in key sequence', async () => {
+                        const emitted = [];
+                        short.setDependencies ({ emitted })
+                        short.load ({
+                              'waittest' : {
+                                            'key: a' : ({ wait, ignore, dependencies, isWaiting, type, end }) => {
+                                                                  if ( !isWaiting () ) {
+                                                                              // Switch sequence timer off and wait for edit the sequence
+                                                                              wait ()
+                                                                              ignore ()
+                                                                              return
+                                                                        }
+                                                                  // Sequence was ended. Proceed
+                                                                  dependencies.emitted.push ( 'a' )
+                                                                  end ()
+                                                            },
+                                            'key: b' : ({ wait, ignore, dependencies, isWaiting, type, end }) => {
+                                                                  dependencies.emitted.push ( 'b' )
+                                                            },
+                                            'key: r' : ({ wait, ignore, dependencies, isWaiting, type, end }) => {
+                                                                  // Ignore 'r' in the sequence
+                                                                  ignore ()
+                                                            },
+                                            'key: b,a' : ({ wait, ignore, dependencies, isWaiting, type, end }) => {
+                                                                  dependencies.emitted.push ( 'b,a' )                                                                  
+                                                            },
+                                            'key: esc' : ({ wait, ignore, dependencies, isWaiting, type, end }) => {
+                                                                  // Ignore 'escape in the sequence'
+                                                                  ignore ()
+                                                            }
+                                          }
+                              })
+
+                        short.enablePlugin ( pluginKey )
+                        short.changeContext ( 'waittest' )
+                        // Press 'a' - should call handler, set wait and ignore
+                        await userEvent.keyboard ( 'a' )
+                        await wait ( 500  )
+
+                        await userEvent.keyboard ('{Escape}')
+                        // Then press 'b' - since waiting, should emit 'b'
+                        await userEvent.keyboard ( 'b' )
+                        // Then press 'r' - will ignore 'r' in sequence because of use of 'ignore' in a handler
+                        await userEvent.keyboard ( 'r' )
+                        await userEvent.keyboard ( 'a' )
+                        await waitFor ( () => {
+                                  expect ( emitted ).to.deep.equal ( [ 'b', 'a', 'b,a'] )
+                        }, { timeout: 1000, interval: 12 })
+            }) // it wait and ignore in key sequence
+
+
+      
+      it ( 'Ignore keys after sequence', async () => {
+                        const emitted = [];
+                        short.setDependencies ({ emitted })
+                        short.load ({
+                              'waittest' : {
+                                            'key: a,b,esc' : ({ wait, ignore, dependencies, isWaiting, type, end }) => {
+                                                                  dependencies.emitted.push ( 'a,b,esc' )
+                                                            },
+                                            'key: r' : ({ wait, ignore, dependencies, isWaiting, type, end }) => {
+                                                                  dependencies.emitted.push ( 'r' )
+                                                            },
+                                            'key : s' : ({ wait, ignore, dependencies, isWaiting, type, end }) => {
+                                                                  dependencies.emitted.push ( 's' )
+                                                            },
+                                            'key: esc' : ({ wait, ignore, dependencies, isWaiting, type, end }) => {
+                                                                  dependencies.emitted.push ( 'esc' )
+                                                            }
+                                          }
+                              })
+
+                        
+                        short.enablePlugin ( pluginKey )
+                        short.changeContext ( 'waittest' )
+                        
+                        await userEvent.keyboard ( 'a' )
+                        await userEvent.keyboard ( 'b' )
+                        await userEvent.keyboard ( '{Escape}' )
+
+                        // Will be ignored
+                        await userEvent.keyboard ( 'r' )
+                        await userEvent.keyboard ( 'r' )
+                        await userEvent.keyboard ( '{Escape}' )
+
+                        // Wait above keyWait time to activate sequence again
+                        await wait ( 500 )
+                        // New sequence - will emit 'key: s'
+                        await userEvent.keyboard ( 's' )
+                        await wait ( 500 )
+                        await waitFor ( () => {
+                                    expect ( emitted ).to.deep.equal ( [ 'a,b,esc', 's' ] )
+                              }, { timeout: 1000, interval: 12 })
+            }) // it ignore keys after sequence
+
+      
+
+      it ( 'Stop a plugin durring a sequence', async () => {
+                        const emitted = [];
+                        short.setDependencies ({ emitted })
+                        short.load ({
+                              'waittest' : {
+                                            'key: a,b,esc' : ({ wait, ignore, dependencies, isWaiting, type, end }) => {
+                                                                  dependencies.emitted.push ( 'a,b,esc' )
+                                                            },
+                                            'key: r' : ({ wait, ignore, dependencies, isWaiting, type, end }) => {
+                                                                  dependencies.emitted.push ( 'r' )
+                                                            },
+                                            'key : s' : ({ wait, ignore, dependencies, isWaiting, type, end }) => {
+                                                                  dependencies.emitted.push ( 's' )
+                                                            },
+                                            'key: esc' : ({ wait, ignore, dependencies, isWaiting, type, end }) => {
+                                                                  dependencies.emitted.push ( 'esc' )
+                                                            }
+                                          }
+                              })
+
+                        
+                        short.enablePlugin ( pluginKey )
+                        short.changeContext ( 'waittest' )
+                        
+                        await userEvent.keyboard ( 'a' )
+                        await userEvent.keyboard ( 'b' )
+                        short.disablePlugin ( 'key' )
+                        await userEvent.keyboard ( '{Escape}' )
+                        expect ( emitted ).to.deep.equal ( [] )
+            }) // it stop a plugin durring a sequence
+
+
+
+      it ( 'Key setup event', async () => {
+                        const emitted = [];
+                        short.setDependencies ({ emitted })
+                        short.load ({
+                              'local' : {
+                                            'key: a' : ({ wait, ignore, dependencies, isWaiting, type, end }) => {
+                                                                  dependencies.emitted.push ( 'a' )
+                                                      }
+                                            , 'key: setup' : ({ dependencies, defaults }) => {
+                                                                  dependencies.emitted.push ( 'setup' )
+                                                                  expect ( defaults.keyWait ).to.equal ( 480 )
+                                                                  // Setup should return an object with required param changes
+                                                                  // It's not possible to test...
+                                                                  return { keyWait: 100 }
+                                                      }
+                                          }
+                              })
+                         
+                        short.enablePlugin ( pluginKey )
+                        short.changeContext ( 'local' )
+                        const start = performance.now ()
+                        await userEvent.keyboard ( 'a' )
+                        await wait ( 150 )
+                        await userEvent.keyboard ( 'a' )
+                        await waitFor ( () => {
+                              const end = performance.now ()
+                              expect ( end - start ).to.be.lessThan ( 200 )
+                              expect ( emitted ).to.deep.equal ( [ 'setup', 'a', 'a' ] )
+                        }, { timeout: 1000, interval: 12 })
+            }) // it key setup
+
+
+
+      it ( 'Extra parameters to plugin options', async () => {
+                              short.enablePlugin ( pluginKey )
+                              const emit = [];
+                              const setupContext = {
+                                          'key:setup' : () => {
+                                                emit.push ( 'setup' )
+                                                return { keyWait: 100, emit }
+                                                },
+                                          'key:a' : ({options}) => {
+                                                      expect ( options.keyWait ).to.equal ( 100 )
+                                                      options.emit.push ( 'a' )
+                                                }
+                                      } // setupContext
+                              
+                              short.load ({ setupContext })
+                              short.changeContext ( 'setupContext' )
+
+                              // Setup event execution is on change context:
+                              expect ( emit[0] ).to.equal ( 'setup' )
+                              
+                              // Click and measure time
+                              await userEvent.keyboard ( 'a')                       
+                              await waitFor ( () => {
+                                          expect ( emit ).to.deep.equal ( [ 'setup', 'a' ] )
+                                    }, { timeout: 1000, interval: 12 })
+                  }) // it extra parameters to plugin options
+
 })