extend.js

'use strict';
(function(global){
     function isFunction(item) {
        return typeof item === 'function';
    }
    function extend(target, options){
        var copy;
        if(typeof target !== 'object' && !isFunction(target)){
            target = {};
        }
        for(var name in options){
            target[name] = options[name];
        }
        return target;
    }
    global.extend = extend;
})(window);

jsonp.js

'use strict';
(function(global){
    var paramSerialize = function(data){
        var s = [];
        var add = function(key, value){
            value = isFunction( value ) ? value() : ( value == null ? '' : value );
            s[ s.length ] = encodeURIComponent( key ) + '=' + encodeURIComponent( value );
        };
        Object.keys(data).forEach(function(a, index){
            add(a, data[a])
        });
        return s.join("&");
    };
    //jsonp
    var jsonp = function(args){
        var loaded  = false;
        var paramStr = paramSerialize(args.data);
        var callbackName = args.callback ? args.callback : 'callback';
        var response = {};
        if(paramStr){
            args.url += '?' + paramStr + '&callback=' + callbackName;
        }
        window[callbackName] = function(){
            response = arguments[0];
        };
        createJS(args.url, function() {
            loaded = true;
            args.onsuccess(response);
            delete window[callbackName];
        }, function() {
            if ( loaded ) { return; }
            loaded = true;
            args.onerror(response);
            delete window[callbackName];
        });
    };
    var createJS = function(src, onloadend, onerror) {
        var res                = document.createElement('script');
        res.type               = 'text/javascript';
        res.charset            = 'utf-8';
        res.onload             = onloadend             || function() {};
        res.onerror            = onerror            || function() {};
        res.src                = src;

        document.getElementsByTagName('head')[0].appendChild(res);

        return res;
    };
    function isFunction(item) {
        return typeof item === 'function';
    }
    global.requestJsonp = jsonp;
})(window);

promise.js

'use strict';
(function(global){
    var PENDING   = void 0;
    var FULFILLED = 1;
    var REJECTED  = 2;

    function isFunction(item) {
        return typeof item === 'function';
    }
    var Promise = function(resolver){
        var promise = this;
        promise._state = undefined;
        promise._subscribers = [];
        try {
            resolver(function resolvePromise(value){
                resolve(promise, value);
            }, function rejectPromise(reason) {
                reject(promise, reason);
            });
        } catch(e) {
            reject(promise, e);
        }
    };
    Promise.prototype = {
        constructor: Promise,
        then: function(onFulfillment, onRejection){
            var parent = this;
            var state = parent._state;

            if (state === FULFILLED && !onFulfillment || state === REJECTED && !onRejection) {
                return this;
            }

            var child = new Promise();
            var result = parent._result;

            subscribe(parent, child, onFulfillment, onRejection);
            return child;

        },
        resolve: function(object){
            var Constructor = this;

            if (object && typeof object === 'object' && object.constructor === Constructor) {
                return object;
            }

            var promise = new Constructor(noop);
            resolve(promise, object);
            return promise;
        }
    };
    function flush(callback, arg) {
        return function(){
            return callback(arg);
        }
    }
    function useSetTimeout(callback, arg) {
        setTimeout(flush(callback, arg), 1);
    }
    var asap = function asap(callback, arg) {
        useSetTimeout(callback, arg);
    };
    function resolve(promise, value){
        fulfill(promise, value);
    }
    function subscribe(parent, child, onFulfillment, onRejection) {
        var subscribers = parent._subscribers;
        var length = subscribers.length;

        parent._onerror = null;

        subscribers[length] = child;
        subscribers[length + FULFILLED] = onFulfillment;
        subscribers[length + REJECTED]  = onRejection;
    }
    function publish(promise) {
        var subscribers = promise._subscribers;
        var settled = promise._state;

        if (subscribers.length === 0) { return; }

        var child, callback, detail = promise._result;

        for (var i = 0; i < subscribers.length; i += 3) {
            child = subscribers[i];
            callback = subscribers[i + settled];

            if (child) {
                invokeCallback(settled, child, callback, detail);
            }
        }

        promise._subscribers.length = 0;
    }
    function cannotReturnOwn() {
        return new TypeError('A promises callback cannot return that same promise.');
    }
    function ErrorObject() {
        this.error = null;
    }
    var TRY_CATCH_ERROR = new ErrorObject();
    function tryCatch(callback, detail) {
        try {
            return callback(detail);
        } catch(e) {
            TRY_CATCH_ERROR.error = e;
            return TRY_CATCH_ERROR;
        }
    }
    function invokeCallback(settled, promise, callback, detail) {
        var hasCallback = isFunction(callback),
            value, error, succeeded, failed;
        if (hasCallback) {
            value = tryCatch(callback, detail);

            if (value === TRY_CATCH_ERROR) {
                failed = true;
                error = value.error;
                value = null;
            } else {
                succeeded = true;
            }

            if (promise === value) {
                reject(promise, cannotReturnOwn());
            }

        } else {
            value = detail;
            succeeded = true;
        }
    }
    function reject(promise, reason) {
        if (promise._state !== PENDING) { return; }
        promise._state = REJECTED;
        promise._result = reason;

        asap(publishRejection, promise);
    }
    function publishRejection(promise) {
        if (promise._onerror) {
            promise._onerror(promise._result);
        }

        publish(promise);
    }

    function fulfill(promise, value) {
        if (promise._state !== PENDING) { return; }

        promise._result = value;
        promise._state = FULFILLED;

        if (promise._subscribers.length !== 0) {
            asap(publish, promise);
        }
    }
    global.FPromise = Promise;
})(window);