awv3/dist/session/lifecycle.js

⚡ AWV3 embedded CAD

'use strict';

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

var _defineProperty2 = require('babel-runtime/core-js/object/define-property');

var _defineProperty3 = _interopRequireDefault(_defineProperty2);

var _set = require('babel-runtime/core-js/set');

var _set2 = _interopRequireDefault(_set);

var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of');

var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);

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

var _createClass3 = _interopRequireDefault(_createClass2);

var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

var _inherits2 = require('babel-runtime/helpers/inherits');

var _inherits3 = _interopRequireDefault(_inherits2);

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

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

var _keys = require('babel-runtime/core-js/object/keys');

var _keys2 = _interopRequireDefault(_keys);

var _defineProperty4 = require('babel-runtime/helpers/defineProperty');

var _defineProperty5 = _interopRequireDefault(_defineProperty4);

var _extends6 = require('babel-runtime/helpers/extends');

var _extends7 = _interopRequireDefault(_extends6);

var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

var _uuidV = require('uuid-v4');

var _uuidV2 = _interopRequireDefault(_uuidV);

var _omit = require('lodash/omit');

var _omit2 = _interopRequireDefault(_omit);

var _cloneDeep = require('lodash/cloneDeep');

var _cloneDeep2 = _interopRequireDefault(_cloneDeep);

var _error = require('../core/error');

var _helpers = require('./helpers');

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

// Store mixin which creates four actions: register(id, props), unregister(id), update(id, props) & patch(props)
var mixin = function mixin(name, subReducer) {
    var references = {};
    var types = {
        register: name + '/REGISTER',
        registerQueue: name + '/REGISTERQUEUE',
        unregister: name + '/UNREGISTER',
        update: name + '/UPDATE',
        merge: name + '/MERGE'
    };

    return {
        references: references,
        types: types,
        actions: {
            register: function register(reference, props) {
                return function (dispatch) {
                    // Store references to the actual lifecycle class making the register call
                    references[reference.id] = reference;
                    dispatch({ type: types.register, id: reference.id, props: props });
                };
            },
            unregister: function unregister(ids) {
                return function (dispatch) {
                    var objects = Array.isArray(ids) ? ids : [ids];
                    dispatch({ type: types.unregister, ids: ids });
                    objects.forEach(function (id) {
                        // Destroy & remove reference
                        if (references[id]) {
                            references[id].destroy(false);
                            delete references[id];
                        }
                    });
                };
            },
            update: function update(id, props) {
                return { type: types.update, id: id, props: props };
            },
            merge: function merge(props) {
                return { type: types.merge, props: props };
            }
        },
        reducer: function reducer() {
            var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
            var _ref = arguments[1];
            var type = _ref.type,
                id = _ref.id,
                payload = (0, _objectWithoutProperties3.default)(_ref, ['type', 'id']);

            switch (type) {
                case types.register:
                    return (0, _extends7.default)({}, state, (0, _defineProperty5.default)({}, id, (0, _extends7.default)({ id: id }, payload.props)));
                case types.unregister:
                    return (0, _omit2.default)(state, payload.ids);
                case types.update:
                    return (0, _extends7.default)({}, state, (0, _defineProperty5.default)({}, id, (0, _extends7.default)({}, state[id], payload.props)));
                case types.merge:
                    return (0, _keys2.default)(payload.props).reduce(function (prev, key) {
                        return (0, _extends7.default)({}, prev, (0, _defineProperty5.default)({}, key, (0, _extends7.default)({ id: key }, prev[key], payload.props[key])));
                    }, state);
                default:
                    if (payload && id && state[id]) {
                        return (0, _extends7.default)({}, state, (0, _defineProperty5.default)({}, id, subReducer(state[id], (0, _extends7.default)({ type: type }, payload))));
                    }
            }
            return state;
        }
    };
};

// Base for all objects tied to the store. Lifecycle takes care of the initial
// register, watches for removal, manages child-relations and observers
// Lifecycle eligiable objects must have store actions that expose:
//      1. register(id, props) method
//      2. unregister(id) method
//      3. update(id, props) method
exports.mixin = mixin;

exports.default = function () {
    var Base = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : function () {
        function _class() {
            (0, _classCallCheck3.default)(this, _class);
        }

        return _class;
    }();
    var arg = arguments[1];
    return function (_Base) {
        (0, _inherits3.default)(Lifecycle, _Base);

        function Lifecycle() {
            var session = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : (0, _error.halt)('Lifecycle object is missing a session');
            var actions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : (0, _error.halt)('Lifecycle object is missing link to actions');
            var selector = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : (0, _error.halt)('Lifecycle object is missing a selector');
            var props = arguments[3];
            (0, _classCallCheck3.default)(this, Lifecycle);

            var _this = (0, _possibleConstructorReturn3.default)(this, (Lifecycle.__proto__ || (0, _getPrototypeOf2.default)(Lifecycle)).call(this, arg));

            _this.id = (0, _uuidV2.default)();
            _this.session = session;
            _this.store = session.store;
            _this.actions = actions;
            _this.getState = function () {
                return selector(_this.store.getState());
            };
            _this.subscriptions = new _set2.default();
            _this.dependencies = [];

            // Register object and store original properties
            _this.store.dispatch(actions.register(_this, props));
            _this.props = (0, _cloneDeep2.default)(props);

            // Create managed observer
            var observer = (0, _helpers.createObserver)(_this.store, _this.getState);
            _this.observe = function (selector, callback, options) {
                return observer(selector, callback, (0, _extends7.default)({ manager: _this.managed && _this.addSubscription.bind(_this) }, options));
            };

            // Make props available on the object with automatic setters/getters

            var _loop = function _loop(prop) {
                !_this[prop] && (0, _defineProperty3.default)(_this, prop, {
                    configurable: true,
                    get: function get() {
                        var state = _this.getState();
                        return state && state[prop];
                    },
                    set: function set(value) {
                        return _this.store.dispatch(actions.update(_this.id, (0, _defineProperty5.default)({}, prop, value)));
                    }
                });
            };

            for (var prop in props) {
                _loop(prop);
            }
            return _this;
        }

        (0, _createClass3.default)(Lifecycle, [{
            key: 'update',
            value: function update(props) {
                this.store.dispatch(this.actions.update(this.id, props));
            }
        }, {
            key: 'merge',
            value: function merge(props) {
                this.store.dispatch(this.actions.merge(this.id, props));
            }
        }, {
            key: 'reset',
            value: function reset() {
                this.store.dispatch(this.actions.update(this.id, this.props));
            }
        }, {
            key: 'destroy',
            value: function destroy() {
                var dispatchUnregister = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;

                if (dispatchUnregister) {
                    this.store.dispatch(this.actions.unregister(this.id));
                } else {
                    this.removeSubscriptions();
                    this.__onDestroyed && this.__onDestroyed();
                    this.onDestroyed();
                    this.dependencies.slice().forEach(function (child) {
                        return child.destroy();
                    });
                    this.dependencies = [];
                }
            }
        }, {
            key: 'addSubscription',
            value: function addSubscription(unsubscribe) {
                this.subscriptions.add(unsubscribe);
                return unsubscribe;
            }
        }, {
            key: 'removeSubscription',
            value: function removeSubscription(unsubscribe) {
                unsubscribe();
                this.subscriptions.delete(unsubscribe);
            }
        }, {
            key: 'removeSubscriptions',
            value: function removeSubscriptions() {
                this.subscriptions.forEach(function (unsubscribe) {
                    return unsubscribe();
                });
                this.subscriptions.clear();
                this.dependencies.forEach(function (child) {
                    return child.removeSubscriptions();
                });
            }
        }, {
            key: 'onDestroyed',
            value: function onDestroyed() {}
        }]);
        return Lifecycle;
    }(Base);
};