intent.js

define(['underscore'], function (_) {

    var baseIntent = {
        DEBUG: false,
        /**
         * Intent type
         * @type {String}
         */
        type: null,

        /**
         * Data passed to intent. Can be anything but most cases should
         * be as as simple as possible
         * @type {Mixed}
         */
        data: {},
        args: [],

        /**
         * Component that sent the intent. 
         * @type {Component}
         */
        origin: null,

        /**
         * Method that sender expects to be called when intent is handled
         * 
         * Context (this) is always the sender component. Callbacks should
         * always have following interface callback(err, args*). 
         * @type {Function}
         */
        respondCallback: null,

        /**
         * Is Intent sent
         * @type {Boolean}
         */
        sent: false,

        /**
         * Is callback called
         * @type {Boolean}
         */
        handled: false,

        /**
         * Creates new intent
         * 
         * @param {String} type Intent type
         * @param {Mixed} [data] Data
         * @return {Intent}
         */
        create: function(type, data) {
            if (this.DEBUG) console.info('INTENT create: ' + type);

            var intent = Object.create(baseIntent);

            var args = Array.prototype.slice.call(arguments, 1);

            intent.type = type;
            intent.data = data;
            intent.args = args;

            return intent;
        },


        /**
         * Broadcasts the intent
         *
         * 
         * @param {Component|Application} [origin] Component that triggered intent
         * @param {Function} [respondCallback] Function called in respond
         */
        send: function(origin, respondCallback) {
            if (this.DEBUG) console.info('INTENT send: ' + this.type, this);

            if (this.sent) throw 'Intent already sent';

            Object.defineProperty(this, 'origin', {
                value: origin
            });
            Object.defineProperty(this, 'respondCallback', {
                value: respondCallback
            });
            Object.defineProperty(this, 'sent', {
                value: true
            });

            // Ensure context of the respond method
            this.respond = _.bind(baseIntent.respond, this);

            this._application.sendIntent(this);

        },


        /**
         * Responds to the intent triggering callback if set
         * 
         * Pass respond data as arguments.
         */
        respond: function() {
            if (this.DEBUG) console.info('INTENT respond: ' + this.type, arguments);

            if (this.origin && this.respondCallback) {
                Object.defineProperty(this, 'handled', {
                    value: true
                });

                var inst = this,
                    args = arguments;
                _.defer(function() {
                    inst.respondCallback.apply(inst.origin, args);
                });
            }
        },

        setDebug: function () {
            this.DEBUG = true;
            return this;
        }
    };

    return baseIntent;
});