banggood-store/lib/StoreManage.js

bang data store

'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.default = undefined;

var _assign = require('babel-runtime/core-js/object/assign');

var _assign2 = _interopRequireDefault(_assign);

var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

var _createClass2 = require('babel-runtime/helpers/createClass');

var _createClass3 = _interopRequireDefault(_createClass2);

var _invariant = require('invariant');

var _invariant2 = _interopRequireDefault(_invariant);

var _StoreContext = require('./StoreContext');

var _StoreContext2 = _interopRequireDefault(_StoreContext);

var _LifecycleStateManage = require('./LifecycleStateManage');

var _LifecycleStateManage2 = _interopRequireDefault(_LifecycleStateManage);

var _Lifecycle = require('./Lifecycle');

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

var StoreManage = function () {
    function StoreManage() {
        (0, _classCallCheck3.default)(this, StoreManage);

        this.history = {};
        this.initialState = {};
        this.types = {};
        this.states = null;
        this.events = {};
        var _history$initialState = { history: null, initialState: null },
            history = _history$initialState.history,
            initialState = _history$initialState.initialState;

        this.history = history;
        this.initialState = initialState || {};
        this.states = new _LifecycleStateManage2.default(history);
    }

    (0, _createClass3.default)(StoreManage, [{
        key: 'mount',
        value: function mount(storeClass) {
            this.checkStoreClass(storeClass);
            var Name = storeClass.Name,
                namespace = storeClass.meta.namespace;

            var name = Name;
            var types = this.types[namespace];
            if (!types) {
                types = this.types[namespace] = {};
            }
            var type = types[name];
            if (!type) {
                type = types[name] = storeClass;
                this.registerEventScopes(type);
            } else {
                (0, _invariant2.default)(storeClass === type, namespace + '.' + name + ' store is mounted.');
            }
            return type;
        }
    }, {
        key: 'unmount',
        value: function unmount(storeClass) {
            throw new Error('unmount not implement');
        }
    }, {
        key: 'getInitialState',
        value: function getInitialState(storeClass) {
            return {};
        }
    }, {
        key: 'getState',
        value: function getState(storeClass) {
            var autoCreate = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
            var states = this.states;
            var Name = storeClass.Name,
                namespace = storeClass.meta.namespace; //name:类名

            var name = Name;
            (0, _invariant2.default)(Name, Name + ': store Name is not  undefined.');
            var state = states.get(storeClass);
            if (!state && autoCreate) {
                var type = this.getType(namespace, name);
                if (type == null) {
                    type = this.mount(storeClass);
                }
                // invariant(type === storeClass, `${namespace}.${name} store is mounted`);
                state = this.initState(type);
                states.set(storeClass, state);
            }
            return state;
        }
    }, {
        key: 'getType',
        value: function getType(namespace, name) {
            var types = this.types[namespace];
            return types ? types[name] : null;
        }
    }, {
        key: 'initState',
        value: function initState(storeClass) {
            var context = new _StoreContext2.default(this, storeClass);
            var state = new storeClass(context);
            return state;
        }
    }, {
        key: 'registerEventScopes',
        value: function registerEventScopes(storeClass) {
            var events = this.events; //{}

            var eventScopes = storeClass.meta.eventScopes;

            if (eventScopes) {
                eventScopes.forEach(function (eventScope) {
                    var types = events[eventScope.name];
                    if (!types) {
                        types = events[eventScope.name] = []; //types and events quote
                    }
                    types.push(storeClass); //events[eventScope.name]=storeClass
                });
            }
        }
    }, {
        key: 'unregisterEventScopes',
        value: function unregisterEventScopes(storeClass) {
            throw new Error('unregister event scopes not implement');
        }
    }, {
        key: 'emit',
        value: function emit(event, payload) {
            var _this = this;

            var types = this.events[event.scope];
            if (types) {
                var context = (0, _assign2.default)({}, event, { payload: payload });
                types.forEach(function (type) {
                    var state = _this.getState(type);
                    if (state && state.onEvent && typeof state.onEvent === 'function') {
                        state.onEvent(context);
                    }
                });
            }
        }
    }, {
        key: 'checkStoreClass',
        value: function checkStoreClass(storeClass) {
            (0, _invariant2.default)(typeof storeClass === 'function', 'store class must be function');
            (0, _invariant2.default)(!!storeClass.name, 'store class name can not be null');
            (0, _invariant2.default)(!!storeClass.meta, 'store ' + storeClass.name + ' meta can not be null.');
            (0, _invariant2.default)(!!storeClass.meta.namespace, 'store ' + storeClass.name + ' meta namespace can not be null.');
            (0, _invariant2.default)((0, _Lifecycle.validLifecycle)(storeClass.meta.lifecycle), 'store ' + storeClass.name + ' meta lifecycle is invalid.');
        }
    }]);
    return StoreManage;
}();

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