transition-manager/lib/core/transitionController.js

Transition Manager. Framework independent transition manager to transition elements using states and actions.

'use strict';

Object.defineProperty(exports, '__esModule', {
	value: true
});

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

var _commonLoggerJs = require('../common/logger.js');

var _commonLoggerJs2 = _interopRequireDefault(_commonLoggerJs);

var _utilsDefault = require('../utils/default');

var _utilsDefault2 = _interopRequireDefault(_utilsDefault);

var _utilsMixin = require('../utils/mixin');

var _utilsMixin2 = _interopRequireDefault(_utilsMixin);

/* dispatcher signals */

var _commonDispatcher = require('../common/dispatcher');

/* promises */

var _commonPromiseFacade = require('../common/promiseFacade');

/* create class and extend logger */
var TransitionController = _utilsMixin2['default']({ name: 'TransitionController' }, _commonLoggerJs2['default']);

(function () {
	var _tranistionComplete = null,
	    _options = { // default options
		debug: false,
		transitions: null
	};

	/**
  * transition the views, find the transition module if it 
  * exists then pass in the linked views, data and settings
  * 
  * @param  {onject} transitionObj  - contains {transitionType, views, currentViewID, nextViewID}
  * @param  {array} viewsToDispose  - array to store the views passed to each module to dispatch on transition completed
  * @return {array} promises from Deferred 
  */
	function _transitionViews(transitionObj) {
		if (!transitionObj) {
			return TransitionController.error('transition is not defined');
		}
		var transitionModule = _options.transitions[transitionObj.transitionType];

		if (transitionModule) {

			var deferred = _commonPromiseFacade.Deferred(),
			    views = transitionObj.views,
			    currentViewRef = transitionObj.currentViewID,
			    nextViewRef = transitionObj.nextViewID;

			/* individual transition completed */
			deferred.promise.then(function () {
				_commonDispatcher.transitionComplete.dispatch(transitionObj);
				TransitionController.log(transitionObj.transitionType + ' -- completed');
			});

			if (transitionModule.initialize) {
				transitionModule.initialize(views, transitionObj.data, deferred, currentViewRef, nextViewRef);
			}

			_commonDispatcher.transitionStarted.dispatch(transitionObj);
			TransitionController.log(transitionObj.transitionType + ' -- started');
			transitionModule.animate(views, transitionObj.data, deferred, currentViewRef, nextViewRef);

			return deferred.promise;
		} else {
			TransitionController.error(transitionObj.transitionType + ' does NOT exist');
		}
	}

	function _prepareAndStart(transitions) {
		var initialTransiion = transitions.shift(0),
		    transitionsLength = transitions.length;

		var deferredTransitions = [],
		    i = 0,
		    transitionObj = undefined;

		// get the first transition to prevent looping unnecessarily
		deferredTransitions.push(_transitionViews(initialTransiion));

		while (i < transitionsLength) {
			transitionObj = transitions[i];
			deferredTransitions[deferredTransitions.length] = _transitionViews(transitionObj);

			++i;
		}

		// listen for completed modules
		_commonPromiseFacade.all(deferredTransitions).then(function () {
			TransitionController.log('transition queue empty ---- all transitions completed');

			_tranistionComplete();
			_commonDispatcher.allTransitionCompleted.dispatch();
		}, TransitionController.error);
	}

	/**
  * remove a module by name from the dictionary 
  * of modules if they exist
  * 
  * @param  {string} moduleName [
  * @return {object} TransitionController
  */
	TransitionController.removeModule = function (moduleName) {
		if (!moduleName) {
			return false;
		}

		if (moduleName instanceof Array) {
			moduleName.forEach(function (module) {
				this.removeModule(module);
			}, this);
			return this;
		}

		if (_options.transitions[moduleName]) {
			delete _options.transitions[moduleName];
		}
		return this;
	};

	/**
  * Add module by name 
  * @param {string/array} moduleName [description]
  * @param {object} module - transition module class
  * @return {object} TransitionController
  */
	TransitionController.addModule = function (moduleName, module) {
		if (!moduleName) {
			return false;
		}
		if (moduleName instanceof Array) {

			moduleName.forEach(function (moduleData) {
				var key = Object.keys(moduleData)[0];
				this.addModule(key, moduleData[key]);
			}, this);

			return this;
		}

		if (_options.transitions[moduleName]) {
			return false;
		}
		_options.transitions[moduleName] = module;

		return this;
	};

	/**
  * start processing the requested transition
  * @param  {array/object} - transition objects or array of ytransition objects
  */
	TransitionController.processTransition = function (transitions) {
		_commonDispatcher.allTransitionsStarted.dispatch(transitions);

		// prepare and start the transitions
		TransitionController.log('-- start transitioning views --');
		_prepareAndStart(transitions);
	};

	/**
  * init the transition controller
  * @param  {object} options - options to override defaults
  */
	TransitionController.init = function (options) {
		// get transitions from init options
		_utilsDefault2['default'](_options, options);

		TransitionController.initLogger(_options.debug);
		TransitionController.log('initiated');
	};

	/**
  * link external methid to change the transition completedx state
  */
	Object.defineProperty(TransitionController, 'transitionCompleted', { set: function set(method) {
			_tranistionComplete = method;
		} });
})();

exports['default'] = TransitionController;
module.exports = exports['default'];