refer/lib/createStore.js

redux-like library for handling global state on functional style

'use strict';

exports.__esModule = true;

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 }; }

var _types = require('./types');

var _combineHandlers = require('./combineHandlers');

var _combineHandlers2 = _interopRequireDefault(_combineHandlers);

var _createDispatch = require('./createDispatch');

var _createDispatch2 = _interopRequireDefault(_createDispatch);

var _mapValues = require('./mapValues');

var _mapValues2 = _interopRequireDefault(_mapValues);

var _constants = require('./constants');

var LIFE_CYCLE = _interopRequireWildcard(_constants);

var GET_TABLE = LIFE_CYCLE.GET_TABLE;
var SHOULD_DISPATCH = LIFE_CYCLE.SHOULD_DISPATCH;
var DISPATCH = LIFE_CYCLE.DISPATCH;
var WILL_UPDATE = LIFE_CYCLE.WILL_UPDATE;
var SHOULD_UPDATE = LIFE_CYCLE.SHOULD_UPDATE;
var DID_UPDATE = LIFE_CYCLE.DID_UPDATE;
var THROW_ERROR = LIFE_CYCLE.THROW_ERROR;
var ASYNC_START = LIFE_CYCLE.ASYNC_START;
var ASYNC_END = LIFE_CYCLE.ASYNC_END;
var SYNC = LIFE_CYCLE.SYNC;

var createStore = function createStore(innerDispatch) {
	var initialState = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];

	if (_types.isArr(innerDispatch)) {
		innerDispatch = _createDispatch2['default'](_combineHandlers2['default'].apply(undefined, innerDispatch));
	} else if (_types.isObj(innerDispatch)) {
		innerDispatch = _createDispatch2['default'](innerDispatch);
	}

	if (!_types.isFn(innerDispatch)) {
		throw new Error('Expected the innerDispatch to be a function which is ' + innerDispatch);
	}

	var listeners = [];
	var subscribe = function subscribe(listener) {
		listeners.push(listener);
		return function () {
			var index = listeners.indexOf(listener);
			if (index !== -1) {
				listeners.splice(index, 1);
			}
		};
	};

	var currentState = initialState;
	var replaceState = function replaceState(nextState, silent) {
		for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
			args[_key - 2] = arguments[_key];
		}

		currentState = nextState;
		if (!silent) {
			listeners.forEach(function (listener) {
				return listener.apply(undefined, args);
			});
		}
	};
	var updateCurrentState = function updateCurrentState(data) {
		if (innerDispatch(SHOULD_UPDATE, data) !== false) {
			innerDispatch(WILL_UPDATE, data);
			replaceState(data.nextState, null, data);
			innerDispatch(DID_UPDATE, data);
		}
	};

	var getState = function getState() {
		return currentState;
	};
	var dispatchError = function dispatchError(error) {
		return Promise.reject(innerDispatch(THROW_ERROR, error));
	};

	var isDispatching = false;
	var dispatch = function dispatch(key, value) {
		if (isDispatching) {
			throw new Error('store.dispatch(key, value): handler may not dispatch');
		}

		var currentData = { currentState: currentState, key: key, value: value };

		if (innerDispatch(SHOULD_DISPATCH, currentData) === false) {
			return currentState;
		}

		innerDispatch(DISPATCH, currentData);

		var nextState = undefined;
		var isAsync = false;
		var getNextState = function getNextState(f) {
			return f(currentState);
		};
		var handlerNextState = function handlerNextState(nextState) {
			var data = undefined;
			if (isAsync) {
				data = { currentState: currentState, nextState: nextState, key: key, value: value };
				updateCurrentState(data);
				innerDispatch(ASYNC_END, data);
			}
			return nextState;
		};

		try {
			isDispatching = true;
			nextState = innerDispatch([key, getNextState, handlerNextState], value);
		} catch (error) {
			return dispatchError(error);
		} finally {
			isDispatching = false;
		}

		if (nextState === currentState) {
			return currentState;
		}

		var data = { currentState: currentState, nextState: nextState, key: key, value: value };

		if (!_types.isThenable(nextState)) {
			updateCurrentState(data);
			innerDispatch(SYNC, data);
			return currentState;
		}

		innerDispatch(ASYNC_START, data);
		isAsync = true;
		return nextState['catch'](function (error) {
			innerDispatch(ASYNC_END, { currentState: currentState, key: key, value: value, error: error });
			return dispatchError(error);
		});
	};

	var createActions = function createActions(obj) {
		return _mapValues2['default'](obj, function (_, key) {
			return function (value) {
				return LIFE_CYCLE.hasOwnProperty(key) ? innerDispatch(key, value) : dispatch(key, value);
			};
		});
	};
	var actions = createActions(innerDispatch(GET_TABLE));

	return {
		dispatch: dispatch,
		actions: actions,
		getState: getState,
		replaceState: replaceState,
		subscribe: subscribe,
		createActions: createActions
	};
};

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