mirror of
https://github.com/wahyd4/cdnjs.git
synced 2026-08-09 04:46:00 +10:00
3408 lines
109 KiB
JavaScript
3408 lines
109 KiB
JavaScript
// angularsubkit.js - 1.0.1
|
||
// https://github.com/subkit
|
||
// Copyright 2012 - 2014 http://subkit.io
|
||
// MIT License
|
||
|
||
!function(e){"object"==typeof exports?module.exports=e():"function"==typeof define&&define.amd?define(e):"undefined"!=typeof window?window.Subkit=e():"undefined"!=typeof global?global.Subkit=e():"undefined"!=typeof self&&(self.Subkit=e())}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
|
||
module.exports = function(subkit){
|
||
'use strict';
|
||
|
||
return {
|
||
list: function(callback){
|
||
var deferred = subkit.$q.defer();
|
||
var url = subkit.baseUrl + '/baas';
|
||
subkit.httpRequest.get(url, subkit.options, function(status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 200) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve(result.json());
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
},
|
||
listByAccountId: function(name, callback){
|
||
var deferred = subkit.$q.defer();
|
||
var url = subkit.baseUrl + '/baas/by/accounts/' + name;
|
||
subkit.httpRequest.get(url, subkit.options, function(status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 200) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve(result.json());
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
},
|
||
get: function(name, callback){
|
||
var deferred = subkit.$q.defer();
|
||
var url = subkit.baseUrl + '/baas/' + name;
|
||
subkit.httpRequest.get(url, subkit.options, function(status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 200) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve(result.json());
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
},
|
||
set: function(id, username, password, callback){
|
||
var deferred = subkit.$q.defer();
|
||
var url = subkit.baseUrl + '/baas/' + id;
|
||
var msg = JSON.parse(JSON.stringify(subkit.options));
|
||
msg.data = {
|
||
username: username,
|
||
password: password
|
||
};
|
||
subkit.httpRequest.post(url, msg, function(status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 200 && status !== 201 && status!==202) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve(result.json());
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
},
|
||
remove: function(id, callback){
|
||
var deferred = subkit.$q.defer();
|
||
var url = subkit.baseUrl + '/baas/' + id;
|
||
subkit.httpRequest.del(url,subkit.options, function(status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 200 && status!==202 && status!==204) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve(result.json());
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
},
|
||
start: function(id, callback){
|
||
var deferred = subkit.$q.defer();
|
||
var url = subkit.baseUrl + '/baas/command/' + id;
|
||
subkit.httpRequest.put(url,subkit.options, function(status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 200 && status!==202 && status!==204) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve(result.json());
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
},
|
||
stop: function(id, callback){
|
||
var deferred = subkit.$q.defer();
|
||
var url = subkit.baseUrl + '/baas/command/' + id;
|
||
subkit.httpRequest.del(url,subkit.options, function(status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 200 && status!==202 && status!==204) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve(result.json());
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
}
|
||
};
|
||
};
|
||
|
||
},{}],2:[function(require,module,exports){
|
||
module.exports = function(subkit){
|
||
'use strict';
|
||
|
||
return {
|
||
Email: function(){
|
||
var self = this;
|
||
self.recipient = '';
|
||
self.templateId = '';
|
||
self.subject = '';
|
||
self.metadata;
|
||
},
|
||
send: function(email, callback){
|
||
var deferred = subkit.$q.defer();
|
||
var url = subkit.baseUrl + '/email/action/send/' + email.recipient;
|
||
var msg = JSON.parse(JSON.stringify(subkit.options));
|
||
msg.data = email;
|
||
subkit.httpRequest.post(url, msg, function(status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 201 && status!==202) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve(result.json());
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
},
|
||
setSettings: function(value, callback){
|
||
var deferred = subkit.$q.defer();
|
||
var url = subkit.baseUrl + '/email/settings';
|
||
var msg = JSON.parse(JSON.stringify(subkit.options));
|
||
msg.data = value;
|
||
subkit.httpRequest.put(url, msg, function(status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 201 && status!==202) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve(result.json());
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
},
|
||
getSettings: function(callback){
|
||
var deferred = subkit.$q.defer();
|
||
var url = subkit.baseUrl + '/email/settings';
|
||
subkit.httpRequest.get(url, subkit.options, function(status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 200) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve(result.json());
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
}
|
||
};
|
||
};
|
||
},{}],3:[function(require,module,exports){
|
||
/** @module file */
|
||
|
||
/**
|
||
* File
|
||
* @param {Subkit} subkit - A Subkit instance
|
||
*/
|
||
module.exports = function(subkit){
|
||
'use strict';
|
||
|
||
return {
|
||
|
||
/**
|
||
* Upload a file as a Blob.
|
||
* @method subkit.file.upload
|
||
* @memberOf :file#
|
||
* @param {Blob} file - A file as Blob
|
||
* @param {callback|undefined} callback - Optional handler function
|
||
* @return {Promise} Q based Promise
|
||
*/
|
||
upload: function(file, callback){
|
||
var deferred = subkit.$q.defer();
|
||
var msg = JSON.parse(JSON.stringify(subkit.options));
|
||
msg.headers['Content-Type'] = 'application/octed-stream';
|
||
msg.data = file;
|
||
var url = subkit.baseUrl + '/file/upload/' + file.name;
|
||
subkit.httpRequest.post(url, msg, function(status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 201 && status!==202) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve(result.json());
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
},
|
||
/**
|
||
* Download a file.
|
||
* @method subkit.file.download
|
||
* @memberOf module:file#
|
||
* @param {string} fileName - File name
|
||
* @param {callback|undefined} callback - Optional handler function
|
||
* @return {Promise} Q based Promise
|
||
*/
|
||
download: function(fileName, callback){
|
||
var deferred = subkit.$q.defer();
|
||
var url = subkit.baseUrl + '/file/download/' + fileName;
|
||
subkit.httpRequest.get(url, subkit.options, function(status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 200) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve(result.text());
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
},
|
||
delete: function(fileName, callback){
|
||
var deferred = subkit.$q.defer();
|
||
var url = subkit.baseUrl + '/file/' + fileName;
|
||
subkit.httpRequest.del(url, subkit.options, function(status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 200 && status!==202 && status!==204) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve(result.json());
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
},
|
||
list: function (callback){
|
||
var deferred = subkit.$q.defer();
|
||
var url = subkit.baseUrl + '/file';
|
||
subkit.httpRequest.get(url, subkit.options, function(status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 200) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve(result.json());
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
},
|
||
open: function(fileName, callback){
|
||
var deferred = subkit.$q.defer();
|
||
var url = subkit.baseUrl + '/file/' + fileName;
|
||
subkit.httpRequest.get(url, subkit.options, function(status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 200) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve(result.text());
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
}
|
||
};
|
||
};
|
||
},{}],4:[function(require,module,exports){
|
||
module.exports = function(subkit){
|
||
'use strict';
|
||
|
||
return {
|
||
list: function(callback){
|
||
var deferred = subkit.$q.defer();
|
||
var url = subkit.baseUrl + '/processes';
|
||
var msg = JSON.parse(JSON.stringify(subkit.options));
|
||
msg.data = {filter: '{}'};
|
||
subkit.httpRequest.get(url, msg,function (status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 200) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve(result.json().map(function(itm){
|
||
return itm.value;
|
||
}));
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
},
|
||
get: function(id, callback){
|
||
var deferred = subkit.$q.defer();
|
||
var url = subkit.baseUrl + '/processes/' + id;
|
||
subkit.httpRequest.get(url,subkit.options,function (status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 200) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve(result.json().map(function(itm){
|
||
return itm.value;
|
||
}));
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
},
|
||
run: function(document, callback){
|
||
var deferred = subkit.$q.defer();
|
||
var url = subkit.baseUrl + '/processes/actions/run/' + document.rel;
|
||
var msg = JSON.parse(JSON.stringify(subkit.options));
|
||
msg.data = document;
|
||
subkit.httpRequest.post(url, msg, function(status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 200 && status !== 201 && status!==202) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve(result.json());
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
}
|
||
};
|
||
};
|
||
},{}],5:[function(require,module,exports){
|
||
module.exports = function(subkit){
|
||
'use strict';
|
||
|
||
return {
|
||
};
|
||
};
|
||
},{}],6:[function(require,module,exports){
|
||
module.exports = function(subkit){
|
||
'use strict';
|
||
|
||
return {
|
||
set: function(task, callback){
|
||
var deferred = subkit.$q.defer();
|
||
var msg = JSON.parse(JSON.stringify(subkit.options));
|
||
msg.data = task;
|
||
var url = subkit.baseUrl + '/task/' + task.Name;
|
||
subkit.httpRequest.put(url, msg, function(status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 201 && status!==202) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve(result.json());
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
},
|
||
get: function(taskName, callback){
|
||
var deferred = subkit.$q.defer();
|
||
var url = subkit.baseUrl + '/task/' + taskName;
|
||
subkit.httpRequest.get(url, subkit.options, function(status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 200) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve(result.json());
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
},
|
||
remove: function(taskName, callback){
|
||
var deferred = subkit.$q.defer();
|
||
var url = subkit.baseUrl + '/task/' + taskName;
|
||
subkit.httpRequest.del(url, subkit.options, function(status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 200 && status!==202 && status!==204) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve(result.json());
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
},
|
||
list: function(callback){
|
||
var deferred = subkit.$q.defer();
|
||
var url = subkit.baseUrl + '/task';
|
||
subkit.httpRequest.get(url, subkit.options, function(status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 200) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve(result.json());
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
},
|
||
run: function(taskName, value, callback, logCallback){
|
||
var deferred = subkit.$q.defer();
|
||
var url = subkit.baseUrl + '/task/run/' + taskName;
|
||
var msg = JSON.parse(JSON.stringify(subkit.options));
|
||
msg.data = value;
|
||
subkit.httpRequest.get(url, msg, function(status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 200) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve(result.json());
|
||
}, logCallback);
|
||
return deferred.promise.nodeify(callback);
|
||
}
|
||
};
|
||
};
|
||
},{}],7:[function(require,module,exports){
|
||
module.exports = function(subkit){
|
||
'use strict';
|
||
|
||
return {
|
||
add: function(templateName,template,callback){
|
||
var deferred = subkit.$q.defer();
|
||
var msg = JSON.parse(JSON.stringify(subkit.options));
|
||
msg.headers['Content-Type'] = 'application/octed-stream';
|
||
msg.data = template;
|
||
var url = subkit.baseUrl + '/template/' + templateName;
|
||
subkit.httpRequest.post(url, msg, function(status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 201 && status!==202) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve(result.json());
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
},
|
||
set: function(templateName, template, callback){
|
||
var deferred = subkit.$q.defer();
|
||
var msg = JSON.parse(JSON.stringify(subkit.options));
|
||
msg.headers['Content-Type'] = 'application/octed-stream';
|
||
msg.data = template;
|
||
var url = subkit.baseUrl + '/template/' + templateName;
|
||
subkit.httpRequest.put(url, msg, function(status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 201 && status!==202) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve(result.json());
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
},
|
||
get: function(templateName, callback){
|
||
var deferred = subkit.$q.defer();
|
||
var url = subkit.baseUrl + '/template/' + templateName;
|
||
subkit.httpRequest.get(url, subkit.options, function(status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 200) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve(result.text());
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
},
|
||
remove: function(templateName, callback){
|
||
var deferred = subkit.$q.defer();
|
||
var url = subkit.baseUrl + '/template/' + templateName;
|
||
subkit.httpRequest.del(url, subkit.options, function(status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 200 && status!==202 && status!==204) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve(result.json());
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
},
|
||
list: function(callback){
|
||
var deferred = subkit.$q.defer();
|
||
var url = subkit.baseUrl + '/template';
|
||
subkit.httpRequest.get(url, subkit.options, function(status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 200) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve(result.json());
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
},
|
||
open: function(templateName, metadata, callback){
|
||
var deferred = subkit.$q.defer();
|
||
var url = subkit.baseUrl + '/template/'+templateName+'/actions/render';
|
||
if(metadata){
|
||
subkit.options.cache = true;
|
||
var str = [];
|
||
for(var idx in metadata){
|
||
if (metadata.hasOwnProperty(idx)) {
|
||
str.push(encodeURIComponent(idx) + '=' + encodeURIComponent(metadata[idx]));
|
||
}
|
||
}
|
||
url += '?' + str.join('&');
|
||
}
|
||
|
||
subkit.httpRequest.get(url, subkit.options, function(status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 200) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve(result.text());
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
}
|
||
};
|
||
};
|
||
},{}],8:[function(require,module,exports){
|
||
module.exports = function(subkit){
|
||
'use strict';
|
||
|
||
return {
|
||
login: function(callback){
|
||
var deferred = subkit.$q.defer();
|
||
var url = subkit.baseUrl + '/users/actions/login';
|
||
subkit.httpRequest.authBasic(subkit.options.username, subkit.options.password);
|
||
subkit.httpRequest.post(url, subkit.options, function(status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 200) deferred.reject(new Error('Authentication failed.'));
|
||
else {
|
||
subkit.options.apiKey = result.json().apiKey;
|
||
deferred.resolve({
|
||
apiKey: subkit.options.apiKey,
|
||
username: subkit.options.username,
|
||
password: subkit.options.password,
|
||
baseUrl: subkit.baseUrl
|
||
});
|
||
}
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
},
|
||
listAll: function(callback){
|
||
var deferred = subkit.$q.defer();
|
||
var url = subkit.baseUrl + '/users';
|
||
var msg = JSON.parse(JSON.stringify(subkit.options));
|
||
msg.data = {filter: '{}'};
|
||
subkit.httpRequest.get(url, msg,function (status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 200) deferred.reject(result.json().message);
|
||
else deferred.resolve(result.json().map(function(itm){
|
||
return itm.value;
|
||
}));
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
},
|
||
list: function(callback){
|
||
var deferred = subkit.$q.defer();
|
||
var url = subkit.baseUrl + '/users';
|
||
subkit.httpRequest.get(url,subkit.options,function (status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 200) deferred.reject(result.json().message);
|
||
else deferred.resolve(result.json().map(function(itm){
|
||
return itm.value;
|
||
}));
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
},
|
||
groups: function(callback){
|
||
var deferred = subkit.$q.defer();
|
||
var url = subkit.baseUrl + '/users/groups';
|
||
subkit.httpRequest.get(url,subkit.options,function (status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 200) deferred.reject(result.json().message);
|
||
else {
|
||
result = result.json();
|
||
var results = [];
|
||
for(var idx in result){
|
||
if (result.hasOwnProperty(idx)) results.push(idx);
|
||
}
|
||
deferred.resolve(results);
|
||
}
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
},
|
||
register: function(username, password, callback){
|
||
var deferred = subkit.$q.defer();
|
||
var url = subkit.baseUrl + '/users/actions/register';
|
||
var msg = JSON.parse(JSON.stringify(subkit.options));
|
||
msg.data = {
|
||
username: username,
|
||
password: password
|
||
};
|
||
subkit.httpRequest.post(url, msg, function(status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 201 && status!==202) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve(result.json());
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
},
|
||
remove: function(key, callback){
|
||
var deferred = subkit.$q.defer();
|
||
var url = subkit.baseUrl + '/users/' + key;
|
||
subkit.httpRequest.del(url, subkit.options, function(status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 200 && status!==202 && status!==204) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve(result.json());
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
},
|
||
get: function(key, callback){
|
||
var deferred = subkit.$q.defer();
|
||
var url = subkit.baseUrl + '/users/' + key;
|
||
subkit.httpRequest.get(url,subkit.options,function (status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 200) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve(result.json());
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
},
|
||
set: function(key, account, callback){
|
||
var deferred = subkit.$q.defer();
|
||
var url = subkit.baseUrl + '/users/' + key;
|
||
var msg = JSON.parse(JSON.stringify(subkit.options));
|
||
msg.data = account;
|
||
subkit.httpRequest.put(url, msg, function(status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 200 && status!==202) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve(result.json());
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
}
|
||
};
|
||
};
|
||
},{}],9:[function(require,module,exports){
|
||
/** @module Subkit */
|
||
|
||
/**
|
||
* Subkit
|
||
* @param {object} config - A Subkit configuration
|
||
*/
|
||
module.exports = function(config){
|
||
'use strict';
|
||
|
||
var self = this;
|
||
self.$q = require('q');
|
||
self.user = require('./plugins/user')(self);
|
||
self.file = require('./plugins/file')(self);
|
||
self.task = require('./plugins/task')(self);
|
||
self.template = require('./plugins/template')(self);
|
||
self.email = require('./plugins/email')(self);
|
||
self.flow = require('./plugins/flow')(self);
|
||
self.geolocation = require('./plugins/geolocation')(self);
|
||
self.baas = require('./plugins/baas')(self);
|
||
|
||
/**
|
||
* Generates a UUID.
|
||
* @method subkit.UUID
|
||
* @memberOf module:Subkit#
|
||
* @return {string} - A new UUID
|
||
*/
|
||
self.UUID = function () {
|
||
// http://www.ietf.org/rfc/rfc4122.txt
|
||
var s = [];
|
||
var hexDigits = '0123456789abcdef';
|
||
for (var i = 0; i < 36; i++) {
|
||
s[i] = hexDigits.substr(Math.floor(Math.random() * 0x10), 1);
|
||
}
|
||
s[14] = '4'; // bits 12-15 of the time_hi_and_version field to 0010
|
||
s[19] = hexDigits.substr((s[19] & 0x3) | 0x8, 1); // bits 6-7 of the clock_seq_hi_and_reserved to 01
|
||
s[8] = s[13] = s[18] = s[23] = '-';
|
||
|
||
var uuid = s.join('');
|
||
return uuid;
|
||
};
|
||
|
||
self.manage = {
|
||
/**
|
||
* Login into Subkit backend.
|
||
* @method subkit.manage.login
|
||
* @memberOf module:Subkit#manage
|
||
* @param {callback|undefined} callback - Optional handler function
|
||
* @return {Promise} Q based Promise
|
||
*/
|
||
login: function(callback){
|
||
var deferred = self.$q.defer();
|
||
var url = self.baseUrl + '/manage/login';
|
||
httpRequest.authBasic(self.options.username, self.options.password);
|
||
httpRequest.post(url, self.options, function(status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 200) deferred.reject(new Error(result.json().message));
|
||
else {
|
||
self.options.apiKey = result.json().api.apiKey;
|
||
deferred.resolve({
|
||
apiKey: self.options.apiKey,
|
||
username: self.options.username,
|
||
password: self.options.password,
|
||
baseUrl: self.baseUrl
|
||
});
|
||
}
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
},
|
||
/**
|
||
* Import data.
|
||
* @method subkit.manage.import
|
||
* @memberOf module:Subkit#
|
||
* @param {file} file - A file as Blob
|
||
* @param {callback|undefined} callback - Optional handler function
|
||
* @return {Promise} Q based Promise
|
||
*/
|
||
import: function(file, callback){
|
||
var deferred = self.$q.defer();
|
||
var msg = JSON.parse(JSON.stringify(self.options));
|
||
msg.headers = {
|
||
'Content-Type': 'application/octed-stream',
|
||
apiKey: config.apiKey
|
||
};
|
||
msg.data = file;
|
||
var url = self.baseUrl + '/manage/import';
|
||
httpRequest.post(url, msg, function(status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 201) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve(result.json());
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
},
|
||
export: function(callback){
|
||
var deferred = self.$q.defer();
|
||
var url = self.baseUrl + '/manage/export';
|
||
httpRequest.get(url, self.options, function(status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 200) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve('data:application/octet-stream,' + result.text());
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
},
|
||
backup: function(callback){
|
||
if(callback) callback();
|
||
},
|
||
restore: function(name, callback){
|
||
if(callback) callback();
|
||
},
|
||
acl:{
|
||
list: function(identity, callback){
|
||
var url = self.baseUrl + '/shares/';
|
||
|
||
if(typeof identity === 'function'){
|
||
url += 'identities';
|
||
callback = identity;
|
||
} else {
|
||
url += identity;
|
||
}
|
||
|
||
httpRequest.get(url, self.options, function(status, result){
|
||
if(!callback) return;
|
||
if(status === 0) return callback({message: 'No network connection.'});
|
||
if(status !== 200) return callback(result.json());
|
||
callback(null, result.json());
|
||
});
|
||
},
|
||
set: function(key, callback){
|
||
var url = self.baseUrl + '/shares/' + encodeURIComponent(key);
|
||
httpRequest.post(url, self.options, function(status, result){
|
||
if(!callback) return;
|
||
if(status === 0) return callback({message: 'No network connection.'});
|
||
if(status !== 201) return callback(result.json());
|
||
callback(null, result.json());
|
||
});
|
||
},
|
||
remove: function(key, callback){
|
||
var url = self.baseUrl + '/shares/' + encodeURIComponent(key);
|
||
httpRequest.del(url, self.options, function(status, result){
|
||
if(!callback) return;
|
||
if(status === 0) return callback({message: 'No network connection.'});
|
||
if(status !== 202) return callback(result.json());
|
||
callback(null, result.json());
|
||
});
|
||
},
|
||
grantWrite: function(key, identity, callback){
|
||
var url = self.baseUrl + '/shares/' + encodeURIComponent(key) + '/actions/grantwrite/' + identity;
|
||
httpRequest.put(url, self.options, function(status, result){
|
||
if(!callback) return;
|
||
if(status === 0) return callback({message: 'No network connection.'});
|
||
if(status !== 202) return callback(result.json());
|
||
callback(null, result.json());
|
||
});
|
||
},
|
||
grantDelete: function(key, identity, callback){
|
||
var url = self.baseUrl + '/shares/' + encodeURIComponent(key) + '/actions/grantdelete/' + identity;
|
||
httpRequest.put(url, self.options, function(status, result){
|
||
if(!callback) return;
|
||
if(status === 0) return callback({message: 'No network connection.'});
|
||
if(status !== 202) return callback(result.json());
|
||
callback(null, result.json());
|
||
});
|
||
},
|
||
grantRead: function(key, identity, callback){
|
||
var url = self.baseUrl + '/shares/' + encodeURIComponent(key) + '/actions/grantread/' + identity;
|
||
httpRequest.put(url, self.options, function(status, result){
|
||
if(!callback) return;
|
||
if(status === 0) return callback({message: 'No network connection.'});
|
||
if(status !== 202) return callback(result.json());
|
||
callback(null, result.json());
|
||
});
|
||
},
|
||
revokeWrite: function(key, identity, callback){
|
||
var url = self.baseUrl + '/shares/' + encodeURIComponent(key) + '/actions/revokewrite/' + identity;
|
||
httpRequest.put(url, self.options, function(status, result){
|
||
if(!callback) return;
|
||
if(status === 0) return callback({message: 'No network connection.'});
|
||
if(status !== 202) return callback(result.json());
|
||
callback(null, result.json());
|
||
});
|
||
},
|
||
revokeDelete: function(key, identity, callback){
|
||
var url = self.baseUrl + '/shares/' + encodeURIComponent(key) + '/actions/revokedelete/' + identity;
|
||
httpRequest.put(url, self.options, function(status, result){
|
||
if(!callback) return;
|
||
if(status === 0) return callback({message: 'No network connection.'});
|
||
if(status !== 202) return callback(result.json());
|
||
callback(null, result.json());
|
||
});
|
||
},
|
||
revokeRead: function(key, identity, callback){
|
||
var url = self.baseUrl + '/shares/' + encodeURIComponent(key) + '/actions/revokeread/' + identity;
|
||
httpRequest.put(url, self.options, function(status, result){
|
||
if(!callback) return;
|
||
if(status === 0) return callback({message: 'No network connection.'});
|
||
if(status !== 202) return callback(result.json());
|
||
callback(null, result.json());
|
||
});
|
||
}
|
||
},
|
||
password: {
|
||
set: function(oldPassword, newPassword, verifyPassword, callback){
|
||
var deferred = self.$q.defer();
|
||
var url = self.baseUrl + '/manage/password/actions/reset';
|
||
var msg = JSON.parse(JSON.stringify(self.options));
|
||
msg.data = {
|
||
password: oldPassword,
|
||
newPassword: newPassword,
|
||
newPasswordValidation: verifyPassword
|
||
};
|
||
httpRequest.put(url, msg, function(status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 200 && status !== 202) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve(result.json());
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
}
|
||
},
|
||
user: {
|
||
set: function(username, callback){
|
||
var deferred = self.$q.defer();
|
||
var url = self.baseUrl + '/manage/user';
|
||
var msg = JSON.parse(JSON.stringify(self.options));
|
||
msg.data = {
|
||
username: username
|
||
};
|
||
httpRequest.put(url, msg, function(status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 200 && status !== 202) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve(result.json());
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
}
|
||
},
|
||
apikey: {
|
||
reset: function(callback){
|
||
var deferred = self.$q.defer();
|
||
var url = self.baseUrl + '/manage/apikey/actions/reset';
|
||
httpRequest.put(url, self.options, function(status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 200 && status !== 202) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve(result.json());
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
}
|
||
},
|
||
certificate:{
|
||
get: function(callback){
|
||
var deferred = self.$q.defer();
|
||
var url = self.baseUrl + '/manage/certificate';
|
||
httpRequest.get(url, self.options, function(status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 200) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve(result.json());
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
},
|
||
set: function(certificate, key, callback){
|
||
var deferred = self.$q.defer();
|
||
var url = self.baseUrl + '/manage/certificate/actions/change';
|
||
var msg = JSON.parse(JSON.stringify(self.options));
|
||
msg.data = {
|
||
certificate: certificate,
|
||
key: key
|
||
};
|
||
httpRequest.put(url, msg, function(status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 200 && status !== 201 && status !== 202) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve(result.json());
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
}
|
||
},
|
||
status: {
|
||
get: function(callback){
|
||
var deferred = self.$q.defer();
|
||
var url = self.baseUrl + '/manage/os';
|
||
httpRequest.get(url, self.options, function(status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 200) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve(result.json());
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
}
|
||
},
|
||
plugin: {
|
||
list: function(callback){
|
||
var deferred = self.$q.defer();
|
||
var url = self.baseUrl + '/plugin';
|
||
httpRequest.get(url, self.options, function(status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 200) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve(result.json());
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
}
|
||
}
|
||
};
|
||
self.store = function(store){
|
||
var _prepareUrl = function(key){
|
||
if(store && !key) return self.baseUrl + '/stores/' + store;
|
||
if(store && key) return self.baseUrl + '/stores/' + store + '/' + key;
|
||
if(!store && key && key.indexOf('!') !== -1) {
|
||
key = key.replace(/^[a-zA-z0-9]\/\//, '!');
|
||
return self.baseUrl + '/stores/' + key;
|
||
}
|
||
if(!store && key) return self.baseUrl + '/stores/' + key;
|
||
return self.baseUrl + '/stores';
|
||
};
|
||
var Continuation = function(){
|
||
var self = this;
|
||
self.doneResult = function(){};
|
||
self.errorResult = function(){};
|
||
self.done = function(callback){
|
||
self.doneResult = callback;
|
||
return self;
|
||
};
|
||
self.error = function(callback){
|
||
self.errorResult = callback;
|
||
return self;
|
||
};
|
||
};
|
||
var pollingRequestRef = null;
|
||
|
||
var ref = {
|
||
key: function(){
|
||
return self.UUID();
|
||
},
|
||
import: function(file, callback){
|
||
var msg = JSON.parse(JSON.stringify(self.options));
|
||
msg.headers = {
|
||
'Content-Type': 'application/octed-stream',
|
||
apiKey: config.apiKey
|
||
};
|
||
msg.data = file;
|
||
var url = self.baseUrl + '/manage/import/' + store;
|
||
httpRequest.post(url, msg, function(status, result){
|
||
if(!callback) return;
|
||
if(status === 0) return callback({message: 'No network connection.'});
|
||
if(status !== 201) return callback(result.json());
|
||
callback(null, result.json());
|
||
});
|
||
},
|
||
export: function(callback){
|
||
var url = self.baseUrl + '/manage/export/' + store;
|
||
httpRequest.get(url, self.options, function(status, result){
|
||
if(!callback) return;
|
||
if(status === 0) return callback({message: 'No network connection.'});
|
||
if(status !== 200) return callback(result.json());
|
||
callback(null, 'data:application/octet-stream,' + result.text());
|
||
});
|
||
},
|
||
set: function(key, value, callback){
|
||
key = arguments[0];
|
||
value = arguments[1];
|
||
|
||
if(arguments.length === 1 && key instanceof Object){
|
||
value = key;
|
||
key = self.UUID();
|
||
}
|
||
var url = _prepareUrl(key);
|
||
var continueWith = new Continuation();
|
||
var msg = JSON.parse(JSON.stringify(self.options));
|
||
msg.data = value;
|
||
|
||
httpRequest.post(url, msg, function(status, result){
|
||
if(status!==200 && status!==201) {
|
||
continueWith.errorResult(result.text());
|
||
_changeStatus(result.text());
|
||
if(callback) callback(result.text());
|
||
}else{
|
||
continueWith.doneResult(result.json());
|
||
if(callback) callback(null, result.json());
|
||
}
|
||
});
|
||
return continueWith;
|
||
},
|
||
get: function(key, callback){
|
||
var continueWith = new Continuation();
|
||
httpRequest.get(_prepareUrl(key), self.options, function(status, result){
|
||
if(status===0 && status!==200) {
|
||
continueWith.errorResult(result.text());
|
||
_changeStatus(result.text());
|
||
if(callback) callback(result.text());
|
||
}else{
|
||
continueWith.doneResult(result.json());
|
||
if(callback) callback(null, result.json());
|
||
}
|
||
});
|
||
return continueWith;
|
||
},
|
||
remove: function(key, callback){
|
||
var continueWith = new Continuation();
|
||
httpRequest.del(_prepareUrl(key), self.options, function(status, result){
|
||
if(status!==200 && status!==202) {
|
||
continueWith.errorResult(result.text());
|
||
_changeStatus(result.text());
|
||
if(callback) callback(result.text());
|
||
}else{
|
||
continueWith.doneResult(result.json());
|
||
if(callback) callback(null, result.json());
|
||
}
|
||
});
|
||
return continueWith;
|
||
},
|
||
history: function(callback){
|
||
var continueWith = new Continuation();
|
||
var result = [];
|
||
continueWith.doneResult(result);
|
||
if(callback) callback(null, result);
|
||
return ref;
|
||
},
|
||
on: function(callback){
|
||
if(self.subscribed[store] && pollingRequestRef) {
|
||
pollingRequestRef().abort();
|
||
}
|
||
self.subscribed[store] = true;
|
||
pollingRequestRef = _poll(store, self.clientId, callback);
|
||
_changeStatus('subscribed to ' + store);
|
||
return ref;
|
||
},
|
||
off: function(){
|
||
delete self.subscribed[store];
|
||
if(pollingRequestRef) pollingRequestRef().abort();
|
||
_changeStatus('unsubscribed from ' + store);
|
||
return ref;
|
||
}
|
||
};
|
||
return ref;
|
||
};
|
||
self.notify = {
|
||
upload: function(provider, env, file, callback){
|
||
var deferred = self.$q.defer();
|
||
var msg = JSON.parse(JSON.stringify(self.options));
|
||
msg.headers = {
|
||
'Content-Type': 'application/octed-stream',
|
||
apiKey: config.apiKey
|
||
};
|
||
msg.data = file;
|
||
var url = self.baseUrl + '/push/upload/' + provider + '/' + env;
|
||
httpRequest.post(url, msg, function(status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status!==200 && status !== 201 && status!==202) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve(result.json());
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
},
|
||
send: function(value, callback){
|
||
var deferred = self.$q.defer();
|
||
var url = self.baseUrl + '/push/send';
|
||
var msg = JSON.parse(JSON.stringify(self.options));
|
||
msg.data = value;
|
||
httpRequest.post(url, msg, function(status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status!==200 && status !== 201 && status!==202) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve(result.json());
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
},
|
||
settings: {
|
||
load: function(callback){
|
||
var deferred = self.$q.defer();
|
||
var url = self.baseUrl + '/push/settings';
|
||
httpRequest.get(url, self.options, function(status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 200) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve(result.json());
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
},
|
||
save: function(value, callback){
|
||
var deferred = self.$q.defer();
|
||
var url = self.baseUrl + '/push/settings';
|
||
var msg = JSON.parse(JSON.stringify(self.options));
|
||
msg.data = value;
|
||
httpRequest.put(url, msg, function(status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status!==200 && status !== 201 && status!==202) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve(result.json());
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
}
|
||
}
|
||
};
|
||
self.pubsub = {
|
||
channels: function(callback){
|
||
var deferred = self.$q.defer();
|
||
var url = self.baseUrl + '/pubsub/channels';
|
||
httpRequest.get(url, self.options, function(status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 200) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve(result.json());
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
},
|
||
push: function(channel, value, callback){
|
||
var deferred = self.$q.defer();
|
||
var url = self.baseUrl + '/pubsub/channel/publish/' + channel;
|
||
var msg = JSON.parse(JSON.stringify(self.options));
|
||
msg.data = value;
|
||
httpRequest.post(url, msg, function(status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 200 && status !== 201 && status !== 202) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve(result.json());
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
},
|
||
on: function(channel, callback) {
|
||
channel = channel.replace('/', '_');
|
||
self.subscribed[channel] = true;
|
||
_changeStatus('subscribed to ' + channel);
|
||
var pollingRequestRef = _poll(channel, self.clientId, callback);
|
||
return {
|
||
off: function(){
|
||
delete self.subscribed[channel];
|
||
if(pollingRequestRef) pollingRequestRef().abort();
|
||
_changeStatus('unsubscribed from ' + channel);
|
||
},
|
||
push: function(value, callback){
|
||
self.pubsub.push(channel, value, callback);
|
||
}
|
||
};
|
||
}
|
||
};
|
||
self.statistics = {
|
||
minutes: function(callback){
|
||
var deferred = self.$q.defer();
|
||
var url = self.baseUrl + '/statistics/minutes';
|
||
httpRequest.get(url, self.options, function(status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 200) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve(result.json());
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
},
|
||
summary: function(callback){
|
||
var deferred = self.$q.defer();
|
||
var url = self.baseUrl + '/statistics/summary';
|
||
httpRequest.get(url, self.options, function(status, result){
|
||
if (status === 0) deferred.reject(new Error('No network connection.'));
|
||
else if (status !== 200) deferred.reject(new Error(result.json().message));
|
||
else deferred.resolve(result.json());
|
||
});
|
||
return deferred.promise.nodeify(callback);
|
||
}
|
||
};
|
||
|
||
var getXhr = function (callback) {
|
||
if (window.XMLHttpRequest) {
|
||
return callback(null, new XMLHttpRequest());
|
||
} else if (window.ActiveXObject) {
|
||
try {
|
||
return callback(null, new ActiveXObject('Msxml2.XMLHTTP'));
|
||
} catch (e) {
|
||
return callback(null, new ActiveXObject('Microsoft.XMLHTTP'));
|
||
}
|
||
}
|
||
return callback(new Error());
|
||
};
|
||
var encodeUsingUrlEncoding = function (data) {
|
||
if(typeof data === 'string') {
|
||
return data;
|
||
}
|
||
|
||
var result = [];
|
||
for(var dataItem in data) {
|
||
if(data.hasOwnProperty(dataItem)) {
|
||
result.push(encodeURIComponent(dataItem) + '=' + encodeURIComponent(data[dataItem]));
|
||
}
|
||
}
|
||
|
||
return result.join('&');
|
||
};
|
||
var utf8 = function (text) {
|
||
text = text.replace(/\r\n/g, '\n');
|
||
var result = '';
|
||
|
||
for(var i = 0; i < text.length; i++) {
|
||
var c = text.charCodeAt(i);
|
||
|
||
if(c < 128) {
|
||
result += String.fromCharCode(c);
|
||
} else if((c > 127) && (c < 2048)) {
|
||
result += String.fromCharCode((c >> 6) | 192);
|
||
result += String.fromCharCode((c & 63) | 128);
|
||
} else {
|
||
result += String.fromCharCode((c >> 12) | 224);
|
||
result += String.fromCharCode(((c >> 6) & 63) | 128);
|
||
result += String.fromCharCode((c & 63) | 128);
|
||
}
|
||
}
|
||
|
||
return result;
|
||
};
|
||
var base64 = function (text) {
|
||
var keyStr = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
|
||
|
||
text = utf8(text);
|
||
var result = '',
|
||
chr1, chr2, chr3,
|
||
enc1, enc2, enc3, enc4,
|
||
i = 0;
|
||
|
||
do {
|
||
chr1 = text.charCodeAt(i++);
|
||
chr2 = text.charCodeAt(i++);
|
||
chr3 = text.charCodeAt(i++);
|
||
|
||
enc1 = chr1 >> 2;
|
||
enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
|
||
enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
|
||
enc4 = chr3 & 63;
|
||
|
||
if(isNaN(chr2)) {
|
||
enc3 = enc4 = 64;
|
||
} else if(isNaN(chr3)) {
|
||
enc4 = 64;
|
||
}
|
||
|
||
result +=
|
||
keyStr.charAt(enc1) +
|
||
keyStr.charAt(enc2) +
|
||
keyStr.charAt(enc3) +
|
||
keyStr.charAt(enc4);
|
||
chr1 = chr2 = chr3 = '';
|
||
enc1 = enc2 = enc3 = enc4 = '';
|
||
} while(i < text.length);
|
||
|
||
return result;
|
||
};
|
||
var mergeHeaders = function () {
|
||
var result = arguments[0];
|
||
for(var i = 1; i < arguments.length; i++) {
|
||
var currentHeaders = arguments[i];
|
||
for(var header in currentHeaders) {
|
||
if(currentHeaders.hasOwnProperty(header)) {
|
||
result[header] = currentHeaders[header];
|
||
}
|
||
}
|
||
}
|
||
return result;
|
||
};
|
||
var ajax = function (method, url, options, callback, logCallback) {
|
||
if(typeof options === 'function') {
|
||
callback = options;
|
||
options = {};
|
||
}
|
||
options.cache = options.cache || true;
|
||
options.headers = options.headers || {};
|
||
options.jsonp = options.jsonp || false;
|
||
|
||
var headers = mergeHeaders({
|
||
'accept': '*/*',
|
||
'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8',
|
||
'x-auth-token': options.apiKey
|
||
}, ajax.headers, options.headers);
|
||
var payload;
|
||
|
||
if(options.data) {
|
||
if ((method === 'GET') && (headers['Content-Type'] === 'application/json')) {
|
||
payload = encodeUsingUrlEncoding(options.data);
|
||
}
|
||
else if (headers['Content-Type'] === 'application/json') {
|
||
payload = JSON.stringify(options.data);
|
||
}
|
||
else if(headers['Content-Type'].indexOf('application/octed-stream') !== -1){
|
||
payload = options.data;
|
||
}
|
||
else {
|
||
payload = encodeUsingUrlEncoding(options.data);
|
||
}
|
||
}
|
||
|
||
if(method === 'GET') {
|
||
var queryString = [];
|
||
if(payload) {
|
||
queryString.push(payload);
|
||
payload = null;
|
||
}
|
||
|
||
if(!options.cache) {
|
||
queryString.push('_=' + (new Date()).getTime());
|
||
}
|
||
|
||
if(options.jsonp) {
|
||
queryString.push('callback=' + options.jsonp);
|
||
queryString.push('jsonp=' + options.jsonp);
|
||
}
|
||
|
||
queryString = '?' + queryString.join('&');
|
||
url += queryString !== '?' ? queryString : '';
|
||
|
||
if(options.jsonp) {
|
||
var head = document.getElementsByTagName('head')[0];
|
||
var script = document.createElement('script');
|
||
script.type = 'text/javascript';
|
||
script.src = url;
|
||
head.appendChild(script);
|
||
return;
|
||
}
|
||
}
|
||
var xhrRef = null;
|
||
getXhr(function (err, xhr) {
|
||
xhrRef = xhr;
|
||
if(err) return callback(err);
|
||
xhr.open(method, url, options.async || true);
|
||
for(var header in headers) {
|
||
if(headers.hasOwnProperty(header)) {
|
||
xhr.setRequestHeader(header, headers[header]);
|
||
}
|
||
}
|
||
xhr.onerror = function(){
|
||
callback(xhr.status, {
|
||
text: function () {
|
||
return xhr.statusText;
|
||
}
|
||
});
|
||
};
|
||
xhr.onreadystatechange = function () {
|
||
if(xhr.readyState === 4 && xhr.status !== 0) {
|
||
var log = this.getResponseHeader('subkit-log');
|
||
if(logCallback) logCallback(log);
|
||
|
||
if(!callback) return;
|
||
var data = xhr.responseText || '';
|
||
callback(xhr.status, {
|
||
text: function () {
|
||
return data;
|
||
},
|
||
json: function () {
|
||
if(data) return JSON.parse(data);
|
||
return {};
|
||
},
|
||
headers: function(){
|
||
return xhr.getAllResponseHeaders();
|
||
}
|
||
});
|
||
}
|
||
};
|
||
|
||
xhr.send(payload);
|
||
});
|
||
return xhrRef;
|
||
};
|
||
var httpRequest = {
|
||
authBasic: function (username, password) {
|
||
httpRequest.headers({});
|
||
ajax.headers['Authorization'] = 'Basic ' + base64(username + ':' + password);
|
||
},
|
||
connect: function (url, options, callback, logCallback) {
|
||
return ajax('CONNECT', url, options, callback, logCallback);
|
||
},
|
||
del: function (url, options, callback, logCallback) {
|
||
return ajax('DELETE', url, options, callback, logCallback);
|
||
},
|
||
get: function (url, options, callback, logCallback) {
|
||
return ajax('GET', url, options, callback, logCallback);
|
||
},
|
||
head: function (url, options, callback, logCallback) {
|
||
return ajax('HEAD', url, options, callback, logCallback);
|
||
},
|
||
headers: function (headers) {
|
||
ajax.headers = headers || {};
|
||
},
|
||
isAllowed: function (url, verb, callback, logCallback) {
|
||
this.options(url, function (status, data) {
|
||
callback(data.text().indexOf(verb) !== -1);
|
||
}, logCallback);
|
||
},
|
||
options: function (url, options, callback, logCallback) {
|
||
return ajax('OPTIONS', url, options, callback, logCallback);
|
||
},
|
||
patch: function (url, options, callback, logCallback) {
|
||
return ajax('PATCH', url, options, callback, logCallback);
|
||
},
|
||
post: function (url, options, callback, logCallback) {
|
||
return ajax('POST', url, options, callback, logCallback);
|
||
},
|
||
put: function (url, options, callback, logCallback) {
|
||
return ajax('PUT', url, options, callback, logCallback);
|
||
},
|
||
trace: function (url, options, callback, logCallback) {
|
||
return ajax('TRACE', url, options, callback, logCallback);
|
||
}
|
||
};
|
||
var _init = function(){
|
||
var clientId = window.sessionStorage.getItem('clientId');
|
||
if(!clientId) {
|
||
clientId = self.UUID();
|
||
window.sessionStorage.setItem('clientId', clientId);
|
||
}
|
||
return clientId;
|
||
};
|
||
self.clientId = config.clientId || _init();
|
||
self.baseUrl = config.baseUrl || ((window.location.origin.indexOf('http') !== -1) ? window.location.origin : 'https://localhost:8080');
|
||
self.options = {
|
||
apiKey: config.apiKey || '',
|
||
username: config.username || '',
|
||
password: config.password || '',
|
||
headers : {
|
||
'Content-Type': 'application/json'
|
||
}
|
||
};
|
||
var statusListeners = [];
|
||
self.subscribed = {};
|
||
var _changeStatus = function(status){
|
||
if(status.json) status = status.json();
|
||
|
||
statusListeners.forEach(function(listener){
|
||
listener(status);
|
||
});
|
||
};
|
||
self.httpRequest = httpRequest;
|
||
|
||
var _poll = function(channel, clientId, callback) {
|
||
var subscribeUrl = self.baseUrl + '/pubsub/subscribe/' + channel + '/' + clientId;
|
||
var request = null;
|
||
var count = 1;
|
||
|
||
(function _pollRef(){
|
||
request = httpRequest.get(subscribeUrl, self.options, function(status, result){
|
||
if(status !== 200) {
|
||
if(self.subscribed[channel]){
|
||
callback({message: 'subscription error - retry'});
|
||
setTimeout(function(){_pollRef(channel, clientId, callback);},300*count++);
|
||
}
|
||
}else{
|
||
count = 1;
|
||
result.json().forEach(function(item){
|
||
callback(null, item.value);
|
||
});
|
||
if(self.subscribed[channel]) _pollRef(channel, clientId, callback);
|
||
}
|
||
});
|
||
})();
|
||
|
||
return function(){
|
||
return request;
|
||
};
|
||
};
|
||
};
|
||
},{"./plugins/baas":1,"./plugins/email":2,"./plugins/file":3,"./plugins/flow":4,"./plugins/geolocation":5,"./plugins/task":6,"./plugins/template":7,"./plugins/user":8,"q":11}],10:[function(require,module,exports){
|
||
// shim for using process in browser
|
||
|
||
var process = module.exports = {};
|
||
|
||
process.nextTick = (function () {
|
||
var canSetImmediate = typeof window !== 'undefined'
|
||
&& window.setImmediate;
|
||
var canPost = typeof window !== 'undefined'
|
||
&& window.postMessage && window.addEventListener
|
||
;
|
||
|
||
if (canSetImmediate) {
|
||
return function (f) { return window.setImmediate(f) };
|
||
}
|
||
|
||
if (canPost) {
|
||
var queue = [];
|
||
window.addEventListener('message', function (ev) {
|
||
var source = ev.source;
|
||
if ((source === window || source === null) && ev.data === 'process-tick') {
|
||
ev.stopPropagation();
|
||
if (queue.length > 0) {
|
||
var fn = queue.shift();
|
||
fn();
|
||
}
|
||
}
|
||
}, true);
|
||
|
||
return function nextTick(fn) {
|
||
queue.push(fn);
|
||
window.postMessage('process-tick', '*');
|
||
};
|
||
}
|
||
|
||
return function nextTick(fn) {
|
||
setTimeout(fn, 0);
|
||
};
|
||
})();
|
||
|
||
process.title = 'browser';
|
||
process.browser = true;
|
||
process.env = {};
|
||
process.argv = [];
|
||
|
||
process.binding = function (name) {
|
||
throw new Error('process.binding is not supported');
|
||
}
|
||
|
||
// TODO(shtylman)
|
||
process.cwd = function () { return '/' };
|
||
process.chdir = function (dir) {
|
||
throw new Error('process.chdir is not supported');
|
||
};
|
||
|
||
},{}],11:[function(require,module,exports){
|
||
var process=require("__browserify_process");// vim:ts=4:sts=4:sw=4:
|
||
/*!
|
||
*
|
||
* Copyright 2009-2012 Kris Kowal under the terms of the MIT
|
||
* license found at http://github.com/kriskowal/q/raw/master/LICENSE
|
||
*
|
||
* With parts by Tyler Close
|
||
* Copyright 2007-2009 Tyler Close under the terms of the MIT X license found
|
||
* at http://www.opensource.org/licenses/mit-license.html
|
||
* Forked at ref_send.js version: 2009-05-11
|
||
*
|
||
* With parts by Mark Miller
|
||
* Copyright (C) 2011 Google Inc.
|
||
*
|
||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||
* you may not use this file except in compliance with the License.
|
||
* You may obtain a copy of the License at
|
||
*
|
||
* http://www.apache.org/licenses/LICENSE-2.0
|
||
*
|
||
* Unless required by applicable law or agreed to in writing, software
|
||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
* See the License for the specific language governing permissions and
|
||
* limitations under the License.
|
||
*
|
||
*/
|
||
|
||
(function (definition) {
|
||
// Turn off strict mode for this function so we can assign to global.Q
|
||
/* jshint strict: false */
|
||
|
||
// This file will function properly as a <script> tag, or a module
|
||
// using CommonJS and NodeJS or RequireJS module formats. In
|
||
// Common/Node/RequireJS, the module exports the Q API and when
|
||
// executed as a simple <script>, it creates a Q global instead.
|
||
|
||
// Montage Require
|
||
if (typeof bootstrap === "function") {
|
||
bootstrap("promise", definition);
|
||
|
||
// CommonJS
|
||
} else if (typeof exports === "object") {
|
||
module.exports = definition();
|
||
|
||
// RequireJS
|
||
} else if (typeof define === "function" && define.amd) {
|
||
define(definition);
|
||
|
||
// SES (Secure EcmaScript)
|
||
} else if (typeof ses !== "undefined") {
|
||
if (!ses.ok()) {
|
||
return;
|
||
} else {
|
||
ses.makeQ = definition;
|
||
}
|
||
|
||
// <script>
|
||
} else {
|
||
Q = definition();
|
||
}
|
||
|
||
})(function () {
|
||
"use strict";
|
||
|
||
var hasStacks = false;
|
||
try {
|
||
throw new Error();
|
||
} catch (e) {
|
||
hasStacks = !!e.stack;
|
||
}
|
||
|
||
// All code after this point will be filtered from stack traces reported
|
||
// by Q.
|
||
var qStartingLine = captureLine();
|
||
var qFileName;
|
||
|
||
// shims
|
||
|
||
// used for fallback in "allResolved"
|
||
var noop = function () {};
|
||
|
||
// Use the fastest possible means to execute a task in a future turn
|
||
// of the event loop.
|
||
var nextTick =(function () {
|
||
// linked list of tasks (single, with head node)
|
||
var head = {task: void 0, next: null};
|
||
var tail = head;
|
||
var flushing = false;
|
||
var requestTick = void 0;
|
||
var isNodeJS = false;
|
||
|
||
function flush() {
|
||
/* jshint loopfunc: true */
|
||
|
||
while (head.next) {
|
||
head = head.next;
|
||
var task = head.task;
|
||
head.task = void 0;
|
||
var domain = head.domain;
|
||
|
||
if (domain) {
|
||
head.domain = void 0;
|
||
domain.enter();
|
||
}
|
||
|
||
try {
|
||
task();
|
||
|
||
} catch (e) {
|
||
if (isNodeJS) {
|
||
// In node, uncaught exceptions are considered fatal errors.
|
||
// Re-throw them synchronously to interrupt flushing!
|
||
|
||
// Ensure continuation if the uncaught exception is suppressed
|
||
// listening "uncaughtException" events (as domains does).
|
||
// Continue in next event to avoid tick recursion.
|
||
if (domain) {
|
||
domain.exit();
|
||
}
|
||
setTimeout(flush, 0);
|
||
if (domain) {
|
||
domain.enter();
|
||
}
|
||
|
||
throw e;
|
||
|
||
} else {
|
||
// In browsers, uncaught exceptions are not fatal.
|
||
// Re-throw them asynchronously to avoid slow-downs.
|
||
setTimeout(function() {
|
||
throw e;
|
||
}, 0);
|
||
}
|
||
}
|
||
|
||
if (domain) {
|
||
domain.exit();
|
||
}
|
||
}
|
||
|
||
flushing = false;
|
||
}
|
||
|
||
nextTick = function (task) {
|
||
tail = tail.next = {
|
||
task: task,
|
||
domain: isNodeJS && process.domain,
|
||
next: null
|
||
};
|
||
|
||
if (!flushing) {
|
||
flushing = true;
|
||
requestTick();
|
||
}
|
||
};
|
||
|
||
if (typeof process !== "undefined" && process.nextTick) {
|
||
// Node.js before 0.9. Note that some fake-Node environments, like the
|
||
// Mocha test runner, introduce a `process` global without a `nextTick`.
|
||
isNodeJS = true;
|
||
|
||
requestTick = function () {
|
||
process.nextTick(flush);
|
||
};
|
||
|
||
} else if (typeof setImmediate === "function") {
|
||
// In IE10, Node.js 0.9+, or https://github.com/NobleJS/setImmediate
|
||
if (typeof window !== "undefined") {
|
||
requestTick = setImmediate.bind(window, flush);
|
||
} else {
|
||
requestTick = function () {
|
||
setImmediate(flush);
|
||
};
|
||
}
|
||
|
||
} else if (typeof MessageChannel !== "undefined") {
|
||
// modern browsers
|
||
// http://www.nonblocking.io/2011/06/windownexttick.html
|
||
var channel = new MessageChannel();
|
||
// At least Safari Version 6.0.5 (8536.30.1) intermittently cannot create
|
||
// working message ports the first time a page loads.
|
||
channel.port1.onmessage = function () {
|
||
requestTick = requestPortTick;
|
||
channel.port1.onmessage = flush;
|
||
flush();
|
||
};
|
||
var requestPortTick = function () {
|
||
// Opera requires us to provide a message payload, regardless of
|
||
// whether we use it.
|
||
channel.port2.postMessage(0);
|
||
};
|
||
requestTick = function () {
|
||
setTimeout(flush, 0);
|
||
requestPortTick();
|
||
};
|
||
|
||
} else {
|
||
// old browsers
|
||
requestTick = function () {
|
||
setTimeout(flush, 0);
|
||
};
|
||
}
|
||
|
||
return nextTick;
|
||
})();
|
||
|
||
// Attempt to make generics safe in the face of downstream
|
||
// modifications.
|
||
// There is no situation where this is necessary.
|
||
// If you need a security guarantee, these primordials need to be
|
||
// deeply frozen anyway, and if you don’t need a security guarantee,
|
||
// this is just plain paranoid.
|
||
// However, this **might** have the nice side-effect of reducing the size of
|
||
// the minified code by reducing x.call() to merely x()
|
||
// See Mark Miller’s explanation of what this does.
|
||
// http://wiki.ecmascript.org/doku.php?id=conventions:safe_meta_programming
|
||
var call = Function.call;
|
||
function uncurryThis(f) {
|
||
return function () {
|
||
return call.apply(f, arguments);
|
||
};
|
||
}
|
||
// This is equivalent, but slower:
|
||
// uncurryThis = Function_bind.bind(Function_bind.call);
|
||
// http://jsperf.com/uncurrythis
|
||
|
||
var array_slice = uncurryThis(Array.prototype.slice);
|
||
|
||
var array_reduce = uncurryThis(
|
||
Array.prototype.reduce || function (callback, basis) {
|
||
var index = 0,
|
||
length = this.length;
|
||
// concerning the initial value, if one is not provided
|
||
if (arguments.length === 1) {
|
||
// seek to the first value in the array, accounting
|
||
// for the possibility that is is a sparse array
|
||
do {
|
||
if (index in this) {
|
||
basis = this[index++];
|
||
break;
|
||
}
|
||
if (++index >= length) {
|
||
throw new TypeError();
|
||
}
|
||
} while (1);
|
||
}
|
||
// reduce
|
||
for (; index < length; index++) {
|
||
// account for the possibility that the array is sparse
|
||
if (index in this) {
|
||
basis = callback(basis, this[index], index);
|
||
}
|
||
}
|
||
return basis;
|
||
}
|
||
);
|
||
|
||
var array_indexOf = uncurryThis(
|
||
Array.prototype.indexOf || function (value) {
|
||
// not a very good shim, but good enough for our one use of it
|
||
for (var i = 0; i < this.length; i++) {
|
||
if (this[i] === value) {
|
||
return i;
|
||
}
|
||
}
|
||
return -1;
|
||
}
|
||
);
|
||
|
||
var array_map = uncurryThis(
|
||
Array.prototype.map || function (callback, thisp) {
|
||
var self = this;
|
||
var collect = [];
|
||
array_reduce(self, function (undefined, value, index) {
|
||
collect.push(callback.call(thisp, value, index, self));
|
||
}, void 0);
|
||
return collect;
|
||
}
|
||
);
|
||
|
||
var object_create = Object.create || function (prototype) {
|
||
function Type() { }
|
||
Type.prototype = prototype;
|
||
return new Type();
|
||
};
|
||
|
||
var object_hasOwnProperty = uncurryThis(Object.prototype.hasOwnProperty);
|
||
|
||
var object_keys = Object.keys || function (object) {
|
||
var keys = [];
|
||
for (var key in object) {
|
||
if (object_hasOwnProperty(object, key)) {
|
||
keys.push(key);
|
||
}
|
||
}
|
||
return keys;
|
||
};
|
||
|
||
var object_toString = uncurryThis(Object.prototype.toString);
|
||
|
||
function isObject(value) {
|
||
return value === Object(value);
|
||
}
|
||
|
||
// generator related shims
|
||
|
||
// FIXME: Remove this function once ES6 generators are in SpiderMonkey.
|
||
function isStopIteration(exception) {
|
||
return (
|
||
object_toString(exception) === "[object StopIteration]" ||
|
||
exception instanceof QReturnValue
|
||
);
|
||
}
|
||
|
||
// FIXME: Remove this helper and Q.return once ES6 generators are in
|
||
// SpiderMonkey.
|
||
var QReturnValue;
|
||
if (typeof ReturnValue !== "undefined") {
|
||
QReturnValue = ReturnValue;
|
||
} else {
|
||
QReturnValue = function (value) {
|
||
this.value = value;
|
||
};
|
||
}
|
||
|
||
// long stack traces
|
||
|
||
var STACK_JUMP_SEPARATOR = "From previous event:";
|
||
|
||
function makeStackTraceLong(error, promise) {
|
||
// If possible, transform the error stack trace by removing Node and Q
|
||
// cruft, then concatenating with the stack trace of `promise`. See #57.
|
||
if (hasStacks &&
|
||
promise.stack &&
|
||
typeof error === "object" &&
|
||
error !== null &&
|
||
error.stack &&
|
||
error.stack.indexOf(STACK_JUMP_SEPARATOR) === -1
|
||
) {
|
||
var stacks = [];
|
||
for (var p = promise; !!p; p = p.source) {
|
||
if (p.stack) {
|
||
stacks.unshift(p.stack);
|
||
}
|
||
}
|
||
stacks.unshift(error.stack);
|
||
|
||
var concatedStacks = stacks.join("\n" + STACK_JUMP_SEPARATOR + "\n");
|
||
error.stack = filterStackString(concatedStacks);
|
||
}
|
||
}
|
||
|
||
function filterStackString(stackString) {
|
||
var lines = stackString.split("\n");
|
||
var desiredLines = [];
|
||
for (var i = 0; i < lines.length; ++i) {
|
||
var line = lines[i];
|
||
|
||
if (!isInternalFrame(line) && !isNodeFrame(line) && line) {
|
||
desiredLines.push(line);
|
||
}
|
||
}
|
||
return desiredLines.join("\n");
|
||
}
|
||
|
||
function isNodeFrame(stackLine) {
|
||
return stackLine.indexOf("(module.js:") !== -1 ||
|
||
stackLine.indexOf("(node.js:") !== -1;
|
||
}
|
||
|
||
function getFileNameAndLineNumber(stackLine) {
|
||
// Named functions: "at functionName (filename:lineNumber:columnNumber)"
|
||
// In IE10 function name can have spaces ("Anonymous function") O_o
|
||
var attempt1 = /at .+ \((.+):(\d+):(?:\d+)\)$/.exec(stackLine);
|
||
if (attempt1) {
|
||
return [attempt1[1], Number(attempt1[2])];
|
||
}
|
||
|
||
// Anonymous functions: "at filename:lineNumber:columnNumber"
|
||
var attempt2 = /at ([^ ]+):(\d+):(?:\d+)$/.exec(stackLine);
|
||
if (attempt2) {
|
||
return [attempt2[1], Number(attempt2[2])];
|
||
}
|
||
|
||
// Firefox style: "function@filename:lineNumber or @filename:lineNumber"
|
||
var attempt3 = /.*@(.+):(\d+)$/.exec(stackLine);
|
||
if (attempt3) {
|
||
return [attempt3[1], Number(attempt3[2])];
|
||
}
|
||
}
|
||
|
||
function isInternalFrame(stackLine) {
|
||
var fileNameAndLineNumber = getFileNameAndLineNumber(stackLine);
|
||
|
||
if (!fileNameAndLineNumber) {
|
||
return false;
|
||
}
|
||
|
||
var fileName = fileNameAndLineNumber[0];
|
||
var lineNumber = fileNameAndLineNumber[1];
|
||
|
||
return fileName === qFileName &&
|
||
lineNumber >= qStartingLine &&
|
||
lineNumber <= qEndingLine;
|
||
}
|
||
|
||
// discover own file name and line number range for filtering stack
|
||
// traces
|
||
function captureLine() {
|
||
if (!hasStacks) {
|
||
return;
|
||
}
|
||
|
||
try {
|
||
throw new Error();
|
||
} catch (e) {
|
||
var lines = e.stack.split("\n");
|
||
var firstLine = lines[0].indexOf("@") > 0 ? lines[1] : lines[2];
|
||
var fileNameAndLineNumber = getFileNameAndLineNumber(firstLine);
|
||
if (!fileNameAndLineNumber) {
|
||
return;
|
||
}
|
||
|
||
qFileName = fileNameAndLineNumber[0];
|
||
return fileNameAndLineNumber[1];
|
||
}
|
||
}
|
||
|
||
function deprecate(callback, name, alternative) {
|
||
return function () {
|
||
if (typeof console !== "undefined" &&
|
||
typeof console.warn === "function") {
|
||
console.warn(name + " is deprecated, use " + alternative +
|
||
" instead.", new Error("").stack);
|
||
}
|
||
return callback.apply(callback, arguments);
|
||
};
|
||
}
|
||
|
||
// end of shims
|
||
// beginning of real work
|
||
|
||
/**
|
||
* Constructs a promise for an immediate reference, passes promises through, or
|
||
* coerces promises from different systems.
|
||
* @param value immediate reference or promise
|
||
*/
|
||
function Q(value) {
|
||
// If the object is already a Promise, return it directly. This enables
|
||
// the resolve function to both be used to created references from objects,
|
||
// but to tolerably coerce non-promises to promises.
|
||
if (isPromise(value)) {
|
||
return value;
|
||
}
|
||
|
||
// assimilate thenables
|
||
if (isPromiseAlike(value)) {
|
||
return coerce(value);
|
||
} else {
|
||
return fulfill(value);
|
||
}
|
||
}
|
||
Q.resolve = Q;
|
||
|
||
/**
|
||
* Performs a task in a future turn of the event loop.
|
||
* @param {Function} task
|
||
*/
|
||
Q.nextTick = nextTick;
|
||
|
||
/**
|
||
* Controls whether or not long stack traces will be on
|
||
*/
|
||
Q.longStackSupport = false;
|
||
|
||
/**
|
||
* Constructs a {promise, resolve, reject} object.
|
||
*
|
||
* `resolve` is a callback to invoke with a more resolved value for the
|
||
* promise. To fulfill the promise, invoke `resolve` with any value that is
|
||
* not a thenable. To reject the promise, invoke `resolve` with a rejected
|
||
* thenable, or invoke `reject` with the reason directly. To resolve the
|
||
* promise to another thenable, thus putting it in the same state, invoke
|
||
* `resolve` with that other thenable.
|
||
*/
|
||
Q.defer = defer;
|
||
function defer() {
|
||
// if "messages" is an "Array", that indicates that the promise has not yet
|
||
// been resolved. If it is "undefined", it has been resolved. Each
|
||
// element of the messages array is itself an array of complete arguments to
|
||
// forward to the resolved promise. We coerce the resolution value to a
|
||
// promise using the `resolve` function because it handles both fully
|
||
// non-thenable values and other thenables gracefully.
|
||
var messages = [], progressListeners = [], resolvedPromise;
|
||
|
||
var deferred = object_create(defer.prototype);
|
||
var promise = object_create(Promise.prototype);
|
||
|
||
promise.promiseDispatch = function (resolve, op, operands) {
|
||
var args = array_slice(arguments);
|
||
if (messages) {
|
||
messages.push(args);
|
||
if (op === "when" && operands[1]) { // progress operand
|
||
progressListeners.push(operands[1]);
|
||
}
|
||
} else {
|
||
nextTick(function () {
|
||
resolvedPromise.promiseDispatch.apply(resolvedPromise, args);
|
||
});
|
||
}
|
||
};
|
||
|
||
// XXX deprecated
|
||
promise.valueOf = function () {
|
||
if (messages) {
|
||
return promise;
|
||
}
|
||
var nearerValue = nearer(resolvedPromise);
|
||
if (isPromise(nearerValue)) {
|
||
resolvedPromise = nearerValue; // shorten chain
|
||
}
|
||
return nearerValue;
|
||
};
|
||
|
||
promise.inspect = function () {
|
||
if (!resolvedPromise) {
|
||
return { state: "pending" };
|
||
}
|
||
return resolvedPromise.inspect();
|
||
};
|
||
|
||
if (Q.longStackSupport && hasStacks) {
|
||
try {
|
||
throw new Error();
|
||
} catch (e) {
|
||
// NOTE: don't try to use `Error.captureStackTrace` or transfer the
|
||
// accessor around; that causes memory leaks as per GH-111. Just
|
||
// reify the stack trace as a string ASAP.
|
||
//
|
||
// At the same time, cut off the first line; it's always just
|
||
// "[object Promise]\n", as per the `toString`.
|
||
promise.stack = e.stack.substring(e.stack.indexOf("\n") + 1);
|
||
}
|
||
}
|
||
|
||
// NOTE: we do the checks for `resolvedPromise` in each method, instead of
|
||
// consolidating them into `become`, since otherwise we'd create new
|
||
// promises with the lines `become(whatever(value))`. See e.g. GH-252.
|
||
|
||
function become(newPromise) {
|
||
resolvedPromise = newPromise;
|
||
promise.source = newPromise;
|
||
|
||
array_reduce(messages, function (undefined, message) {
|
||
nextTick(function () {
|
||
newPromise.promiseDispatch.apply(newPromise, message);
|
||
});
|
||
}, void 0);
|
||
|
||
messages = void 0;
|
||
progressListeners = void 0;
|
||
}
|
||
|
||
deferred.promise = promise;
|
||
deferred.resolve = function (value) {
|
||
if (resolvedPromise) {
|
||
return;
|
||
}
|
||
|
||
become(Q(value));
|
||
};
|
||
|
||
deferred.fulfill = function (value) {
|
||
if (resolvedPromise) {
|
||
return;
|
||
}
|
||
|
||
become(fulfill(value));
|
||
};
|
||
deferred.reject = function (reason) {
|
||
if (resolvedPromise) {
|
||
return;
|
||
}
|
||
|
||
become(reject(reason));
|
||
};
|
||
deferred.notify = function (progress) {
|
||
if (resolvedPromise) {
|
||
return;
|
||
}
|
||
|
||
array_reduce(progressListeners, function (undefined, progressListener) {
|
||
nextTick(function () {
|
||
progressListener(progress);
|
||
});
|
||
}, void 0);
|
||
};
|
||
|
||
return deferred;
|
||
}
|
||
|
||
/**
|
||
* Creates a Node-style callback that will resolve or reject the deferred
|
||
* promise.
|
||
* @returns a nodeback
|
||
*/
|
||
defer.prototype.makeNodeResolver = function () {
|
||
var self = this;
|
||
return function (error, value) {
|
||
if (error) {
|
||
self.reject(error);
|
||
} else if (arguments.length > 2) {
|
||
self.resolve(array_slice(arguments, 1));
|
||
} else {
|
||
self.resolve(value);
|
||
}
|
||
};
|
||
};
|
||
|
||
/**
|
||
* @param resolver {Function} a function that returns nothing and accepts
|
||
* the resolve, reject, and notify functions for a deferred.
|
||
* @returns a promise that may be resolved with the given resolve and reject
|
||
* functions, or rejected by a thrown exception in resolver
|
||
*/
|
||
Q.Promise = promise; // ES6
|
||
Q.promise = promise;
|
||
function promise(resolver) {
|
||
if (typeof resolver !== "function") {
|
||
throw new TypeError("resolver must be a function.");
|
||
}
|
||
var deferred = defer();
|
||
try {
|
||
resolver(deferred.resolve, deferred.reject, deferred.notify);
|
||
} catch (reason) {
|
||
deferred.reject(reason);
|
||
}
|
||
return deferred.promise;
|
||
}
|
||
|
||
promise.race = race; // ES6
|
||
promise.all = all; // ES6
|
||
promise.reject = reject; // ES6
|
||
promise.resolve = Q; // ES6
|
||
|
||
// XXX experimental. This method is a way to denote that a local value is
|
||
// serializable and should be immediately dispatched to a remote upon request,
|
||
// instead of passing a reference.
|
||
Q.passByCopy = function (object) {
|
||
//freeze(object);
|
||
//passByCopies.set(object, true);
|
||
return object;
|
||
};
|
||
|
||
Promise.prototype.passByCopy = function () {
|
||
//freeze(object);
|
||
//passByCopies.set(object, true);
|
||
return this;
|
||
};
|
||
|
||
/**
|
||
* If two promises eventually fulfill to the same value, promises that value,
|
||
* but otherwise rejects.
|
||
* @param x {Any*}
|
||
* @param y {Any*}
|
||
* @returns {Any*} a promise for x and y if they are the same, but a rejection
|
||
* otherwise.
|
||
*
|
||
*/
|
||
Q.join = function (x, y) {
|
||
return Q(x).join(y);
|
||
};
|
||
|
||
Promise.prototype.join = function (that) {
|
||
return Q([this, that]).spread(function (x, y) {
|
||
if (x === y) {
|
||
// TODO: "===" should be Object.is or equiv
|
||
return x;
|
||
} else {
|
||
throw new Error("Can't join: not the same: " + x + " " + y);
|
||
}
|
||
});
|
||
};
|
||
|
||
/**
|
||
* Returns a promise for the first of an array of promises to become fulfilled.
|
||
* @param answers {Array[Any*]} promises to race
|
||
* @returns {Any*} the first promise to be fulfilled
|
||
*/
|
||
Q.race = race;
|
||
function race(answerPs) {
|
||
return promise(function(resolve, reject) {
|
||
// Switch to this once we can assume at least ES5
|
||
// answerPs.forEach(function(answerP) {
|
||
// Q(answerP).then(resolve, reject);
|
||
// });
|
||
// Use this in the meantime
|
||
for (var i = 0, len = answerPs.length; i < len; i++) {
|
||
Q(answerPs[i]).then(resolve, reject);
|
||
}
|
||
});
|
||
}
|
||
|
||
Promise.prototype.race = function () {
|
||
return this.then(Q.race);
|
||
};
|
||
|
||
/**
|
||
* Constructs a Promise with a promise descriptor object and optional fallback
|
||
* function. The descriptor contains methods like when(rejected), get(name),
|
||
* set(name, value), post(name, args), and delete(name), which all
|
||
* return either a value, a promise for a value, or a rejection. The fallback
|
||
* accepts the operation name, a resolver, and any further arguments that would
|
||
* have been forwarded to the appropriate method above had a method been
|
||
* provided with the proper name. The API makes no guarantees about the nature
|
||
* of the returned object, apart from that it is usable whereever promises are
|
||
* bought and sold.
|
||
*/
|
||
Q.makePromise = Promise;
|
||
function Promise(descriptor, fallback, inspect) {
|
||
if (fallback === void 0) {
|
||
fallback = function (op) {
|
||
return reject(new Error(
|
||
"Promise does not support operation: " + op
|
||
));
|
||
};
|
||
}
|
||
if (inspect === void 0) {
|
||
inspect = function () {
|
||
return {state: "unknown"};
|
||
};
|
||
}
|
||
|
||
var promise = object_create(Promise.prototype);
|
||
|
||
promise.promiseDispatch = function (resolve, op, args) {
|
||
var result;
|
||
try {
|
||
if (descriptor[op]) {
|
||
result = descriptor[op].apply(promise, args);
|
||
} else {
|
||
result = fallback.call(promise, op, args);
|
||
}
|
||
} catch (exception) {
|
||
result = reject(exception);
|
||
}
|
||
if (resolve) {
|
||
resolve(result);
|
||
}
|
||
};
|
||
|
||
promise.inspect = inspect;
|
||
|
||
// XXX deprecated `valueOf` and `exception` support
|
||
if (inspect) {
|
||
var inspected = inspect();
|
||
if (inspected.state === "rejected") {
|
||
promise.exception = inspected.reason;
|
||
}
|
||
|
||
promise.valueOf = function () {
|
||
var inspected = inspect();
|
||
if (inspected.state === "pending" ||
|
||
inspected.state === "rejected") {
|
||
return promise;
|
||
}
|
||
return inspected.value;
|
||
};
|
||
}
|
||
|
||
return promise;
|
||
}
|
||
|
||
Promise.prototype.toString = function () {
|
||
return "[object Promise]";
|
||
};
|
||
|
||
Promise.prototype.then = function (fulfilled, rejected, progressed) {
|
||
var self = this;
|
||
var deferred = defer();
|
||
var done = false; // ensure the untrusted promise makes at most a
|
||
// single call to one of the callbacks
|
||
|
||
function _fulfilled(value) {
|
||
try {
|
||
return typeof fulfilled === "function" ? fulfilled(value) : value;
|
||
} catch (exception) {
|
||
return reject(exception);
|
||
}
|
||
}
|
||
|
||
function _rejected(exception) {
|
||
if (typeof rejected === "function") {
|
||
makeStackTraceLong(exception, self);
|
||
try {
|
||
return rejected(exception);
|
||
} catch (newException) {
|
||
return reject(newException);
|
||
}
|
||
}
|
||
return reject(exception);
|
||
}
|
||
|
||
function _progressed(value) {
|
||
return typeof progressed === "function" ? progressed(value) : value;
|
||
}
|
||
|
||
nextTick(function () {
|
||
self.promiseDispatch(function (value) {
|
||
if (done) {
|
||
return;
|
||
}
|
||
done = true;
|
||
|
||
deferred.resolve(_fulfilled(value));
|
||
}, "when", [function (exception) {
|
||
if (done) {
|
||
return;
|
||
}
|
||
done = true;
|
||
|
||
deferred.resolve(_rejected(exception));
|
||
}]);
|
||
});
|
||
|
||
// Progress propagator need to be attached in the current tick.
|
||
self.promiseDispatch(void 0, "when", [void 0, function (value) {
|
||
var newValue;
|
||
var threw = false;
|
||
try {
|
||
newValue = _progressed(value);
|
||
} catch (e) {
|
||
threw = true;
|
||
if (Q.onerror) {
|
||
Q.onerror(e);
|
||
} else {
|
||
throw e;
|
||
}
|
||
}
|
||
|
||
if (!threw) {
|
||
deferred.notify(newValue);
|
||
}
|
||
}]);
|
||
|
||
return deferred.promise;
|
||
};
|
||
|
||
/**
|
||
* Registers an observer on a promise.
|
||
*
|
||
* Guarantees:
|
||
*
|
||
* 1. that fulfilled and rejected will be called only once.
|
||
* 2. that either the fulfilled callback or the rejected callback will be
|
||
* called, but not both.
|
||
* 3. that fulfilled and rejected will not be called in this turn.
|
||
*
|
||
* @param value promise or immediate reference to observe
|
||
* @param fulfilled function to be called with the fulfilled value
|
||
* @param rejected function to be called with the rejection exception
|
||
* @param progressed function to be called on any progress notifications
|
||
* @return promise for the return value from the invoked callback
|
||
*/
|
||
Q.when = when;
|
||
function when(value, fulfilled, rejected, progressed) {
|
||
return Q(value).then(fulfilled, rejected, progressed);
|
||
}
|
||
|
||
Promise.prototype.thenResolve = function (value) {
|
||
return this.then(function () { return value; });
|
||
};
|
||
|
||
Q.thenResolve = function (promise, value) {
|
||
return Q(promise).thenResolve(value);
|
||
};
|
||
|
||
Promise.prototype.thenReject = function (reason) {
|
||
return this.then(function () { throw reason; });
|
||
};
|
||
|
||
Q.thenReject = function (promise, reason) {
|
||
return Q(promise).thenReject(reason);
|
||
};
|
||
|
||
/**
|
||
* If an object is not a promise, it is as "near" as possible.
|
||
* If a promise is rejected, it is as "near" as possible too.
|
||
* If it’s a fulfilled promise, the fulfillment value is nearer.
|
||
* If it’s a deferred promise and the deferred has been resolved, the
|
||
* resolution is "nearer".
|
||
* @param object
|
||
* @returns most resolved (nearest) form of the object
|
||
*/
|
||
|
||
// XXX should we re-do this?
|
||
Q.nearer = nearer;
|
||
function nearer(value) {
|
||
if (isPromise(value)) {
|
||
var inspected = value.inspect();
|
||
if (inspected.state === "fulfilled") {
|
||
return inspected.value;
|
||
}
|
||
}
|
||
return value;
|
||
}
|
||
|
||
/**
|
||
* @returns whether the given object is a promise.
|
||
* Otherwise it is a fulfilled value.
|
||
*/
|
||
Q.isPromise = isPromise;
|
||
function isPromise(object) {
|
||
return isObject(object) &&
|
||
typeof object.promiseDispatch === "function" &&
|
||
typeof object.inspect === "function";
|
||
}
|
||
|
||
Q.isPromiseAlike = isPromiseAlike;
|
||
function isPromiseAlike(object) {
|
||
return isObject(object) && typeof object.then === "function";
|
||
}
|
||
|
||
/**
|
||
* @returns whether the given object is a pending promise, meaning not
|
||
* fulfilled or rejected.
|
||
*/
|
||
Q.isPending = isPending;
|
||
function isPending(object) {
|
||
return isPromise(object) && object.inspect().state === "pending";
|
||
}
|
||
|
||
Promise.prototype.isPending = function () {
|
||
return this.inspect().state === "pending";
|
||
};
|
||
|
||
/**
|
||
* @returns whether the given object is a value or fulfilled
|
||
* promise.
|
||
*/
|
||
Q.isFulfilled = isFulfilled;
|
||
function isFulfilled(object) {
|
||
return !isPromise(object) || object.inspect().state === "fulfilled";
|
||
}
|
||
|
||
Promise.prototype.isFulfilled = function () {
|
||
return this.inspect().state === "fulfilled";
|
||
};
|
||
|
||
/**
|
||
* @returns whether the given object is a rejected promise.
|
||
*/
|
||
Q.isRejected = isRejected;
|
||
function isRejected(object) {
|
||
return isPromise(object) && object.inspect().state === "rejected";
|
||
}
|
||
|
||
Promise.prototype.isRejected = function () {
|
||
return this.inspect().state === "rejected";
|
||
};
|
||
|
||
//// BEGIN UNHANDLED REJECTION TRACKING
|
||
|
||
// This promise library consumes exceptions thrown in handlers so they can be
|
||
// handled by a subsequent promise. The exceptions get added to this array when
|
||
// they are created, and removed when they are handled. Note that in ES6 or
|
||
// shimmed environments, this would naturally be a `Set`.
|
||
var unhandledReasons = [];
|
||
var unhandledRejections = [];
|
||
var trackUnhandledRejections = true;
|
||
|
||
function resetUnhandledRejections() {
|
||
unhandledReasons.length = 0;
|
||
unhandledRejections.length = 0;
|
||
|
||
if (!trackUnhandledRejections) {
|
||
trackUnhandledRejections = true;
|
||
}
|
||
}
|
||
|
||
function trackRejection(promise, reason) {
|
||
if (!trackUnhandledRejections) {
|
||
return;
|
||
}
|
||
|
||
unhandledRejections.push(promise);
|
||
if (reason && typeof reason.stack !== "undefined") {
|
||
unhandledReasons.push(reason.stack);
|
||
} else {
|
||
unhandledReasons.push("(no stack) " + reason);
|
||
}
|
||
}
|
||
|
||
function untrackRejection(promise) {
|
||
if (!trackUnhandledRejections) {
|
||
return;
|
||
}
|
||
|
||
var at = array_indexOf(unhandledRejections, promise);
|
||
if (at !== -1) {
|
||
unhandledRejections.splice(at, 1);
|
||
unhandledReasons.splice(at, 1);
|
||
}
|
||
}
|
||
|
||
Q.resetUnhandledRejections = resetUnhandledRejections;
|
||
|
||
Q.getUnhandledReasons = function () {
|
||
// Make a copy so that consumers can't interfere with our internal state.
|
||
return unhandledReasons.slice();
|
||
};
|
||
|
||
Q.stopUnhandledRejectionTracking = function () {
|
||
resetUnhandledRejections();
|
||
trackUnhandledRejections = false;
|
||
};
|
||
|
||
resetUnhandledRejections();
|
||
|
||
//// END UNHANDLED REJECTION TRACKING
|
||
|
||
/**
|
||
* Constructs a rejected promise.
|
||
* @param reason value describing the failure
|
||
*/
|
||
Q.reject = reject;
|
||
function reject(reason) {
|
||
var rejection = Promise({
|
||
"when": function (rejected) {
|
||
// note that the error has been handled
|
||
if (rejected) {
|
||
untrackRejection(this);
|
||
}
|
||
return rejected ? rejected(reason) : this;
|
||
}
|
||
}, function fallback() {
|
||
return this;
|
||
}, function inspect() {
|
||
return { state: "rejected", reason: reason };
|
||
});
|
||
|
||
// Note that the reason has not been handled.
|
||
trackRejection(rejection, reason);
|
||
|
||
return rejection;
|
||
}
|
||
|
||
/**
|
||
* Constructs a fulfilled promise for an immediate reference.
|
||
* @param value immediate reference
|
||
*/
|
||
Q.fulfill = fulfill;
|
||
function fulfill(value) {
|
||
return Promise({
|
||
"when": function () {
|
||
return value;
|
||
},
|
||
"get": function (name) {
|
||
return value[name];
|
||
},
|
||
"set": function (name, rhs) {
|
||
value[name] = rhs;
|
||
},
|
||
"delete": function (name) {
|
||
delete value[name];
|
||
},
|
||
"post": function (name, args) {
|
||
// Mark Miller proposes that post with no name should apply a
|
||
// promised function.
|
||
if (name === null || name === void 0) {
|
||
return value.apply(void 0, args);
|
||
} else {
|
||
return value[name].apply(value, args);
|
||
}
|
||
},
|
||
"apply": function (thisp, args) {
|
||
return value.apply(thisp, args);
|
||
},
|
||
"keys": function () {
|
||
return object_keys(value);
|
||
}
|
||
}, void 0, function inspect() {
|
||
return { state: "fulfilled", value: value };
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Converts thenables to Q promises.
|
||
* @param promise thenable promise
|
||
* @returns a Q promise
|
||
*/
|
||
function coerce(promise) {
|
||
var deferred = defer();
|
||
nextTick(function () {
|
||
try {
|
||
promise.then(deferred.resolve, deferred.reject, deferred.notify);
|
||
} catch (exception) {
|
||
deferred.reject(exception);
|
||
}
|
||
});
|
||
return deferred.promise;
|
||
}
|
||
|
||
/**
|
||
* Annotates an object such that it will never be
|
||
* transferred away from this process over any promise
|
||
* communication channel.
|
||
* @param object
|
||
* @returns promise a wrapping of that object that
|
||
* additionally responds to the "isDef" message
|
||
* without a rejection.
|
||
*/
|
||
Q.master = master;
|
||
function master(object) {
|
||
return Promise({
|
||
"isDef": function () {}
|
||
}, function fallback(op, args) {
|
||
return dispatch(object, op, args);
|
||
}, function () {
|
||
return Q(object).inspect();
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Spreads the values of a promised array of arguments into the
|
||
* fulfillment callback.
|
||
* @param fulfilled callback that receives variadic arguments from the
|
||
* promised array
|
||
* @param rejected callback that receives the exception if the promise
|
||
* is rejected.
|
||
* @returns a promise for the return value or thrown exception of
|
||
* either callback.
|
||
*/
|
||
Q.spread = spread;
|
||
function spread(value, fulfilled, rejected) {
|
||
return Q(value).spread(fulfilled, rejected);
|
||
}
|
||
|
||
Promise.prototype.spread = function (fulfilled, rejected) {
|
||
return this.all().then(function (array) {
|
||
return fulfilled.apply(void 0, array);
|
||
}, rejected);
|
||
};
|
||
|
||
/**
|
||
* The async function is a decorator for generator functions, turning
|
||
* them into asynchronous generators. Although generators are only part
|
||
* of the newest ECMAScript 6 drafts, this code does not cause syntax
|
||
* errors in older engines. This code should continue to work and will
|
||
* in fact improve over time as the language improves.
|
||
*
|
||
* ES6 generators are currently part of V8 version 3.19 with the
|
||
* --harmony-generators runtime flag enabled. SpiderMonkey has had them
|
||
* for longer, but under an older Python-inspired form. This function
|
||
* works on both kinds of generators.
|
||
*
|
||
* Decorates a generator function such that:
|
||
* - it may yield promises
|
||
* - execution will continue when that promise is fulfilled
|
||
* - the value of the yield expression will be the fulfilled value
|
||
* - it returns a promise for the return value (when the generator
|
||
* stops iterating)
|
||
* - the decorated function returns a promise for the return value
|
||
* of the generator or the first rejected promise among those
|
||
* yielded.
|
||
* - if an error is thrown in the generator, it propagates through
|
||
* every following yield until it is caught, or until it escapes
|
||
* the generator function altogether, and is translated into a
|
||
* rejection for the promise returned by the decorated generator.
|
||
*/
|
||
Q.async = async;
|
||
function async(makeGenerator) {
|
||
return function () {
|
||
// when verb is "send", arg is a value
|
||
// when verb is "throw", arg is an exception
|
||
function continuer(verb, arg) {
|
||
var result;
|
||
|
||
// Until V8 3.19 / Chromium 29 is released, SpiderMonkey is the only
|
||
// engine that has a deployed base of browsers that support generators.
|
||
// However, SM's generators use the Python-inspired semantics of
|
||
// outdated ES6 drafts. We would like to support ES6, but we'd also
|
||
// like to make it possible to use generators in deployed browsers, so
|
||
// we also support Python-style generators. At some point we can remove
|
||
// this block.
|
||
|
||
if (typeof StopIteration === "undefined") {
|
||
// ES6 Generators
|
||
try {
|
||
result = generator[verb](arg);
|
||
} catch (exception) {
|
||
return reject(exception);
|
||
}
|
||
if (result.done) {
|
||
return result.value;
|
||
} else {
|
||
return when(result.value, callback, errback);
|
||
}
|
||
} else {
|
||
// SpiderMonkey Generators
|
||
// FIXME: Remove this case when SM does ES6 generators.
|
||
try {
|
||
result = generator[verb](arg);
|
||
} catch (exception) {
|
||
if (isStopIteration(exception)) {
|
||
return exception.value;
|
||
} else {
|
||
return reject(exception);
|
||
}
|
||
}
|
||
return when(result, callback, errback);
|
||
}
|
||
}
|
||
var generator = makeGenerator.apply(this, arguments);
|
||
var callback = continuer.bind(continuer, "next");
|
||
var errback = continuer.bind(continuer, "throw");
|
||
return callback();
|
||
};
|
||
}
|
||
|
||
/**
|
||
* The spawn function is a small wrapper around async that immediately
|
||
* calls the generator and also ends the promise chain, so that any
|
||
* unhandled errors are thrown instead of forwarded to the error
|
||
* handler. This is useful because it's extremely common to run
|
||
* generators at the top-level to work with libraries.
|
||
*/
|
||
Q.spawn = spawn;
|
||
function spawn(makeGenerator) {
|
||
Q.done(Q.async(makeGenerator)());
|
||
}
|
||
|
||
// FIXME: Remove this interface once ES6 generators are in SpiderMonkey.
|
||
/**
|
||
* Throws a ReturnValue exception to stop an asynchronous generator.
|
||
*
|
||
* This interface is a stop-gap measure to support generator return
|
||
* values in older Firefox/SpiderMonkey. In browsers that support ES6
|
||
* generators like Chromium 29, just use "return" in your generator
|
||
* functions.
|
||
*
|
||
* @param value the return value for the surrounding generator
|
||
* @throws ReturnValue exception with the value.
|
||
* @example
|
||
* // ES6 style
|
||
* Q.async(function* () {
|
||
* var foo = yield getFooPromise();
|
||
* var bar = yield getBarPromise();
|
||
* return foo + bar;
|
||
* })
|
||
* // Older SpiderMonkey style
|
||
* Q.async(function () {
|
||
* var foo = yield getFooPromise();
|
||
* var bar = yield getBarPromise();
|
||
* Q.return(foo + bar);
|
||
* })
|
||
*/
|
||
Q["return"] = _return;
|
||
function _return(value) {
|
||
throw new QReturnValue(value);
|
||
}
|
||
|
||
/**
|
||
* The promised function decorator ensures that any promise arguments
|
||
* are settled and passed as values (`this` is also settled and passed
|
||
* as a value). It will also ensure that the result of a function is
|
||
* always a promise.
|
||
*
|
||
* @example
|
||
* var add = Q.promised(function (a, b) {
|
||
* return a + b;
|
||
* });
|
||
* add(Q(a), Q(B));
|
||
*
|
||
* @param {function} callback The function to decorate
|
||
* @returns {function} a function that has been decorated.
|
||
*/
|
||
Q.promised = promised;
|
||
function promised(callback) {
|
||
return function () {
|
||
return spread([this, all(arguments)], function (self, args) {
|
||
return callback.apply(self, args);
|
||
});
|
||
};
|
||
}
|
||
|
||
/**
|
||
* sends a message to a value in a future turn
|
||
* @param object* the recipient
|
||
* @param op the name of the message operation, e.g., "when",
|
||
* @param args further arguments to be forwarded to the operation
|
||
* @returns result {Promise} a promise for the result of the operation
|
||
*/
|
||
Q.dispatch = dispatch;
|
||
function dispatch(object, op, args) {
|
||
return Q(object).dispatch(op, args);
|
||
}
|
||
|
||
Promise.prototype.dispatch = function (op, args) {
|
||
var self = this;
|
||
var deferred = defer();
|
||
nextTick(function () {
|
||
self.promiseDispatch(deferred.resolve, op, args);
|
||
});
|
||
return deferred.promise;
|
||
};
|
||
|
||
/**
|
||
* Gets the value of a property in a future turn.
|
||
* @param object promise or immediate reference for target object
|
||
* @param name name of property to get
|
||
* @return promise for the property value
|
||
*/
|
||
Q.get = function (object, key) {
|
||
return Q(object).dispatch("get", [key]);
|
||
};
|
||
|
||
Promise.prototype.get = function (key) {
|
||
return this.dispatch("get", [key]);
|
||
};
|
||
|
||
/**
|
||
* Sets the value of a property in a future turn.
|
||
* @param object promise or immediate reference for object object
|
||
* @param name name of property to set
|
||
* @param value new value of property
|
||
* @return promise for the return value
|
||
*/
|
||
Q.set = function (object, key, value) {
|
||
return Q(object).dispatch("set", [key, value]);
|
||
};
|
||
|
||
Promise.prototype.set = function (key, value) {
|
||
return this.dispatch("set", [key, value]);
|
||
};
|
||
|
||
/**
|
||
* Deletes a property in a future turn.
|
||
* @param object promise or immediate reference for target object
|
||
* @param name name of property to delete
|
||
* @return promise for the return value
|
||
*/
|
||
Q.del = // XXX legacy
|
||
Q["delete"] = function (object, key) {
|
||
return Q(object).dispatch("delete", [key]);
|
||
};
|
||
|
||
Promise.prototype.del = // XXX legacy
|
||
Promise.prototype["delete"] = function (key) {
|
||
return this.dispatch("delete", [key]);
|
||
};
|
||
|
||
/**
|
||
* Invokes a method in a future turn.
|
||
* @param object promise or immediate reference for target object
|
||
* @param name name of method to invoke
|
||
* @param value a value to post, typically an array of
|
||
* invocation arguments for promises that
|
||
* are ultimately backed with `resolve` values,
|
||
* as opposed to those backed with URLs
|
||
* wherein the posted value can be any
|
||
* JSON serializable object.
|
||
* @return promise for the return value
|
||
*/
|
||
// bound locally because it is used by other methods
|
||
Q.mapply = // XXX As proposed by "Redsandro"
|
||
Q.post = function (object, name, args) {
|
||
return Q(object).dispatch("post", [name, args]);
|
||
};
|
||
|
||
Promise.prototype.mapply = // XXX As proposed by "Redsandro"
|
||
Promise.prototype.post = function (name, args) {
|
||
return this.dispatch("post", [name, args]);
|
||
};
|
||
|
||
/**
|
||
* Invokes a method in a future turn.
|
||
* @param object promise or immediate reference for target object
|
||
* @param name name of method to invoke
|
||
* @param ...args array of invocation arguments
|
||
* @return promise for the return value
|
||
*/
|
||
Q.send = // XXX Mark Miller's proposed parlance
|
||
Q.mcall = // XXX As proposed by "Redsandro"
|
||
Q.invoke = function (object, name /*...args*/) {
|
||
return Q(object).dispatch("post", [name, array_slice(arguments, 2)]);
|
||
};
|
||
|
||
Promise.prototype.send = // XXX Mark Miller's proposed parlance
|
||
Promise.prototype.mcall = // XXX As proposed by "Redsandro"
|
||
Promise.prototype.invoke = function (name /*...args*/) {
|
||
return this.dispatch("post", [name, array_slice(arguments, 1)]);
|
||
};
|
||
|
||
/**
|
||
* Applies the promised function in a future turn.
|
||
* @param object promise or immediate reference for target function
|
||
* @param args array of application arguments
|
||
*/
|
||
Q.fapply = function (object, args) {
|
||
return Q(object).dispatch("apply", [void 0, args]);
|
||
};
|
||
|
||
Promise.prototype.fapply = function (args) {
|
||
return this.dispatch("apply", [void 0, args]);
|
||
};
|
||
|
||
/**
|
||
* Calls the promised function in a future turn.
|
||
* @param object promise or immediate reference for target function
|
||
* @param ...args array of application arguments
|
||
*/
|
||
Q["try"] =
|
||
Q.fcall = function (object /* ...args*/) {
|
||
return Q(object).dispatch("apply", [void 0, array_slice(arguments, 1)]);
|
||
};
|
||
|
||
Promise.prototype.fcall = function (/*...args*/) {
|
||
return this.dispatch("apply", [void 0, array_slice(arguments)]);
|
||
};
|
||
|
||
/**
|
||
* Binds the promised function, transforming return values into a fulfilled
|
||
* promise and thrown errors into a rejected one.
|
||
* @param object promise or immediate reference for target function
|
||
* @param ...args array of application arguments
|
||
*/
|
||
Q.fbind = function (object /*...args*/) {
|
||
var promise = Q(object);
|
||
var args = array_slice(arguments, 1);
|
||
return function fbound() {
|
||
return promise.dispatch("apply", [
|
||
this,
|
||
args.concat(array_slice(arguments))
|
||
]);
|
||
};
|
||
};
|
||
Promise.prototype.fbind = function (/*...args*/) {
|
||
var promise = this;
|
||
var args = array_slice(arguments);
|
||
return function fbound() {
|
||
return promise.dispatch("apply", [
|
||
this,
|
||
args.concat(array_slice(arguments))
|
||
]);
|
||
};
|
||
};
|
||
|
||
/**
|
||
* Requests the names of the owned properties of a promised
|
||
* object in a future turn.
|
||
* @param object promise or immediate reference for target object
|
||
* @return promise for the keys of the eventually settled object
|
||
*/
|
||
Q.keys = function (object) {
|
||
return Q(object).dispatch("keys", []);
|
||
};
|
||
|
||
Promise.prototype.keys = function () {
|
||
return this.dispatch("keys", []);
|
||
};
|
||
|
||
/**
|
||
* Turns an array of promises into a promise for an array. If any of
|
||
* the promises gets rejected, the whole array is rejected immediately.
|
||
* @param {Array*} an array (or promise for an array) of values (or
|
||
* promises for values)
|
||
* @returns a promise for an array of the corresponding values
|
||
*/
|
||
// By Mark Miller
|
||
// http://wiki.ecmascript.org/doku.php?id=strawman:concurrency&rev=1308776521#allfulfilled
|
||
Q.all = all;
|
||
function all(promises) {
|
||
return when(promises, function (promises) {
|
||
var countDown = 0;
|
||
var deferred = defer();
|
||
array_reduce(promises, function (undefined, promise, index) {
|
||
var snapshot;
|
||
if (
|
||
isPromise(promise) &&
|
||
(snapshot = promise.inspect()).state === "fulfilled"
|
||
) {
|
||
promises[index] = snapshot.value;
|
||
} else {
|
||
++countDown;
|
||
when(
|
||
promise,
|
||
function (value) {
|
||
promises[index] = value;
|
||
if (--countDown === 0) {
|
||
deferred.resolve(promises);
|
||
}
|
||
},
|
||
deferred.reject,
|
||
function (progress) {
|
||
deferred.notify({ index: index, value: progress });
|
||
}
|
||
);
|
||
}
|
||
}, void 0);
|
||
if (countDown === 0) {
|
||
deferred.resolve(promises);
|
||
}
|
||
return deferred.promise;
|
||
});
|
||
}
|
||
|
||
Promise.prototype.all = function () {
|
||
return all(this);
|
||
};
|
||
|
||
/**
|
||
* Waits for all promises to be settled, either fulfilled or
|
||
* rejected. This is distinct from `all` since that would stop
|
||
* waiting at the first rejection. The promise returned by
|
||
* `allResolved` will never be rejected.
|
||
* @param promises a promise for an array (or an array) of promises
|
||
* (or values)
|
||
* @return a promise for an array of promises
|
||
*/
|
||
Q.allResolved = deprecate(allResolved, "allResolved", "allSettled");
|
||
function allResolved(promises) {
|
||
return when(promises, function (promises) {
|
||
promises = array_map(promises, Q);
|
||
return when(all(array_map(promises, function (promise) {
|
||
return when(promise, noop, noop);
|
||
})), function () {
|
||
return promises;
|
||
});
|
||
});
|
||
}
|
||
|
||
Promise.prototype.allResolved = function () {
|
||
return allResolved(this);
|
||
};
|
||
|
||
/**
|
||
* @see Promise#allSettled
|
||
*/
|
||
Q.allSettled = allSettled;
|
||
function allSettled(promises) {
|
||
return Q(promises).allSettled();
|
||
}
|
||
|
||
/**
|
||
* Turns an array of promises into a promise for an array of their states (as
|
||
* returned by `inspect`) when they have all settled.
|
||
* @param {Array[Any*]} values an array (or promise for an array) of values (or
|
||
* promises for values)
|
||
* @returns {Array[State]} an array of states for the respective values.
|
||
*/
|
||
Promise.prototype.allSettled = function () {
|
||
return this.then(function (promises) {
|
||
return all(array_map(promises, function (promise) {
|
||
promise = Q(promise);
|
||
function regardless() {
|
||
return promise.inspect();
|
||
}
|
||
return promise.then(regardless, regardless);
|
||
}));
|
||
});
|
||
};
|
||
|
||
/**
|
||
* Captures the failure of a promise, giving an oportunity to recover
|
||
* with a callback. If the given promise is fulfilled, the returned
|
||
* promise is fulfilled.
|
||
* @param {Any*} promise for something
|
||
* @param {Function} callback to fulfill the returned promise if the
|
||
* given promise is rejected
|
||
* @returns a promise for the return value of the callback
|
||
*/
|
||
Q.fail = // XXX legacy
|
||
Q["catch"] = function (object, rejected) {
|
||
return Q(object).then(void 0, rejected);
|
||
};
|
||
|
||
Promise.prototype.fail = // XXX legacy
|
||
Promise.prototype["catch"] = function (rejected) {
|
||
return this.then(void 0, rejected);
|
||
};
|
||
|
||
/**
|
||
* Attaches a listener that can respond to progress notifications from a
|
||
* promise's originating deferred. This listener receives the exact arguments
|
||
* passed to ``deferred.notify``.
|
||
* @param {Any*} promise for something
|
||
* @param {Function} callback to receive any progress notifications
|
||
* @returns the given promise, unchanged
|
||
*/
|
||
Q.progress = progress;
|
||
function progress(object, progressed) {
|
||
return Q(object).then(void 0, void 0, progressed);
|
||
}
|
||
|
||
Promise.prototype.progress = function (progressed) {
|
||
return this.then(void 0, void 0, progressed);
|
||
};
|
||
|
||
/**
|
||
* Provides an opportunity to observe the settling of a promise,
|
||
* regardless of whether the promise is fulfilled or rejected. Forwards
|
||
* the resolution to the returned promise when the callback is done.
|
||
* The callback can return a promise to defer completion.
|
||
* @param {Any*} promise
|
||
* @param {Function} callback to observe the resolution of the given
|
||
* promise, takes no arguments.
|
||
* @returns a promise for the resolution of the given promise when
|
||
* ``fin`` is done.
|
||
*/
|
||
Q.fin = // XXX legacy
|
||
Q["finally"] = function (object, callback) {
|
||
return Q(object)["finally"](callback);
|
||
};
|
||
|
||
Promise.prototype.fin = // XXX legacy
|
||
Promise.prototype["finally"] = function (callback) {
|
||
callback = Q(callback);
|
||
return this.then(function (value) {
|
||
return callback.fcall().then(function () {
|
||
return value;
|
||
});
|
||
}, function (reason) {
|
||
// TODO attempt to recycle the rejection with "this".
|
||
return callback.fcall().then(function () {
|
||
throw reason;
|
||
});
|
||
});
|
||
};
|
||
|
||
/**
|
||
* Terminates a chain of promises, forcing rejections to be
|
||
* thrown as exceptions.
|
||
* @param {Any*} promise at the end of a chain of promises
|
||
* @returns nothing
|
||
*/
|
||
Q.done = function (object, fulfilled, rejected, progress) {
|
||
return Q(object).done(fulfilled, rejected, progress);
|
||
};
|
||
|
||
Promise.prototype.done = function (fulfilled, rejected, progress) {
|
||
var onUnhandledError = function (error) {
|
||
// forward to a future turn so that ``when``
|
||
// does not catch it and turn it into a rejection.
|
||
nextTick(function () {
|
||
makeStackTraceLong(error, promise);
|
||
if (Q.onerror) {
|
||
Q.onerror(error);
|
||
} else {
|
||
throw error;
|
||
}
|
||
});
|
||
};
|
||
|
||
// Avoid unnecessary `nextTick`ing via an unnecessary `when`.
|
||
var promise = fulfilled || rejected || progress ?
|
||
this.then(fulfilled, rejected, progress) :
|
||
this;
|
||
|
||
if (typeof process === "object" && process && process.domain) {
|
||
onUnhandledError = process.domain.bind(onUnhandledError);
|
||
}
|
||
|
||
promise.then(void 0, onUnhandledError);
|
||
};
|
||
|
||
/**
|
||
* Causes a promise to be rejected if it does not get fulfilled before
|
||
* some milliseconds time out.
|
||
* @param {Any*} promise
|
||
* @param {Number} milliseconds timeout
|
||
* @param {String} custom error message (optional)
|
||
* @returns a promise for the resolution of the given promise if it is
|
||
* fulfilled before the timeout, otherwise rejected.
|
||
*/
|
||
Q.timeout = function (object, ms, message) {
|
||
return Q(object).timeout(ms, message);
|
||
};
|
||
|
||
Promise.prototype.timeout = function (ms, message) {
|
||
var deferred = defer();
|
||
var timeoutId = setTimeout(function () {
|
||
deferred.reject(new Error(message || "Timed out after " + ms + " ms"));
|
||
}, ms);
|
||
|
||
this.then(function (value) {
|
||
clearTimeout(timeoutId);
|
||
deferred.resolve(value);
|
||
}, function (exception) {
|
||
clearTimeout(timeoutId);
|
||
deferred.reject(exception);
|
||
}, deferred.notify);
|
||
|
||
return deferred.promise;
|
||
};
|
||
|
||
/**
|
||
* Returns a promise for the given value (or promised value), some
|
||
* milliseconds after it resolved. Passes rejections immediately.
|
||
* @param {Any*} promise
|
||
* @param {Number} milliseconds
|
||
* @returns a promise for the resolution of the given promise after milliseconds
|
||
* time has elapsed since the resolution of the given promise.
|
||
* If the given promise rejects, that is passed immediately.
|
||
*/
|
||
Q.delay = function (object, timeout) {
|
||
if (timeout === void 0) {
|
||
timeout = object;
|
||
object = void 0;
|
||
}
|
||
return Q(object).delay(timeout);
|
||
};
|
||
|
||
Promise.prototype.delay = function (timeout) {
|
||
return this.then(function (value) {
|
||
var deferred = defer();
|
||
setTimeout(function () {
|
||
deferred.resolve(value);
|
||
}, timeout);
|
||
return deferred.promise;
|
||
});
|
||
};
|
||
|
||
/**
|
||
* Passes a continuation to a Node function, which is called with the given
|
||
* arguments provided as an array, and returns a promise.
|
||
*
|
||
* Q.nfapply(FS.readFile, [__filename])
|
||
* .then(function (content) {
|
||
* })
|
||
*
|
||
*/
|
||
Q.nfapply = function (callback, args) {
|
||
return Q(callback).nfapply(args);
|
||
};
|
||
|
||
Promise.prototype.nfapply = function (args) {
|
||
var deferred = defer();
|
||
var nodeArgs = array_slice(args);
|
||
nodeArgs.push(deferred.makeNodeResolver());
|
||
this.fapply(nodeArgs).fail(deferred.reject);
|
||
return deferred.promise;
|
||
};
|
||
|
||
/**
|
||
* Passes a continuation to a Node function, which is called with the given
|
||
* arguments provided individually, and returns a promise.
|
||
* @example
|
||
* Q.nfcall(FS.readFile, __filename)
|
||
* .then(function (content) {
|
||
* })
|
||
*
|
||
*/
|
||
Q.nfcall = function (callback /*...args*/) {
|
||
var args = array_slice(arguments, 1);
|
||
return Q(callback).nfapply(args);
|
||
};
|
||
|
||
Promise.prototype.nfcall = function (/*...args*/) {
|
||
var nodeArgs = array_slice(arguments);
|
||
var deferred = defer();
|
||
nodeArgs.push(deferred.makeNodeResolver());
|
||
this.fapply(nodeArgs).fail(deferred.reject);
|
||
return deferred.promise;
|
||
};
|
||
|
||
/**
|
||
* Wraps a NodeJS continuation passing function and returns an equivalent
|
||
* version that returns a promise.
|
||
* @example
|
||
* Q.nfbind(FS.readFile, __filename)("utf-8")
|
||
* .then(console.log)
|
||
* .done()
|
||
*/
|
||
Q.nfbind =
|
||
Q.denodeify = function (callback /*...args*/) {
|
||
var baseArgs = array_slice(arguments, 1);
|
||
return function () {
|
||
var nodeArgs = baseArgs.concat(array_slice(arguments));
|
||
var deferred = defer();
|
||
nodeArgs.push(deferred.makeNodeResolver());
|
||
Q(callback).fapply(nodeArgs).fail(deferred.reject);
|
||
return deferred.promise;
|
||
};
|
||
};
|
||
|
||
Promise.prototype.nfbind =
|
||
Promise.prototype.denodeify = function (/*...args*/) {
|
||
var args = array_slice(arguments);
|
||
args.unshift(this);
|
||
return Q.denodeify.apply(void 0, args);
|
||
};
|
||
|
||
Q.nbind = function (callback, thisp /*...args*/) {
|
||
var baseArgs = array_slice(arguments, 2);
|
||
return function () {
|
||
var nodeArgs = baseArgs.concat(array_slice(arguments));
|
||
var deferred = defer();
|
||
nodeArgs.push(deferred.makeNodeResolver());
|
||
function bound() {
|
||
return callback.apply(thisp, arguments);
|
||
}
|
||
Q(bound).fapply(nodeArgs).fail(deferred.reject);
|
||
return deferred.promise;
|
||
};
|
||
};
|
||
|
||
Promise.prototype.nbind = function (/*thisp, ...args*/) {
|
||
var args = array_slice(arguments, 0);
|
||
args.unshift(this);
|
||
return Q.nbind.apply(void 0, args);
|
||
};
|
||
|
||
/**
|
||
* Calls a method of a Node-style object that accepts a Node-style
|
||
* callback with a given array of arguments, plus a provided callback.
|
||
* @param object an object that has the named method
|
||
* @param {String} name name of the method of object
|
||
* @param {Array} args arguments to pass to the method; the callback
|
||
* will be provided by Q and appended to these arguments.
|
||
* @returns a promise for the value or error
|
||
*/
|
||
Q.nmapply = // XXX As proposed by "Redsandro"
|
||
Q.npost = function (object, name, args) {
|
||
return Q(object).npost(name, args);
|
||
};
|
||
|
||
Promise.prototype.nmapply = // XXX As proposed by "Redsandro"
|
||
Promise.prototype.npost = function (name, args) {
|
||
var nodeArgs = array_slice(args || []);
|
||
var deferred = defer();
|
||
nodeArgs.push(deferred.makeNodeResolver());
|
||
this.dispatch("post", [name, nodeArgs]).fail(deferred.reject);
|
||
return deferred.promise;
|
||
};
|
||
|
||
/**
|
||
* Calls a method of a Node-style object that accepts a Node-style
|
||
* callback, forwarding the given variadic arguments, plus a provided
|
||
* callback argument.
|
||
* @param object an object that has the named method
|
||
* @param {String} name name of the method of object
|
||
* @param ...args arguments to pass to the method; the callback will
|
||
* be provided by Q and appended to these arguments.
|
||
* @returns a promise for the value or error
|
||
*/
|
||
Q.nsend = // XXX Based on Mark Miller's proposed "send"
|
||
Q.nmcall = // XXX Based on "Redsandro's" proposal
|
||
Q.ninvoke = function (object, name /*...args*/) {
|
||
var nodeArgs = array_slice(arguments, 2);
|
||
var deferred = defer();
|
||
nodeArgs.push(deferred.makeNodeResolver());
|
||
Q(object).dispatch("post", [name, nodeArgs]).fail(deferred.reject);
|
||
return deferred.promise;
|
||
};
|
||
|
||
Promise.prototype.nsend = // XXX Based on Mark Miller's proposed "send"
|
||
Promise.prototype.nmcall = // XXX Based on "Redsandro's" proposal
|
||
Promise.prototype.ninvoke = function (name /*...args*/) {
|
||
var nodeArgs = array_slice(arguments, 1);
|
||
var deferred = defer();
|
||
nodeArgs.push(deferred.makeNodeResolver());
|
||
this.dispatch("post", [name, nodeArgs]).fail(deferred.reject);
|
||
return deferred.promise;
|
||
};
|
||
|
||
/**
|
||
* If a function would like to support both Node continuation-passing-style and
|
||
* promise-returning-style, it can end its internal promise chain with
|
||
* `nodeify(nodeback)`, forwarding the optional nodeback argument. If the user
|
||
* elects to use a nodeback, the result will be sent there. If they do not
|
||
* pass a nodeback, they will receive the result promise.
|
||
* @param object a result (or a promise for a result)
|
||
* @param {Function} nodeback a Node.js-style callback
|
||
* @returns either the promise or nothing
|
||
*/
|
||
Q.nodeify = nodeify;
|
||
function nodeify(object, nodeback) {
|
||
return Q(object).nodeify(nodeback);
|
||
}
|
||
|
||
Promise.prototype.nodeify = function (nodeback) {
|
||
if (nodeback) {
|
||
this.then(function (value) {
|
||
nextTick(function () {
|
||
nodeback(null, value);
|
||
});
|
||
}, function (error) {
|
||
nextTick(function () {
|
||
nodeback(error);
|
||
});
|
||
});
|
||
} else {
|
||
return this;
|
||
}
|
||
};
|
||
|
||
// All code before this point will be filtered from stack traces.
|
||
var qEndingLine = captureLine();
|
||
|
||
return Q;
|
||
|
||
});
|
||
|
||
},{"__browserify_process":10}],12:[function(require,module,exports){
|
||
'use strict';
|
||
|
||
var Subkit = require('Subkit');
|
||
module.exports = Subkit;
|
||
|
||
angular
|
||
.module('subkit', [])
|
||
.value('Subkit', Subkit);
|
||
|
||
angular
|
||
.module('subkit')
|
||
.factory('angularSubkit', function() {
|
||
return function(ref, scope, name, initial) {
|
||
var ask = new AngularSubkit(ref);
|
||
return ask.associate(scope, name, initial);
|
||
};
|
||
});
|
||
|
||
var AngularSubkit = function(ref) {
|
||
if (typeof ref == 'string') throw new Error('Please provide a Subkit reference instead of a URL, eg: new Subkit(url)');
|
||
this._fRef = ref;
|
||
};
|
||
|
||
AngularSubkit.prototype = {
|
||
associate: function($scope, name, initial) {
|
||
var self = this;
|
||
if(!$scope[name]) $scope[name] = initial;
|
||
|
||
var storeRef = this._fRef.store(name);
|
||
storeRef
|
||
.get()
|
||
.done(function(data){
|
||
$scope[name] = data;
|
||
$scope.$apply();
|
||
});
|
||
|
||
storeRef.on(function(error, data) {
|
||
if(error) return console.log(error);
|
||
if(initial instanceof Array){
|
||
if(data.type === 'put') {
|
||
var keyMap = $scope[name].map(function(itm){return itm.key.replace(name+'!','')});
|
||
data.key = data.key.replace(name+'!','')
|
||
var itmIdx = keyMap.indexOf(data.key);
|
||
if(itmIdx!==-1) $scope[name][itmIdx] = data;
|
||
else $scope[name].unshift(data);
|
||
}
|
||
if(data.type === 'del') {
|
||
var keyMap = $scope[name].map(function(itm){return itm.key.replace(name+'!','')});
|
||
var itmIdx = keyMap.indexOf(data.key.replace(name+'!',''));
|
||
$scope[name].splice(itmIdx, 1);
|
||
}
|
||
} else if(initial instanceof Object){
|
||
$scope[name] = data;
|
||
}
|
||
$scope.$apply();
|
||
});
|
||
|
||
return storeRef;
|
||
},
|
||
disassociate: function(name) {
|
||
var self = this;
|
||
this._fRef.off(name);
|
||
},
|
||
_log: function(msg) {
|
||
if (console && console.log) {
|
||
console.log(msg);
|
||
}
|
||
}
|
||
};
|
||
},{"Subkit":9}]},{},[12])
|
||
(12)
|
||
});
|
||
; |