fx-task-queue.html

<!--
    Schedules work to execute, will run the passed function, and replace it
    with the newly returned function, repeatedly until the work runs out or
    the workLimit is reached in ms. If the limit is reached and there are still
    functions to run then it will schedule a completion with setTimeout.

    Usage:

    // asyncForEach is similar to:

    var i = 0;
    var array = [ ... ];
    function nextElement() {
        if (i >= array.length)
            return;
        process(array[i++]);
        return nextElement;
    }
    this.$.taskQueue.scheduleWork(nextElement);
-->
<link href="../polymer/polymer.html" rel="import">

<polymer-element name="fx-task-queue" constructor="FxTaskQueue">
<script>
(function() {
    var tasks = [];

    function findTasks(element) {
        return tasks.filter(function(task) {
            return task.element = element;
        });
    }

    function suspendTasks(priority) {
        if (priority == undefined)
            priority = -1;
        tasks.forEach(function(task) {
            if (priority < 0 || task.element.priority <= priority)
                task.suspend();
        });
    }

    function resumeTasks(priority) {
        if (priority == undefined)
            priority = -1;
        tasks.forEach(function(task) {
            if (priority < 0 || task.element.priority <= priority)
                task.resume();
        });
    }

    function ScheduledTask(element, fn) {
        this.callback = fn;
        this.suspendCount = 0;
        this.element = element;
        this.scheduled = false;
        this.canceled = false;
        this.promise = new Promise(function(resolve, reject) {
            this.resolve = resolve;
            this.reject = reject;
        }.bind(this));
    }

    ScheduledTask.prototype.cancel = function() {
        this.canceled = true;
    };

    ScheduledTask.prototype.suspend = function() {
        this.suspendCount++;
    };

    ScheduledTask.prototype.resume = function() {
        this.suspendCount--;
        if (!this.suspendCount)
            this.schedule();
    };

    ScheduledTask.prototype.schedule = function() {
        if (this.scheduled || this.canceled)
            return;
        this.scheduled = true;
        setTimeout(function() {
            this.execute();
        }.bind(this), this.element.delayTime);
    };

    ScheduledTask.prototype.execute = function() {
        try {
            this.executeInternal();
        } catch (e) {
            this.reject(e);
        }
    };

    ScheduledTask.prototype.executeInternal = function() {
        if (this.suspendCount || this.canceled)
            return;
        var endTime = Date.now() + this.element.sliceTime;
        var result = this.callback();
        while (result instanceof Function && Date.now() < endTime)
            result = result();
        if (result instanceof Function) {
            this.callback = result;
            this.schedule();
        } else {
            this.resolve();
        }
    };

    Polymer({
        created: function() {
            this.sliceTime = 100; // ms
            this.delayTime = 0; // ms
            this.priority = 100;
        },
        detach: function() {
            this.cancel();
        },
        scheduleWork: function(fn) {
            var task = new ScheduledTask(this, fn);
            tasks.push(task);
            return task.schedule();
        },
        asyncForEach: function(array, fn) {
            var i = 0;
            function next() {
                if (i >= array.length)
                    return;
                fn(array[i], i);
                i++;
                return next;
            }
            return this.scheduleWork(next);
        },
        cancel: function() {
            findTasks(this).forEach(function(task) {
                task.cancel();
            });
        },
        suspend: function() {
            findTasks(this).forEach(function(task) {
                task.suspend();
            });
        },
        resume: function() {
            findTasks(this).forEach(function(task) {
                task.resume();
            });
        },
    });

    document.addEventListener("polymer-ready", function() {
        // Static API
        FxTaskQueue.suspendTasks = suspendTasks;
        FxTaskQueue.resumeTasks = resumeTasks;
    });
</script>
</polymer-element>