angular-meteor-auth/dist/angular-meteor-auth.js

Angular-Meteor authentication module

/*! angular-meteor-auth v1.1.1 */
(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["angularMeteorAuth"] = factory();
	else
		root["angularMeteorAuth"] = 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) {

	'use strict';

	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	var name = 'angular-meteor.auth';
	exports.default = name;


	angular.module(name, ['angular-meteor.mixer', 'angular-meteor.scope', 'angular-meteor.core', 'angular-meteor.view-model', 'angular-meteor.reactive'])

	/*
	  A mixin which provides us with authentication related methods and properties.
	  This mixin comes in a seperate package called `angular-meteor-auth`. Note that `accounts-base`
	  package needs to be installed in order for this module to work, otherwise an error will be thrown.
	 */
	.factory('$$Auth', ['$Mixer', '$log', '$q', function ($Mixer, $log, $q) {
	  var Accounts = (Package['accounts-base'] || {}).Accounts;

	  if (!Accounts) {
	    throw Error('`angular-meteor.auth` module requires `accounts-base` package, ' + 'please run `meteor add accounts-base` before use');
	  }

	  var errors = {
	    required: 'AUTH_REQUIRED',
	    forbidden: 'FORBIDDEN'
	  };

	  function $$Auth() {
	    var vm = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this;

	    // Reset auth properties
	    this.autorun(function () {
	      // Note that we use Meteor and not Accounts since the following methods are
	      // not available in older versions of `accounts-base` meteor package
	      vm.currentUser = Meteor.user();
	      vm.currentUserId = Meteor.userId();
	      vm.isLoggingIn = Meteor.loggingIn();
	    });
	  }

	  // Waits for user to finish the login process. Gets an optional validation function which
	  // will validate if the current user is valid or not. Returns a promise which will be rejected
	  // once login has failed or user is not valid, otherwise it will be resolved with the current
	  // user
	  $$Auth.$awaitUser = function (validate) {
	    var _this = this;

	    validate = validate ? this.$bindToContext($Mixer.caller, validate) : function () {
	      return true;
	    };

	    if (!_.isFunction(validate)) {
	      throw Error('argument 1 must be a function');
	    }

	    var deferred = this.$$defer();

	    // If user is already logged in resolve the promise immediately to prevent an
	    // unnecessary computation
	    if (this.currentUser) {
	      deferred.resolve(this.currentUser);
	      // Keep the schema of the promise consistent
	      deferred.promise.stop = angular.noop;
	      return deferred.promise;
	    }

	    // Note the promise is being fulfilled in the next event loop to avoid
	    // nested computations, otherwise the outer computation will cancel the
	    // inner one once the scope has been destroyed which will lead to subscription
	    // failures. Happens mainly after resolving a route.
	    var computation = this.autorun(function (computation) {
	      if (_this.getReactively('isLoggingIn')) return;
	      // Stop computation once a user has logged in
	      computation.stop();

	      if (!_this.currentUser) return _this.$$afterFlush(deferred.reject, errors.required);

	      $q.when(validate(_this.currentUser)).then(function (isValid) {
	        // Resolve the promise if validation has passed
	        if (isValid === true) {
	          _this.$$afterFlush(deferred.resolve, _this.currentUser);
	        } else {
	          return $q.reject(isValid);
	        }
	      }).catch(function (isValid) {
	        var error = void 0;

	        if (_.isString(isValid) || isValid instanceof Error) {
	          error = isValid;
	        } else {
	          error = errors.forbidden;
	        }

	        _this.$$afterFlush(deferred.reject, error);
	      });
	    });

	    deferred.promise.stop = computation.stop.bind(computation);
	    return deferred.promise;
	  };

	  // Calls a function with the provided args after flush
	  $$Auth.$$afterFlush = function (fn) {
	    var _fn;

	    if (_.isString(fn)) {
	      fn = this[fn];
	    }

	    for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
	      args[_key - 1] = arguments[_key];
	    }

	    return Tracker.afterFlush((_fn = fn).bind.apply(_fn, [this].concat(args)));
	  };

	  // API v0.2.0
	  // Aliases with small modificatons

	  // No validation
	  // Silent error
	  $$Auth.$waitForUser = function () {
	    // Silent error
	    return this.$awaitUser().catch(function (err) {
	      $log.debug('user login has failed (' + err + ')');
	    });
	  };

	  // No validation
	  $$Auth.$requireUser = function () {
	    return this.$awaitUser();
	  };

	  // Full functionality
	  $$Auth.$requireValidUser = function () {
	    return this.$awaitUser.apply(this, arguments);
	  };

	  return $$Auth;
	}])

	/*
	  External service for syntactic sugare.
	  Originally created as UI-router's resolve handler.
	 */
	.service('$auth', ['$rootScope', '$$Auth', function ($rootScope, $$Auth) {
	  var _this2 = this;

	  // Note that services are initialized once we call them which means that the mixin
	  // will be available by then
	  _.keys($$Auth).forEach(function (k) {
	    var stripped = k.substr(1);
	    // Not using bind() so it would be testable
	    _this2[stripped] = function () {
	      return $rootScope[k].apply($rootScope, arguments);
	    };
	  });
	}]).run(['$Mixer', '$$Auth', function ($Mixer, $$Auth) {
	  $Mixer.mixin($$Auth);
	}]);
	module.exports = exports['default'];

/***/ }
/******/ ])
});
;