In short, it is a small module which can help you synchronize/chain functions. All functions are stored in the array and executed in the last call, so you can decide - in config - about the order of the execution.

When you would like to write: your own "code compilers", function generators etc. When execution depends on environment/config but api should stay unchanged.

It is very easy, just install as a dependency in your project and have fun.

npm install arkan.js --save

This module's API is limited just to one method, which is:

By calling this method you will add function -fn- and it's arguments -fnArgs Array- to the queue. By setting -outputAlias-, the method results will be stored in the Map object under the given key / alias. This method can be chained and the last call will execute the whole queue.

It is used to indicate the expected values stored in the Map object. These values represent the results obtained in the previous stages of the chain.

const Arkan = require("arkan.js").Arkan;

function foo() {
    console.log("running foo");
}
function bar() {
    console.log("running bar");
}
function baz() {
    console.log("running baz");
}
var arkan = new Arkan();
arkan.run(foo).run(bar).run(baz);

// Output:
// running foo
// running bar
// running baz

const Arkan = require("arkan.js").Arkan;

function foo() {
    console.log("running foo");
}
function bar() {
    console.log("running bar");
}
function baz() {
    console.log("running baz");
}
var arkan = new Arkan({
    queueOrder:{
        foo:0,
        bar:5,
        baz:2
    }
});

arkan.run(foo).run(bar).run(baz);

// Output:
// running foo
// running baz
// running bar

const Arkan = require("arkan.js").Arkan;
const args = require("arkan.js").args;

function foo(name, prevName) {
    console.log("running " + name + 
    (prevName ? " | previously launched " + prevName : ""));
    return name;
}

var arkan = new Arkan();
var _bar = {};
arkan.run(foo, ["foo"], "_foo").run(foo, ["bar", args("_foo")], _bar).run(foo, ["baz", args(_bar)]);

// Output:
// running foo
// running bar previously launched foo
// running baz previously launched bar

const Arkan = require("arkan.js").Arkan;
const args = require("arkan.js").args;

function fooPromise() {
    return new Promise((resolve, reject) => {
        console.log("running foo promise");
        resolve("Cool");
    });
}

function barPromise(x,y,txt) {
    return new Promise((resolve, reject) => {
        console.log("running bar promise", txt, x, y);
        setTimeout(reject.bind(null,"You shall not pass"), 2000);
    });
}

function bazPromise(txt) {
    return new Promise((resolve, reject) => {
        console.log("running baz promise", txt);
        resolve();
    });
}

var arkanPromise = new Arkan();

arkanPromise.run(fooPromise, [], "foo").run(barPromise, [args("foo"), 0, 1], "bar").run(bazPromise, [args("bar")]);

// Output:
// running foo promise
// running bar promise Cool 0 1
// execution was interrupted at step 1 (barPromise) with error: You shall not pass