flux.js

var getFlux;
var getTween;

getFlux = function () {
    var flux = { _version : "0.1.5" };
    var tween = getTween();
    flux.list = [];
    flux.objects = {};

    flux.tweens = {};
    flux.easing = { linear : function(p) { return p; } };

    var easing = {
    quad    : "p * p",
    cubic   : "p * p * p",
    quart   : "p * p * p * p",
    quint   : "p * p * p * p * p",
    expo    : "2 ^ (10 * (p - 1))",
    sine    : "-Math.cos(p * (Math.pi * .5)) + 1",
    circ    : "-(Math.sqrt(1 - (p * p)) - 1)",
    back    : "p * p * (2.7 * p - 1.7)",
    elastic : "-(2^(10 * (p - 1)) * Math.sin((p - 1.075) * (Math.PI * 2) / .3))"
    }

    var makefunc = function(str, expr) {
        return new Function("p", str.split("$e").join(expr));
    }

    for (var k in easing) {
        var v = easing[k];

        flux.easing[k + "in"] = makefunc("return $e", v)

        flux.easing[k + "out"] = makefunc(`
        p = 1 - p;
        return 1 - ($e);
        `, v)

        flux.easing[k + "inout"] = makefunc(`
        p = p * 2
        if (p < 1) {
            return .5 * ($e);
        }
        else {
            p = 2 - p;
            return .5 * (1 - ($e)) + .5;
        }
        `, v)
    }


    flux.group = function () {
        return getFlux();
    }

    flux.to = function (obj, time, vars) {
        return flux.add(tween.new(obj, time, vars));
    }

    flux.update = function (deltatime) {
        for (let i = 0; i < this.list.length; i++) {
            var t = this.list[i];
            if (t._delay > 0) {
                t._delay = t._delay - deltatime;
            }
            else {
                if (!t.inited) {
                    flux.clear(t.obj, t.vars);
                    t.init();
                }
                if (t._onstart) {
                    t._onstart();
                    t._onstart = null;
                }
                t.progress = t.progress + t.rate * deltatime;
                var p = t.progress;
                var x = p >= 1 ? 1 : flux.easing[t._ease](p);
                for (var k in t.vars) {
                    var v = t.vars[k];
                    t.obj[k] = v.start + x * v.diff;
                }
                if (t._onupdate) { t._onupdate(); }
                if (p >= 1) {
                    flux.remove(i);
                    if (t._oncomplete) { t._oncomplete(); }
                }
            }
        }
    }

    flux.clear = function (obj, vars) {
        for (var t in this.objects[obj]) {
            if (t.inited) {
                for (var k in vars) {
                    t.vars[k] = null;
                }
            }
        }
    }

    flux.add = function (tween) {
        var obj = tween.obj;
        this.objects[obj] = this.objects[obj] || {};
        this.objects[obj][tween] = true;
        this.list.push(tween);
        tween.parent = this;
        return tween;
    }

    flux.remove = function (x) {
        if (typeof(x) == "number") {
            var obj = this.list[x].obj;
            delete this.objects[obj][this.list[x]];
            if (Object.keys(this.objects[obj]).length == 0) { delete this.objects[obj] }

            this.list[x] = this.list[this.list.length - 1];
            return this.list.pop();
        }

        for (let i = 0; i < this.list.length; i++) {
            if (this.list[i] == x) {
                return this.remove(i);
            }
        }
    }

    return flux;
}


getTween = function() {
    var tween = {}

    var makefsetter = function(field) {
      return function(x) {
        if (typeof(x) != "function") {
            console.error("expected function or callable");
        }
        var old = this[field];
        this[field] = old ? function() { old(); x(); } : x;
        return this;
      }
    }

    var makesetter = function(field, checkfn, errmsg) {
      return function(x) {
        if (checkfn && !checkfn(x)) {
          console.logerror(errmsg.replace("$x", x.toString()));
        }
        this[field] = x;
        return this;
      }
    }

    tween.ease  = makesetter("_ease",
                             function(x) { return flux.easing[x] },
                             "bad easing type '$x'");
    tween.delay = makesetter("_delay",
                             function(x) { return typeof(x) == "number" },
                             "bad delay time; expected number");
    tween.onstart     = makefsetter("_onstart");
    tween.onupdate    = makefsetter("_onupdate");
    tween.oncomplete  = makefsetter("_oncomplete");

    tween.new = function(obj, time, vars) {
        var self = getTween();
        self.obj = obj
        self.rate = time > 0 ? 1 / time : 0
        self.progress = time > 0 ? 0 : 1
        self._delay = 0
        self._ease = "quadout"
        self.vars = {}
        for (var k in vars) {
            var v = vars[k];
            if (typeof(v) != "number") {
                console.error("bad value for key '" + k + "'; expected number");
            }
            self.vars[k] = v
        }
        return self
    }

    tween.init = function() {
        for (var k in this.vars) {
            var v = this.vars[k];
            var x = this.obj[k];
            if (typeof(x) != "number") {
                console.error("bad value on object key '" + k + "'; expected number");
            }
            this.vars[k] = { start : x, diff : v - x };
        }
        this.inited = true
    }

    tween.after = function(...args) {
        var t;
        if (args.length == 2) {
            t = tween.new(this.obj, ...args);
        }
        else {
            t = tween.new(...args);
        }
        t.parent = this.parent;
        var that = this;
        this.oncomplete(function () { flux.add.apply(that.parent, [t]) });
        return t;
    }

    tween.stop = function () {
        flux.remove.apply(this.parent, [this]);
    }

    return tween;
}

flux = getFlux();