https://github.com/andrienko/taj

Yet another task mechanism to work with async code
https://github.com/andrienko/taj

Last synced: 7 days ago
JSON representation

Yet another task mechanism to work with async code

• Host: GitHub
• URL: https://github.com/andrienko/taj
• Owner: andrienko
• Created: 2017-06-09T17:12:48.000Z (over 7 years ago)
• Default Branch: master
• Last Pushed: 2018-03-23T16:40:20.000Z (over 6 years ago)
• Last Synced: 2024-11-06T18:18:31.928Z (10 days ago)
• Language: JavaScript
• Size: 9.77 KB
• Stars: 0
• Watchers: 2
• Forks: 0
• Open Issues: 0
• Metadata Files:
  • Readme: README.md

Awesome Lists containing this project

README

        
Taj

===

Taj Asynchronous Jammer is a yet another piping mechanism for JS.

Here's an example of use:

    var Taj = require('./taj');

    var chain = new Taj();

    

    // Creating new callback

    chain.registerCallback('add',function(pass, value){

      pass(this+value); // this will be the walue ".run" function below is called with.

    });

    

    // now "add" function is registered and can be chained

    

    // Adding it to chain's queue. Twice

    chain

      .add(', world')

      .add('!');

    

    // Running the chain

    chain.run('Hello',function(){

      console.log(this);

    });

    

    // Output will be 'Hello, world!' as a String

    // (primitive gets transformed to obj after passed through apply)

    

The idea is you register several functions and define a queue of them and their arguments. 

You can register multiple functions at once using `.registerCallbacks` method, passing it an object which keys will be

funciton names and values should be callbacks.

You may use .then to add a function to the queue without registering it

    chain

      .then(function(pass){

          pass(this+'test');

      })

      

 - You can also pass parameters array as a second argument of `.then`, these will be applied just like with registered

functions.

 - If you need a different queue - normally you should create a different chain (different Taj object), but also you can

 use the `.resetQueue` method, that will clear the queue.

 - getFunction method will return a function that does the same as if you wrote chain.run

 - You can access queue and callbacks via chain.__state value 

 - When passing primitive values through the chain - the object will be returned (because `apply` is used). If you want

 to explicitly use primitive values the best way would be wrapping them with an object, something like 

 `.run({value: 'Hello'}, function(){ ... })`

 - `pass` function that every callback receives, must be always called (in order to proceed to next chain queue item).

 - `pass` also has two properties - `pass.error` and `pass.pass`. `pass.error` will call the error handler, `pass.pass`

 will proceed to next link without modifying the `this` argument.

 

Events

---

You can use addEventListener to add event listeners. For now event listeners are `next`, `pass`, `error` and `done`.

    chain.addEventListener('next', function(e){

      console.log('Modified:', e.data);

    });