@peter.naydenov/shortcuts 3.4.0 → 3.5.1

package/test/02-key.test.js

@@ -47,9 +47,9 @@ const contextDefinition = {
                               // Single click with right button
                               'click: right-1': () => b = true
                         }
-                , extra : {    
-                            'key : p,r,o,b,a': () => b = true                        
-                        }
+                 , extra : {
+                             'key : p,r,o,b,a': () => b = true
+                         }
                 , extend : {
                               'form : watch' : () => 'input'
                             , 'form : define' : () => 'input'
@@ -121,54 +121,152 @@ describe ( 'Key plugin', () => {
 
 
 
-    it ( 'Key sequence', async () => {
-                      // enable key plugin and normalize shortcuts related to the plugin 'key'
+     it ( 'Key sequence', async () => {
+                       // enable key plugin and normalize shortcuts related to the plugin 'key'
                       short.enablePlugin ( pluginKey )
                       short.changeContext ( 'extra' )
                       // Execute key sequence: 'p,r,o,b,a'
                       await userEvent.keyboard ( 'proba' )
-                      await wait ( 12 )
+                      await wait ( 480 )
                       await waitFor ( () => {
                                 expect ( b ).to.equal ( true )
                       }, { timeout: 1000, interval: 12 })
-        }) // it key sequence
+         }) // it key sequence
+
+
+
+
+    it ( 'Mute and unmute key plugin', async () => {
+                const result = [];
+                let i = 0;
+                result.push ( 'init' )
 
+                short.enablePlugin ( pluginKey )
+                short.setDependencies ({ result })
+                short.load ({
+                      'local': {
+                                  'key: x,y,z' : ({ dependencies }) => {
+                                                    let { result } = dependencies;
+                                                    result.push ( i++ )
+                                                }
+                                }
+                        })
+
+                short.changeContext ( 'local' )
+
+                // Test 1: Plugin should work normally
+                await userEvent.keyboard ( 'xyz' )
+                await waitFor ( () => {
+                          // We checking if the shortcut works
+                          expect ( result ).to.have.lengthOf ( 2 )
+                          expect ( i ).to.equal ( 1 )
+                    }, { timeout: 1000, interval: 12 })
+
+                // Test 2: Mute plugin - should not trigger
+                short.mutePlugin ( 'key' )
+                await userEvent.keyboard ( 'xyz' )
+                await waitFor ( () => {
+                          // Plugin is muted, so we don't expect any changes
+                          expect ( result ).to.have.lengthOf ( 2 )
+                          expect ( i ).to.equal ( 1 )
+                    }, { timeout: 1000, interval: 12 })
+
+                // Test 3: Unmute plugin - should work again
+                short.unmutePlugin ( 'key' )
+                await userEvent.keyboard ( 'xyz' )
+                await waitFor ( () => {
+                          // Plugin is unmuted, should work again
+                          expect ( result ).to.have.lengthOf ( 3 )
+                          expect ( i ).to.equal ( 2 )
+                    }, { timeout: 1000, interval: 12 })
+          }) // it mute and unmute key plugin
+
+
+
+    it ( 'Arguments of key handler', async () => {
+                /**
+                *    Need to know arguments for 'key' handler
+                *    function myKeyHandler ({
+                *                         wait        // (function). Function to pause key sequence processing
+                *                       , end         // (function). Function to end key sequence processing
+                *                       , ignore      // (function). Function to ignore current key in sequence
+                *                       , isWaiting   // (function). Check if sequence is waiting
+                *                       , note        // (string). Current context note or null
+                *                       , context     // (string). Current context name
+                *                       , dependencies // (object). External dependencies object
+                *                       , type        // (string). Event type ('key')
+                *                  }) {
+                *            // Body of the handler. Do something...
+                *       }
+                */
+                let test = [];
+                let i = 0;
+                short.enablePlugin ( pluginKey )
+                short.setDependencies ({ test })
+                short.load ({
+                        'local' : {
+                              'key: a' : ({
+                                           wait
+                                         , end
+                                         , ignore
+                                         , isWaiting
+                                         , note
+                                         , context
+                                         , dependencies
+                                         , type
+                                       }) => {
+                                                const
+                                                    { test } = dependencies
+                                                  , result = {
+                                                                    wait: typeof wait
+                                                                  , end: typeof end
+                                                                  , ignore: typeof ignore
+                                                                  , isWaiting: typeof isWaiting
+                                                                  , note
+                                                                  , context
+                                                                  , type
+                                                              }
+                                                    ;
+                                                test.push ( result )
+                                                i++
+                                          }
+                            } // local
+                      })
+                short.changeContext ( 'local' )
+                await userEvent.keyboard ( 'a' )
+                await wait ( 50 )  // Wait for key processing
+                await waitFor ( () => {
+                            expect ( i ).to.be.equal ( 1 )
+                            let result = test[0];
+                            expect ( result.wait ).to.be.equal ( 'function' )
+                            expect ( result.end ).to.be.equal ( 'function' )
+                            expect ( result.ignore ).to.be.equal ( 'function' )
+                            expect ( result.isWaiting ).to.be.equal ( 'function' )
+                            expect ( result.context ).to.be.equal ( 'local' )
+                            expect ( result.type ).to.be.equal ( 'key' )
+                      }, { timeout: 1000, interval: 12 })
+          }) // it arguments of key handler
 
 
-    it ( 'Mute key plugin', async () => {
+     it ( 'Pause and resume', async () => {
                           short.enablePlugin ( pluginKey )
-                          const result = [];
-                          let i = 0;
-                          result.push ( 'init' )
-
-                          short.setDependencies ({ result })
-                          short.load ({
-                                'local': {
-                                        'key: g,t,i ' : ({dependencies}) => {
-                                                  let { result } = dependencies;
-                                                  result.push ( i++ )
-                                              }
-                                      }
-                              })
-                          
-                          short.changeContext ( 'local' )
-                          await userEvent.keyboard ( 'gti' )
+                          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 ( () => {
-                                    // We checking if the shortcut works
-                                    expect ( result ).to.have.lengthOf ( 2 )
-                                    expect ( i ).to.equal ( 1 )
-                              }, { timeout: 1000, interval: 12 })
+                                      expect ( b ).to.be.equal ( false )
+                                }, { timeout: 1000, interval: 30 })
 
-                          short.mutePlugin ( 'key' )
-                          await userEvent.keyboard ( 'gti' )
+                          short.resume ( 'key : p,r,o,b,a' )
+                          await userEvent.keyboard ( 'proba' )
+                          await wait ( 500 )
                           await waitFor ( () => {
-                                    // Plugin is muted, so we don't expect any changes
-                                    expect ( result ).to.have.lengthOf ( 2 )
-                                    expect ( i ).to.equal ( 1 )
-                              }, { timeout: 1000, interval: 12 })
-        }) // it mute key plugin
-    
-    
-
+                                      expect ( b ).to.be.equal ( true )
+                               }, { timeout: 1000, interval: 30 })
+            }) // it pause and resume
 
 })

package/test/03-click.test.js

@@ -256,65 +256,97 @@ describe ( 'Click plugin', () => {
 
 
       it ( 'Click on anchor', async () => {
-                // Click on anchor that don't have click-data attribute.
-                let result = 'none';
-                short.enablePlugin ( pluginClick )
-                short.load ({ 'extra' : { 
-                                        'click: 1 - left' : ({target, context, event }) => {   // Order of button name and number of click is not important
-                                                    event.preventDefault ()
-                                                    expect ( context ).to.be.equal ( 'extra' )
-                                                    expect ( target.nodeName ).to.be.equal ( 'A' )
-                                                    result = target.nodeName
-                                                }
-                                    } 
-                        })
-                short.changeContext ( 'extra' )
-                let loc = document.querySelector ( '#anchor' )  || false;
-                if ( loc )   await userEvent.click ( loc )
-                expect ( result ).to.be.equal ( 'A' )  
+                        // Click on anchor that don't have click-data attribute.
+                        let result = 'none';
+                        short.enablePlugin ( pluginClick )
+                        short.load ({ 'extra' : { 
+                                                'click: 1 - left' : ({target, context, event }) => {   // Order of button name and number of click is not important
+                                                            event.preventDefault ()
+                                                            expect ( context ).to.be.equal ( 'extra' )
+                                                            expect ( target.nodeName ).to.be.equal ( 'A' )
+                                                            result = target.nodeName
+                                                            }
+                                                } 
+                                    })
+                        short.changeContext ( 'extra' )
+                        let loc = document.querySelector ( '#anchor' )  || false;
+                        if ( loc )   await userEvent.click ( loc )
+                        expect ( result ).to.be.equal ( 'A' )  
           }) // it click on anchor
 
 
 
-      it ( 'Mute click plugin', async () => {
-                                const 
-                                      result = []
-                                    , trg = document.querySelector ( '#rspan' ) 
-                                    ;
-                                
-                                let i = 0;
-                                result.push ( 'init' )
-
-                                
-                                short.load ({
-                                      'local' : {
-                                              'click: left-1 ' : ({dependencies}) => {
-                                                        let { result } = dependencies;
-                                                        result.push ( i++ )
-                                                    }
-                                            }
-                                    })
-                                short.setDependencies ({ result })
-                                short.enablePlugin ( pluginClick )
-                                short.changeContext ( 'local' )
-
-
-                                await userEvent.click ( trg )
-                                await wait( 330 )
-                                await waitFor ( () => {
-                                          // We checking if the shortcut works
-                                          expect ( result ).to.have.lengthOf ( 2 )
-                                          expect ( i ).to.equal ( 1 )
-                                    }, { timeout: 1000, interval: 12 })
-
-                                short.mutePlugin ( 'click' )
-
-                                await userEvent.click ( trg )
-                                await waitFor ( () => {
-                                          // Plugin is muted, so we don't expect any changes
-                                          expect ( result ).to.have.lengthOf ( 2 )
-                                          expect ( i ).to.equal ( 1 )
-                                    }, { timeout: 1000, interval: 12 })
-              }) // it mute click plugin
+      it ( 'Mute and unmute click plugin', async () => {
+                        const 
+                              result = []
+                        , trg = document.querySelector ( '#rspan' ) 
+                        ;
+                        
+                        let i = 0;
+                        result.push ( 'init' )
+
+                        
+                        short.load ({
+                              'local' : {
+                                    'click: left-1 ' : ({dependencies}) => {
+                                                let { result } = dependencies;
+                                                result.push ( i++ )
+                                          }
+                                    }
+                              })
+                        short.setDependencies ({ result })
+                        short.enablePlugin ( pluginClick )
+                        short.changeContext ( 'local' )
+
+
+                        await userEvent.click ( trg )
+                        await wait( 330 )
+                        await waitFor ( () => {
+                              // We checking if the shortcut works
+                              expect ( result ).to.have.lengthOf ( 2 )
+                              expect ( i ).to.equal ( 1 )
+                        }, { timeout: 1000, interval: 12 })
+
+                        short.mutePlugin ( 'click' )
+
+                        await userEvent.click ( trg )
+                        await waitFor ( () => {
+                                    // Plugin is muted, so we don't expect any changes
+                                    expect ( result ).to.have.lengthOf ( 2 )
+                                    expect ( i ).to.equal ( 1 )
+                              }, { timeout: 1000, interval: 12 })
+
+                        short.unmutePlugin ( 'click' )
+
+                        await userEvent.click ( trg )
+                        await wait ( 330 )
+                        await waitFor ( () => {
+                                    // Plugin is unmuted, should work again
+                                    expect ( result ).to.have.lengthOf ( 3 )
+                                    expect ( i ).to.equal ( 2 )
+                              }, { timeout: 1000, interval: 12 })
+               }) // it mute and unmute click plugin
+
+
+
+      it ( 'Pause and resume', async () => {
+                        let target = document.querySelector ( '#rspan' )
+                        short.enablePlugin ( pluginClick )
+                        expect ( b ).to.be.equal ( false )
+                        short.changeContext ( 'touch' )
+                        short.pause ( 'click: left-1' )
+                        await userEvent.click ( target )
+                        await wait ( 400 )
+                        await waitFor ( () => {
+                                    expect ( b ).to.be.equal ( false )
+                              }, { timeout: 1000, interval: 30 })
+                        short.resume ( 'click: left-1' )
+                        await userEvent.click ( target )
+                        await wait ( 400 )
+                        await waitFor ( () => {
+                                    expect ( b ).to.be.equal ( true )
+                                    expect ( c ).to.be.equal ( 'red' )
+                             }, { timeout: 1000, interval: 30 })
+              }) // it pause and resume
   
 }) // describe

package/test/04-form.test.js

@@ -53,13 +53,13 @@ const contextDefinition = {
                 , extend : {
                               'form : watch' : () => 'input'
                             , 'form : define' : () => 'input'
-                            , 'form : action' : () => [
-                                {
-                                      fn : (e) => console.log ( e.target )
-                                    , type : 'input'
-                                    , mode : 'in'
-                                }
-                            ]
+                             , 'form : action' : () => [
+                                 {
+                                       fn : (e) => console.log ( e.target )
+                                     , type : 'input'
+                                     , timing : 'in'
+                                 }
+                             ]
                     }
       }
 
@@ -67,7 +67,7 @@ let short = shortcuts ();
 
 
 
-describe.skip ( 'Form plugin', () => {
+describe.only ( 'Form plugin', () => {
 
       beforeEach ( async  () => {
                   short.load ( contextDefinition )
@@ -86,5 +86,48 @@ describe.skip ( 'Form plugin', () => {
           }) // afterEach
 
 
-
+      it ( 'Shortcut when plugin is not installed', async () => {
+                  const ls = short.listShortcuts ( 'extend' )
+                  expect ( ls ).to.includes ( 'form : action' )
+          }) // it Shortcuts when plugin is not installed
+
+      
+      it ( 'Shortcuts when plugin is enabled', async () => {
+                  short.enablePlugin ( pluginForm )
+                  const ls = short.listShortcuts ( 'extend' )
+                  expect ( ls ).to.includes ( 'FORM:WATCH' )
+                  // Shortcut names are normalized by the plugins!               
+                  expect ( ls ).to.not.includes ( 'form : watch' )                  
+          }) // it Shortcuts when plugin is enabled
+
+
+
+      it ( 'Simpler form listener. Only "form:action" defined', async () => {
+                  // Uses predefined 'watch' and 'define' functions
+                  short.enablePlugin ( pluginForm )
+                  let edit = 'none';
+
+                  const contextExtension = {
+                                  'local' : {
+                                          'form: action' : () => [{
+                                                                    fn : () => edit = 'changed'
+                                                                  , type : 'input'
+                                                                  , timing : 'instant'
+                                                                }]
+                                        }
+                            };
+                  short.load ( contextExtension )
+                  short.changeContext ( 'local' )
+                  let input = document.getElementById ( 'name' )
+                  input.focus ()
+                  await userEvent.keyboard ( 'hello' )
+                  await wait ( 50 )
+                  await waitFor ( () => {
+                              expect ( edit ).to.equal ( 'changed' )
+                      }, { timeout: 1000, interval: 12 })
+          }) // it Simpler form listener
+
+
+
+      
 }) // describe

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "allowJs": true,
+    "declaration": true,
+    "emitDeclarationOnly": true,
+    "outDir": "dist",
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "strict": false,
+    "skipLibCheck": true
+  },
+  "include": [
+    "src/**/*.js"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "test"
+  ]
+}