kyper-matter
Version:
Library to provide simple application functionality like authentication and local/session/token storage for Tesselate applications.
1,650 lines (1,425 loc) • 240 kB
JavaScript
(function webpackUniversalModuleDefinition(root, factory) {
if(typeof exports === 'object' && typeof module === 'object')
module.exports = factory();
else if(typeof define === 'function' && define.amd)
define([], factory);
else if(typeof exports === 'object')
exports["Matter"] = factory();
else
root["Matter"] = factory();
})(this, function() {
return /******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId])
/******/ return installedModules[moduleId].exports;
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ exports: {},
/******/ id: moduleId,
/******/ loaded: false
/******/ };
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/ // Flag the module as loaded
/******/ module.loaded = true;
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/ // Load entry module and return exports
/******/ return __webpack_require__(0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _has = __webpack_require__(160);
var _has2 = _interopRequireDefault(_has);
var _every = __webpack_require__(157);
var _every2 = _interopRequireDefault(_every);
var _isArray = __webpack_require__(1);
var _isArray2 = _interopRequireDefault(_isArray);
var _some = __webpack_require__(171);
var _some2 = _interopRequireDefault(_some);
var _isString = __webpack_require__(9);
var _isString2 = _interopRequireDefault(_isString);
var _isObject = __webpack_require__(2);
var _isObject2 = _interopRequireDefault(_isObject);
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _config = __webpack_require__(12);
var _config2 = _interopRequireDefault(_config);
var _logger = __webpack_require__(3);
var _logger2 = _interopRequireDefault(_logger);
var _dom = __webpack_require__(36);
var dom = _interopRequireWildcard(_dom);
var _request = __webpack_require__(38);
var request = _interopRequireWildcard(_request);
var _providerAuth = __webpack_require__(70);
var ProviderAuth = _interopRequireWildcard(_providerAuth);
var _token = __webpack_require__(39);
var _token2 = _interopRequireDefault(_token);
var _envStorage = __webpack_require__(37);
var envStorage = _interopRequireWildcard(_envStorage);
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
var Matter = function () {
/** Constructor
* @param {String|Object} project Project name or object containing project name and owner
*/
function Matter(project, opts) {
_classCallCheck(this, Matter);
if (!project) {
_logger2.default.error({
description: 'Project name required to use Matter.',
func: 'constructor', obj: 'Matter'
});
throw new Error('Project name is required to use Matter');
}
if ((0, _isObject2.default)(project)) {
this.name = project.name;
this.owner = project.owner || null;
} else {
this.name = project;
}
if (opts) {
this.options = opts;
_config2.default.applySettings(opts);
}
_logger2.default.debug({
description: 'Matter object built.', matter: this,
func: 'constructor', obj: 'Matter'
});
}
/** Get current logged in status
* @return {Boolean}
* @example
* //Check if there is an account currently logged in
* if(matter.isLoggedIn){
* console.log('There is currently an account logged in.')
* } else {
* console.warn('There is no account currently logged in.')
* }
*/
_createClass(Matter, [{
key: 'signup',
/** Signup a new user
* @param {Object} signupData - Object containing data to use while signing up to application.
* @param {String} signupData.username - Username of new user (error will be returned if username is taken)
* @param {String} signupData.email - Email of new user (error will be returned if email is already used)
* @param {String} signupData.password - Password to be used with account (will be encrypted).
* @return {Promise}
* @example
* //Signup a new user
* var signupData = {username: 'testuser1', email:'test@email.com', password: 'testpassword'}
* matter.signup(signupData).then(function(signupRes){
* console.log('New user signed up successfully. New account: ', signupRes.account)
* }, function(err){
* console.error('Error signing up:', err)
* })
*/
value: function signup(signupData) {
var _this = this;
_logger2.default.debug({
description: 'Signup called.', signupData: signupData,
func: 'signup', obj: 'Matter'
});
if (!signupData) {
_logger2.default.error({
description: 'Signup information is required to signup.',
func: 'signup', obj: 'Matter'
});
return Promise.reject({
message: 'Signup data is required to signup.',
status: 'NULL_DATA'
});
}
if ((0, _isString2.default)(signupData)) {
return this.authUsingProvider(signupData);
}
// Handle no username or email
if (!signupData.username || !signupData.email) {
_logger2.default.error({
description: 'Email and Username required to signup.',
func: 'signup', obj: 'Matter'
});
return Promise.reject({
message: 'Email and Username required to signup.',
status: 'EMPTY_DATA'
});
}
if (!signupData.password) {
_logger2.default.error({
description: 'Password is required to signup.',
func: 'signup', obj: 'Matter'
});
return Promise.reject({
message: 'Password is required to signup.',
status: 'PASS_REQUIRED'
});
}
return request.post(this.endpoint + '/signup', signupData).then(function (response) {
if (response.token) {
_this.token.string = response.token;
}
if (response.user) {
_this.currentUser = response.user;
}
_logger2.default.info({
description: 'Signup successful.', user: _this.currentUser,
func: 'signup', obj: 'Matter'
});
return _this.currentUser;
})['catch'](function (error) {
_logger2.default.error({
description: 'Error requesting signup.', error: error,
signupData: signupData, func: 'signup', obj: 'Matter'
});
return Promise.reject(error);
});
}
/** Login by username/email
* @param {Object} loginData - Object containing data to use while logging in to application.
* @param {String} loginData.username - Username of user to login as
* @param {String} loginData.email - Email of new user (Optional instead of username)
* @param {String} loginData.password - Password to be used with account (will be encrypted).
* @return {Promise}
* @example
* //Login as 'testuser1'
* var loginData = {username: 'testuser1', password: 'testpassword'}
* matter.login(loginData).then(function(loginRes){
* console.log('New user logged in succesfully. Account: ', loginRes.user)
* }, function(err){
* console.error('Error logging in:', err)
* })
*/
}, {
key: 'login',
value: function login(loginData) {
var _this2 = this;
if (!loginData || !(0, _isObject2.default)(loginData) && !(0, _isString2.default)(loginData)) {
_logger2.default.error({
description: 'Username/Email and Password are required to login',
func: 'login', obj: 'Matter'
});
return Promise.reject({
message: 'Login data is required to login.',
status: 'DATA_REQUIRED'
});
}
// Provider login
if ((0, _isString2.default)(loginData)) {
return this.authUsingProvider(loginData);
}
// No username or email
if (!loginData.username && !loginData.email) {
_logger2.default.error({
description: 'Email or Username required to login.',
func: 'login', obj: 'Matter'
});
return Promise.reject({
message: 'Email or Username required to login.',
status: 'ID_REQUIRED'
});
}
// Handle null or invalid password
if (!loginData.password || loginData.password === '') {
return Promise.reject({
message: 'Password is required to login.',
status: 'PASS_REQUIRED'
});
}
// Username/Email Login
return request.put(this.endpoint + '/login', loginData).then(function (response) {
if (response.data && response.data.status && response.data.status === 409) {
_logger2.default.error({
description: 'User not found.', response: response,
func: 'login', obj: 'Matter'
});
return Promise.reject(response.data);
}
if (response.token) {
_this2.token.string = response.token;
}
if (response.user) {
_this2.currentUser = response.user;
}
_logger2.default.info({
description: 'Successful login.', user: _this2.currentUser,
func: 'login', obj: 'Matter'
});
return _this2.currentUser;
})['catch'](function (error) {
_logger2.default.error({
description: 'Error requesting login.',
error: error, func: 'login', obj: 'Matter'
});
if (error.status === 409 || error.status === 400) {
error = error.response.text;
}
return Promise.reject(error);
});
}
/** logout
* @description Log out of currently logged in user account
* @return {Promise}
* @example
* //Logout of currently logged in account
* matter.logout().then(function(loginRes){
* console.log('Logged out successfully')
* }, function(err){
* console.error('Error logging out:', err)
* })
*/
}, {
key: 'logout',
value: function logout() {
var _this3 = this;
// TODO: Handle logging out of providers
if (!this.isLoggedIn) {
_logger2.default.warn({
description: 'No logged in account to log out.',
func: 'logout', obj: 'Matter'
});
return Promise.reject({
message: 'No logged in account to log out.',
status: 'NULL_ACCOUNT'
});
}
return request.put(this.endpoint + '/logout').then(function (response) {
_logger2.default.info({
description: 'Logout successful.',
response: response, func: 'logout', obj: 'Matter'
});
_this3.currentUser = null;
_this3.token.delete();
return response;
})['catch'](function (error) {
_logger2.default.error({
description: 'Error requesting log out: ',
error: error, func: 'logout', obj: 'Matter'
});
_this3.storage.removeItem(_config2.default.tokenUserDataName);
_this3.token.delete();
return Promise.reject(error);
});
}
/** Authenticate using external provider
* @param {String} provider - Provider name
* @return {Promise}
* @example
* //Signup using google
* matter.authUsingProvider('google').then(function(signupRes){
* console.log('New user logged in succesfully. Account: ', signupRes.user)
* }, function(err){
* console.error('Error logging in:', err)
* })
*/
}, {
key: 'authUsingProvider',
value: function authUsingProvider(provider) {
var _this4 = this;
if (!provider) {
_logger2.default.info({
description: 'Provider required to sign up.',
func: 'authUsingProvider', obj: 'Matter'
});
return Promise.reject({ message: 'Provider data is required to signup.' });
}
return ProviderAuth.authWithServer(provider).then(function (response) {
_logger2.default.info({
description: 'Provider login successful.',
response: response, func: 'authUsingProvider', obj: 'Matter'
});
if (response && response.token) {
_this4.token.string = response.token;
}
if (response && response.user || response.data) {
_this4.currentUser = response.data || response.user;
}
return _this4.currentUser;
}, function (error) {
_logger2.default.error({
description: 'Provider signup error.', error: error,
func: 'authUsingProvider', obj: 'Matter'
});
return Promise.reject(error);
});
}
/** getCurrentUser
* @return {Promise}
* @example
* //Logout of currently logged in account
* matter.getCurrentUser().then(function(currentAccount){
* console.log('Currently logged in account:', currentAccount)
* }, function(err){
* console.error('Error logging out:', err)
* })
*/
}, {
key: 'getCurrentUser',
value: function getCurrentUser() {
var _this5 = this;
if (this.currentUser) {
_logger2.default.debug({
description: 'Current is already available. Returning user.',
func: 'currentUser', obj: 'Matter'
});
return Promise.resolve(this.currentUser);
}
if (!this.isLoggedIn) {
_logger2.default.debug({
description: 'Current user is null.',
func: 'currentUser', obj: 'Matter'
});
return Promise.resolve(null);
}
return request.get(this.endpoint + '/user').then(function (response) {
// TODO: Save user information locally
_logger2.default.log({
description: 'Current User Request responded.',
response: response, func: 'currentUser', obj: 'Matter'
});
_this5.currentUser = response;
return response;
})['catch'](function (error) {
if (error.status === 401) {
_logger2.default.warn({
description: 'Called for current user without token.',
error: error, func: 'currentUser', obj: 'Matter'
});
_token2.default.delete();
return Promise.resolve(null);
}
_logger2.default.error({
description: 'Error requesting current user.',
error: error, func: 'currentUser', obj: 'Matter'
});
return Promise.reject(error);
});
}
/** updateAccount
* @param {Object} updateData - Data to update within profile (only provided data will be modified).
* @return {Promise}
* @example
* //Update current account's profile
* matter.updateAccount().then(function(updatedAccount){
* console.log('Currently logged in account:', updatedAccount)
* }, function(err){
* console.error('Error updating profile:', err)
* })
*/
}, {
key: 'updateAccount',
value: function updateAccount(updateData) {
var _this6 = this;
if (!this.isLoggedIn) {
_logger2.default.error({
description: 'No current user profile to update.',
func: 'updateAccount', obj: 'Matter'
});
return Promise.reject({
message: 'Must be logged in to update account.'
});
}
if (!updateData) {
_logger2.default.error({
description: 'Data is required to update profile.',
func: 'updateAccount', obj: 'Matter'
});
return Promise.reject({
message: 'Data required to update account.',
status: 'NULL_DATA'
});
}
// Send update request
return request.put(this.endpoint + '/users/' + this.currentUser.username, updateData).then(function (response) {
_logger2.default.info({
description: 'Update profile request responded.',
response: response, func: 'updateAccount', obj: 'Matter'
});
_this6.currentUser = response;
return response;
})['catch'](function (error) {
_logger2.default.error({
description: 'Error requesting current user.',
error: error, func: 'updateAccount', obj: 'Matter'
});
return Promise.reject(error);
});
}
/** uploadAvatar
* @description Upload account avatar to Tessellate
* @param {Object} file - File object to upload
* @return {Promise}
* @example
* //Upload image to tessellate
* matter.uploadAvatar(file).then(function(imgUrl){
* console.log('Currently logged in account:', imgUrl)
* }, function(err){
* console.error('Error uploading image:', err)
* })
*/
}, {
key: 'uploadAvatar',
value: function uploadAvatar(file) {
if (!this.isLoggedIn) {
_logger2.default.error({
description: 'Must be logged in to upload an image.',
func: 'uploadAvatar', obj: 'Matter'
});
return Promise.reject({
message: 'Must be logged in to upload image.'
});
}
if (!file) {
_logger2.default.error({
description: 'File is required to upload Avatar.',
func: 'uploadAvatar', obj: 'Matter'
});
return Promise.reject({
message: 'Data required to update profile.',
status: 'NULL_DATA'
});
}
var reqData = { files: [{ key: 'image', file: file }] };
// Send update request
return request.put(this.endpoint + '/users/' + this.currentUser.username + '/avatar', reqData);
}
/** changePassword
* @param {String} updateData New password for account.
* @return {Promise}
* @example
* //Update current account's password
* var newPassword = 'asdfasdfasdf'
* matter.changePassword(newPassword).then(function(updatedAccount){
* console.log('Currently logged in account:', updatedAccount)
* }, function(err){
* console.error('Error changing password:', err)
* })
*/
}, {
key: 'changePassword',
value: function changePassword(newPassword) {
if (!this.isLoggedIn) {
_logger2.default.error({
description: 'No current user profile for which to change password.',
func: 'changePassword', obj: 'Matter'
});
return Promise.reject({
message: 'Must be logged in to change password.'
});
}
// Send update request
return request.put(this.endpoint + '/user/password', newPassword);
}
/** recoverAccount
* @param {String} updateData New password for account.
* @return {Promise}
* @example
* //Recover current users password
* matter.recoverAccount().then(function(updatedAccount){
* console.log('Currently logged in account:', updatedAccount)
* }, function(err){
* console.error('Error updating profile:', err)
* })
*/
}, {
key: 'recoverAccount',
value: function recoverAccount(accountData) {
if (!accountData) {
_logger2.default.error({
description: 'Account data is required to recover an account.',
func: 'recoverAccount', obj: 'Matter'
});
return Promise.reject({ message: 'Account data is required to recover an account.' });
}
var account = {};
if ((0, _isString2.default)(accountData)) {
account = accountData.indexOf('@') !== -1 ? { email: accountData } : { username: accountData };
} else {
account = accountData;
}
_logger2.default.debug({
description: 'Requesting recovery of account.', account: account,
func: 'recoverAccount', obj: 'Matter'
});
return request.put(this.endpoint + '/user/recover', account);
}
/** Check that user is in a single group or in all of a list of groups
* @param {Array} checkGroups - List of groups to check for account membership
* @return {Boolean}
* @example
* //Check for group membership
* var isBoth =
* if(matter.isInGroup('admins')){
* console.log('Current account is an admin!')
* } else {
* console.warn('Current account is not an admin.')
* }
*/
}, {
key: 'isInGroup',
value: function isInGroup(checkGroups) {
var _this7 = this;
if (!this.isLoggedIn) {
_logger2.default.error({
description: 'No logged in user to check for groups.',
func: 'isInGroup', obj: 'Matter'
});
return false;
}
if (!checkGroups) {
_logger2.default.log({
description: 'Invalid group(s).',
func: 'isInGroup', obj: 'Matter'
});
return false;
}
// Check if user is within groups
if ((0, _isString2.default)(checkGroups)) {
var _ret = function () {
var groupName = checkGroups;
// Single role or string list of roles
var groupsArray = groupName.split(',');
if (groupsArray.length > 1) {
// String list of groupts
_logger2.default.info({
description: 'String list of groups.', list: groupsArray,
func: 'isInGroup', obj: 'Matter'
});
return {
v: _this7.isInGroups(groupsArray)
};
}
// Single group
var groups = _this7.token.data.groups || [];
_logger2.default.log({
description: 'Checking if user is in group.',
group: groupName, userGroups: _this7.token.data.groups,
func: 'isInGroup', obj: 'Matter'
});
return {
v: (0, _some2.default)(groups, function (group) {
return groupName === group.name;
})
};
}();
if ((typeof _ret === 'undefined' ? 'undefined' : _typeof(_ret)) === "object") return _ret.v;
}
if ((0, _isArray2.default)(checkGroups)) {
return this.isInGroups(checkGroups);
}
return false;
}
/** Check that user is in all of a list of groups
* @param {Array|String} checkGroups - List of groups to check for account membership
* @return {Boolean}
* @example
* //Check for group membership
* var isBoth = matter.isInGroups(['admins', 'users'])
* if(isBoth){
* console.log('Current account is both an admin and a user')
* } else {
* console.warn('Current account is not both an admin and a user')
* }
*/
}, {
key: 'isInGroups',
value: function isInGroups(checkGroups) {
var _this8 = this;
if (!this.isLoggedIn) {
_logger2.default.log({
description: 'No logged in user to check.',
func: 'isInGroups', obj: 'Matter'
});
return false;
}
if (!checkGroups) {
_logger2.default.log({
description: 'Invalid group(s).',
func: 'isInGroup', obj: 'Matter'
});
return false;
}
// Check if user is in some of the provided groups
if ((0, _isArray2.default)(checkGroups)) {
return (0, _every2.default)(checkGroups.map(function (group) {
if ((0, _isString2.default)(group)) {
// Group is string
return _this8.isInGroup(group);
}
// Group is object
if ((0, _has2.default)(group, 'name')) {
return _this8.isInGroup(group.name);
}
_logger2.default.error({
description: 'Invalid group object.',
group: group, func: 'isInGroups', obj: 'Matter'
});
return false;
}), true);
}
if ((0, _isString2.default)(checkGroups)) {
// TODO: Handle spaces within string list
var groupsArray = checkGroups.split(',');
if (groupsArray.length > 1) {
return this.isInGroups(groupsArray);
}
return this.isInGroup(groupsArray[0]);
}
_logger2.default.error({
description: 'Invalid groups list.',
func: 'isInGroups', obj: 'Matter'
});
return false;
}
}, {
key: 'isLoggedIn',
get: function get() {
return (0, _isString2.default)(this.token.string);
}
/** Endpoint generation that handles default/provided settings and environment
* @return {String} endpoint - endpoint for tessellate application
*/
}, {
key: 'endpoint',
get: function get() {
// Remove url if host is a tessellate server
if (typeof window !== 'undefined' && (0, _has2.default)(window, 'location') && window.location.host.indexOf('tessellate') !== -1) {
_logger2.default.info({
description: 'App is Tessellate and Host is Tessellate Server, serverUrl simplified!',
func: 'endpoint', obj: 'Matter'
});
return '';
}
// Handle tessellate as name
if (this.name !== 'tessellate') {
return this.owner ? _config2.default.serverUrl + '/users/' + this.owner + '/projects/' + this.name : _config2.default.serverUrl + '/projects/' + this.name;
}
return _config2.default.serverUrl;
}
/** Save current user (handled automatically by default)
* @param {Object} userData - Account data to set for current user
* @example
* //Save account response to current user
* matter.currentUser = {username: 'testuser1', email: 'test@email.com'}
* console.log('New current user set:', matter.currentUser)
*/
}, {
key: 'currentUser',
set: function set(userData) {
_logger2.default.debug({
description: 'Current User set.', user: userData,
func: 'currentUser', obj: 'Matter'
});
envStorage.setItem(_config2.default.tokenUserDataName, userData);
}
/** Get currently logged in user or returns null
* @return {Object|null}
* @example
* //Return account if logged in
* if(matter.isLoggedIn){
* console.log('Current user account: ', matter.currentUser)
* } else {
* console.log('No current user. Current user: ', matter.currentUser)
* }
* matter.currentUser
* console.log('New current user set:', matter.currentUser)
*/
,
get: function get() {
if (this.storage.getItem(_config2.default.tokenUserDataName)) {
return this.storage.getItem(_config2.default.tokenUserDataName);
}
return null;
}
/* Utility to handle safley writing to localStorage, sessionStorage, and cookies
* @return {Object}
*/
}, {
key: 'storage',
get: function get() {
return envStorage;
}
/** Utility to handle token writing/deleting/decoding
* @return {Object}
*/
}, {
key: 'token',
get: function get() {
return _token2.default;
}
/** Utils placed in base library
* @return {Object}
*/
}, {
key: 'utils',
get: function get() {
return { logger: _logger2.default, request: request, storage: envStorage, dom: dom };
}
}]);
return Matter;
}();
exports.default = Matter;
module.exports = exports['default'];
/***/ },
/* 1 */
/***/ function(module, exports) {
/**
* Checks if `value` is classified as an `Array` object.
*
* @static
* @memberOf _
* @type {Function}
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
* @example
*
* _.isArray([1, 2, 3]);
* // => true
*
* _.isArray(document.body.children);
* // => false
*
* _.isArray('abc');
* // => false
*
* _.isArray(_.noop);
* // => false
*/
var isArray = Array.isArray;
module.exports = isArray;
/***/ },
/* 2 */
/***/ function(module, exports) {
/**
* Checks if `value` is the [language type](https://es5.github.io/#x8) of `Object`.
* (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
*
* @static
* @memberOf _
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is an object, else `false`.
* @example
*
* _.isObject({});
* // => true
*
* _.isObject([1, 2, 3]);
* // => true
*
* _.isObject(_.noop);
* // => true
*
* _.isObject(null);
* // => false
*/
function isObject(value) {
var type = typeof value;
return !!value && (type == 'object' || type == 'function');
}
module.exports = isObject;
/***/ },
/* 3 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _isString = __webpack_require__(9);
var _isString2 = _interopRequireDefault(_isString);
var _keys = __webpack_require__(10);
var _keys2 = _interopRequireDefault(_keys);
var _omit = __webpack_require__(169);
var _omit2 = _interopRequireDefault(_omit);
var _each = __webpack_require__(156);
var _each2 = _interopRequireDefault(_each);
var _isObject = __webpack_require__(2);
var _isObject2 = _interopRequireDefault(_isObject);
var _config = __webpack_require__(12);
var _config2 = _interopRequireDefault(_config);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
var logger = {
log: function log(logData) {
var msgArgs = buildMessageArgs(logData);
if (_config2.default.logLevel === 'trace') {
runConsoleMethod('log', msgArgs);
}
},
debug: function debug(logData) {
var msgArgs = buildMessageArgs(logData);
if (_config2.default.logLevel === 'trace' || _config2.default.logLevel === 'debug') {
runConsoleMethod('debug', msgArgs);
}
},
info: function info(logData) {
if (_config2.default.logLevel === 'trace' || _config2.default.logLevel === 'debug' || _config2.default.logLevel === 'info') {
var msgArgs = buildMessageArgs(logData);
runConsoleMethod('info', msgArgs);
}
},
warn: function warn(logData) {
var msgArgs = buildMessageArgs(logData);
if (_config2.default.logLevel === 'trace' || _config2.default.logLevel === 'debug' || _config2.default.logLevel === 'info' || _config2.default.logLevel === 'warn') {
runConsoleMethod('warn', msgArgs);
}
},
error: function error(logData) {
var msgArgs = buildMessageArgs(logData);
if (_config2.default.logLevel === 'trace' || _config2.default.logLevel === 'debug' || _config2.default.logLevel === 'info' || _config2.default.logLevel === 'warn' || _config2.default.logLevel === 'error' || _config2.default.logLevel === 'fatal') {
runConsoleMethod('error', msgArgs);
}
}
};
exports.default = logger;
function runConsoleMethod(methodName, methodData) {
// Safley run console methods or use console log
if (methodName && console[methodName]) {
return console[methodName].apply(console, methodData);
} else {
return console.log.apply(console, methodData);
}
}
function buildMessageArgs(logData) {
var msgStr = '';
var msgObj = {};
// TODO: Attach time stamp
// Attach location information to the beginning of message
if ((0, _isObject2.default)(logData)) {
(function () {
if (logData.func) {
if (logData.obj) {
// Object and function provided
msgStr += '[' + logData.obj + '.' + logData.func + '()]\n ';
} else if (logData.file) {
msgStr += '[' + logData.file + ' > ' + logData.func + '()]\n ';
} else {
msgStr += '[' + logData.func + '()]\n ';
}
}
var hideList = ['func', 'obj', 'file'];
// Print each key and its value other than obj and func
(0, _each2.default)((0, _omit2.default)((0, _keys2.default)(logData), hideList), function (key) {
if (hideList.indexOf(key) === -1) {
if (key === 'description' || key === 'message') {
msgStr += logData[key];
return msgStr;
}
msgObj[key] = logData[key];
}
});
msgStr += '\n';
})();
} else if ((0, _isString2.default)(logData)) {
msgStr = logData;
}
return [msgStr, msgObj];
}
module.exports = exports['default'];
/***/ },
/* 4 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(module, global) {var checkGlobal = __webpack_require__(116);
/** Used to determine if values are of the language type `Object`. */
var objectTypes = {
'function': true,
'object': true
};
/** Detect free variable `exports`. */
var freeExports = (objectTypes[typeof exports] && exports && !exports.nodeType)
? exports
: undefined;
/** Detect free variable `module`. */
var freeModule = (objectTypes[typeof module] && module && !module.nodeType)
? module
: undefined;
/** Detect free variable `global` from Node.js. */
var freeGlobal = checkGlobal(freeExports && freeModule && typeof global == 'object' && global);
/** Detect free variable `self`. */
var freeSelf = checkGlobal(objectTypes[typeof self] && self);
/** Detect free variable `window`. */
var freeWindow = checkGlobal(objectTypes[typeof window] && window);
/** Detect `this` as the global object. */
var thisGlobal = checkGlobal(objectTypes[typeof this] && this);
/**
* Used as a reference to the global object.
*
* The `this` value is used if it's the global object to avoid Greasemonkey's
* restricted `window` object, otherwise the `window` object is used.
*/
var root = freeGlobal ||
((freeWindow !== (thisGlobal && thisGlobal.window)) && freeWindow) ||
freeSelf || thisGlobal || Function('return this')();
module.exports = root;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(67)(module), (function() { return this; }())))
/***/ },
/* 5 */
/***/ function(module, exports) {
/**
* Checks if `value` is object-like. A value is object-like if it's not `null`
* and has a `typeof` result of "object".
*
* @static
* @memberOf _
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is object-like, else `false`.
* @example
*
* _.isObjectLike({});
* // => true
*
* _.isObjectLike([1, 2, 3]);
* // => true
*
* _.isObjectLike(_.noop);
* // => false
*
* _.isObjectLike(null);
* // => false
*/
function isObjectLike(value) {
return !!value && typeof value == 'object';
}
module.exports = isObjectLike;
/***/ },
/* 6 */
/***/ function(module, exports, __webpack_require__) {
var getNative = __webpack_require__(17),
root = __webpack_require__(4);
/* Built-in method references that are verified to be native. */
var Map = getNative(root, 'Map');
module.exports = Map;
/***/ },
/* 7 */
/***/ function(module, exports) {
/**
* Checks if `value` is suitable for use as unique object key.
*
* @private
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is suitable, else `false`.
*/
function isKeyable(value) {
var type = typeof value;
return type == 'number' || type == 'boolean' ||
(type == 'string' && value != '__proto__') || value == null;
}
module.exports = isKeyable;
/***/ },
/* 8 */
/***/ function(module, exports, __webpack_require__) {
var isObject = __webpack_require__(2);
/** `Object#toString` result references. */
var funcTag = '[object Function]',
genTag = '[object GeneratorFunction]';
/** Used for built-in method references. */
var objectProto = Object.prototype;
/**
* Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
* of values.
*/
var objectToString = objectProto.toString;
/**
* Checks if `value` is classified as a `Function` object.
*
* @static
* @memberOf _
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
* @example
*
* _.isFunction(_);
* // => true
*
* _.isFunction(/abc/);
* // => false
*/
function isFunction(value) {
// The use of `Object#toString` avoids issues with the `typeof` operator
// in Safari 8 which returns 'object' for typed array constructors, and
// PhantomJS 1.9 which returns 'function' for `NodeList` instances.
var tag = isObject(value) ? objectToString.call(value) : '';
return tag == funcTag || tag == genTag;
}
module.exports = isFunction;
/***/ },
/* 9 */
/***/ function(module, exports, __webpack_require__) {
var isArray = __webpack_require__(1),
isObjectLike = __webpack_require__(5);
/** `Object#toString` result references. */
var stringTag = '[object String]';
/** Used for built-in method references. */
var objectProto = Object.prototype;
/**
* Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
* of values.
*/
var objectToString = objectProto.toString;
/**
* Checks if `value` is classified as a `String` primitive or object.
*
* @static
* @memberOf _
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
* @example
*
* _.isString('abc');
* // => true
*
* _.isString(1);
* // => false
*/
function isString(value) {
return typeof value == 'string' ||
(!isArray(value) && isObjectLike(value) && objectToString.call(value) == stringTag);
}
module.exports = isString;
/***/ },
/* 10 */
/***/ function(module, exports, __webpack_require__) {
var baseHas = __webpack_require__(27),
baseKeys = __webpack_require__(100),
indexKeys = __webpack_require__(60),
isArrayLike = __webpack_require__(11),
isIndex = __webpack_require__(19),
isPrototype = __webpack_require__(32);
/**
* Creates an array of the own enumerable property names of `object`.
*
* **Note:** Non-object values are coerced to objects. See the
* [ES spec](http://ecma-international.org/ecma-262/6.0/#sec-object.keys)
* for more details.
*
* @static
* @memberOf _
* @category Object
* @param {Object} object The object to query.
* @returns {Array} Returns the array of property names.
* @example
*
* function Foo() {
* this.a = 1;
* this.b = 2;
* }
*
* Foo.prototype.c = 3;
*
* _.keys(new Foo);
* // => ['a', 'b'] (iteration order is not guaranteed)
*
* _.keys('hi');
* // => ['0', '1']
*/
function keys(object) {
var isProto = isPrototype(object);
if (!(isProto || isArrayLike(object))) {
return baseKeys(object);
}
var indexes = indexKeys(object),
skipIndexes = !!indexes,
result = indexes || [],
length = result.length;
for (var key in object) {
if (baseHas(object, key) &&
!(skipIndexes && (key == 'length' || isIndex(key, length))) &&
!(isProto && key == 'constructor')) {
result.push(key);
}
}
return result;
}
module.exports = keys;
/***/ },
/* 11 */
/***/ function(module, exports, __webpack_require__) {
var getLength = __webpack_require__(131),
isFunction = __webpack_require__(8),
isLength = __webpack_require__(23);
/**
* Checks if `value` is array-like. A value is considered array-like if it's
* not a function and has a `value.length` that's an integer greater than or
* equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
*
* @static
* @memberOf _
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is array-like, else `false`.
* @example
*
* _.isArrayLike([1, 2, 3]);
* // => true
*
* _.isArrayLike(document.body.children);
* // => true
*
* _.isArrayLike('abc');
* // => true
*
* _.isArrayLike(_.noop);
* // => false
*/
function isArrayLike(value) {
return value != null &&
!(typeof value == 'function' && isFunction(value)) && isLength(getLength(value));
}
module.exports = isArrayLike;
/***/ },
/* 12 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _find = __webpack_require__(158);
var _find2 = _interopRequireDefault(_find);
var _merge = __webpack_require__(168);
var _merge2 = _interopRequireDefault(_merge);
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
var defaultConfig = {
envs: {
local: {
serverUrl: 'http://localhost:4000',
logLevel: 'trace'
},
dev: {
serverUrl: 'http://tessellate-stage.elasticbeanstalk.com',
logLevel: 'debug'
},
stage: {
serverUrl: 'http://tessellate-stage.elasticbeanstalk.com',
logLevel: 'info'
},
prod: {
serverUrl: 'http://tessellate.elasticbeanstalk.com',
logLevel: 'error'
}
},
tokenName: 'tessellate',
tokenDataName: 'tessellate-tokenData',
tokenUserDataName: 'tessellate-currentUser',
oauthioKey: 'sxwuB9Gci8-4pBH7xjD0V_jooNU',
oauthioCDN: 'https://s3.amazonaws.com/kyper-cdn/js/libs/oauthio-web/v0.5.0/oauth.min.js'
};
var instance = null;
var envName = 'prod';
var level = null;
var Config = function () {
function Config() {
_classCallCheck(this, Config);
if (!instance) {
(0, _merge2.default)(this, defaultConfig);
instance = this;
}
return instance;
}
_createClass(Config, [{
key: 'applySettings',
value: function applySettings(settings) {
if (settings) {
(0, _merge2.default)(this, settings);
}
}
}, {
key: 'serverUrl',
get: function get() {
if (typeof window !== 'undefined' && window.location && window.location.host && window.location.host !== '') {
var matchingEnv = (0, _find2.default)(defaultConfig.envs, function (env) {
return env.serverUrl === window.location.host;
});
if (matchingEnv) {
return '';
}
}
return defaultConfig.envs[this.envName].serverUrl;
}
}, {
key: 'logLevel',
set: function set(setLevel) {
level = setLevel;
},
get: function get() {
if (level) {
return level;
}
return defaultConfig.envs[this.envName].logLevel;
}
}, {
key: 'envName',
set: function set(newEnv) {
envName = newEnv;
},
get: function get() {
return envName;
}
}, {
key: 'env',
get: function get() {
if (defaultConfig.envs[this.envName]) {
return defaultConfig.envs[this.envName];
}
}
}]);
return Config;
}();
var config = new Config();
exports.default = config;
module.exports = exports['default'];
/***/ },
/* 13 */
/***/ function(module, exports, __webpack_require__) {
var stackClear = __webpack_require__(149),
stackDelete = __webpack_require__(150),
stackGet = __webpack_require__(151),
stackHas = __webpack_require__(152),
stackSet = __webpack_require__(153);
/**
* Creates a stack cache object to store key-value pairs.
*
* @private
* @constructor
* @param {Array} [values] The values to cache.
*/
function Stack(values) {
var index = -1,
length = values ? values.length : 0;
this.clear();
while (++index < length) {
var entry = values[index];
this.set(entry[0], entry[1]);
}
}
// Add functions to the `Stack` cache.
Stack.prototype.clear = stackClear;
Stack.prototype['delete'] = stackDelete;
Stack.prototype.get = stackGet;
Stack.prototype.has = stackHas;
Stack.prototype.set = stackSet;
module.exports = Stack;
/***/ },
/* 14 */
/***/ function(module, exports) {
/**
* A specialized version of `_.map` for arrays without support for iteratee
* shorthands.
*
* @private
* @param {Array} array The array to iterate over.
* @param {Function} iteratee The function invoked per iteration.
* @returns {Array} Returns the new mapped array.
*/
function arrayMap(array, iteratee) {
var index = -1,
length = array.length,
result = Array(length);
while (++index < length) {
result[index] = iteratee(array[index], index, array);
}
return result;
}
module.exports = arrayMap;
/***/ },
/* 15 */
/***/ function(module, exports, __webpack_require__) {
var eq = __webpack_require__(21);
/**
* Gets the index at which the first occurrence of `key` is found in `array`
* of key-value pairs.
*
* @private
* @param {Array} array The array to search.
* @param {*} key The key to search for.
* @returns {number} Returns the index of the matched value, else `-1`.
*/
function assocIndexOf(array, key) {
var length = array.length;
while (length--) {
if (eq(array[length][0], key)) {
return length;
}
}
return -1;
}
module.exports = assocIndexOf;
/***/ },
/* 16 */
/***/ function(module, exports, __webpack_require__) {
var baseForOwn = __webpack_require__(50),
createBaseEach = __webpack_require__(126);
/**
* The base implementation of `_.forEach` without support for iteratee shorthands.
*
* @private
* @param {Array|Object} collection The collection to iterate over.
* @param {Function} iteratee The function invoked per iteration.
* @returns {Array|Object} Returns `collection`.
*/
var baseEach = createBaseEach(baseForOwn);
module.exports = baseEach;
/***/ },
/* 17 */
/***/ function(module, exports, __webpack_require__) {
var isNative = __webpack_require__(164);
/**
* Gets the native function at `key` of `object`.
*
* @private
* @param {Object} object The object to query.
* @param {string} key The key of the method to get.
* @returns {*} Returns the function if it's native, else `undefined`.
*/
function getNative(object, key) {
var value = object == null ? undefined : object[key];
return isNative(value) ? value : undefined;
}
module.exports = getNative;
/***/ },
/* 18 */
/***/ function(module, exports) {
/**
* Checks if `value` is a host object in IE < 9.
*
* @private
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a host object, else `false`.
*/
function isHostObject(value) {
// Many host objects are `Object` objects that can coerce to strings
// despite having improperly defined `toString` methods.
var result = false;
if (value != null && typeof value.toString != 'function') {
try {
result = !!(value + '');
} catch (e) {}
}
return result;
}
module.exports = isHostObject;
/***/ },
/* 19 */
/***/ function(module, exports) {
/** Used as references for var