fluxtuate/lib/mediator/mediator-map.js

a javascript ES7 library for handling complex data transactions

"use strict";

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

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _delegator = require("../delegator");

var _delegator2 = _interopRequireDefault(_delegator);

var _mediator = require("./mediator");

var _mediator2 = _interopRequireDefault(_mediator);

var _internals = require("./_internals");

var _mediatorController = require("./mediator-controller");

var _mediatorController2 = _interopRequireDefault(_mediatorController);

var _array = require("lodash/array");

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

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var mediatorMap = Symbol("fluxtuateMediatorMap__mediatorMap");
var controllerDelegator = Symbol("fluxtuateMediatorMap__controllerDelegator");
var controller = Symbol("fluxtuateMediatorMap__controller");
var isPuased = Symbol("fluxtuateMediatorMap__isPaused");

var MediatorMap = function () {
    function MediatorMap(context) {
        var _this = this;

        _classCallCheck(this, MediatorMap);

        this[isPuased] = false;
        this[controllerDelegator] = new _delegator2.default();
        this[controller] = new _mediatorController2.default(context);

        this[controllerDelegator].attachDelegate(this[controller]);

        this[mediatorMap] = {};

        this[_internals.viewCreated] = function (view, viewClass, creationContext) {
            if (!creationContext) {
                throw new Error("You must have a context when creating a view! View was created outside of a context!");
            }
            if (creationContext !== context && !creationContext.isChildOf(context)) return;
            if (_this[isPuased]) return;
            var viewClassName = viewClass[viewClass[_internals.fluxtuateNameProperty]];
            var mediatorClasses = _this[mediatorMap][viewClassName].mediatorClasses;

            _this[controller][_internals.viewCreated](view, viewClass, mediatorClasses);
        };

        this[_internals.viewDestroyed] = function (view, viewClass, creationContext) {
            if (creationContext && creationContext !== context && !creationContext.isChildOf(context)) return;
            var viewClassName = viewClass[viewClass[_internals.fluxtuateNameProperty]];
            if (!_this[mediatorMap][viewClassName]) return;

            var mediatorClasses = _this[mediatorMap][viewClassName].mediatorClasses;

            _this[controller][_internals.viewDestroyed](view, viewClass, mediatorClasses);
        };

        this[_internals.pause] = function () {
            _this[isPuased] = true;
        };

        this[_internals.resume] = function () {
            _this[isPuased] = false;
        };

        this[_internals.destroy] = function () {
            var _loop = function _loop(key) {
                var _mediatorMap$key = _this[mediatorMap][key],
                    viewClass = _mediatorMap$key.viewClass,
                    mediatorClasses = _mediatorMap$key.mediatorClasses;

                mediatorClasses = mediatorClasses.slice();
                mediatorClasses.forEach(function (mediator) {
                    _this.unpamView(viewClass, mediator.mediatorClass);
                });
                viewClass[_internals.viewDelegator].detachDelegate(_this);
            };

            for (var key in _this[mediatorMap]) {
                _loop(key);
            }

            _this[mediatorMap] = {};
        };
    }

    _createClass(MediatorMap, [{
        key: "mapView",
        value: function mapView(view, mediator) {
            for (var _len = arguments.length, props = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
                props[_key - 2] = arguments[_key];
            }

            if (mediator === _mediator2.default || !(mediator.prototype instanceof _mediator2.default)) throw new Error("Your mediators must inherit fluxtuates Mediator class!");

            if (!view[_internals.fluxtuateView]) {
                throw new Error("You must map a fluxtuate view in the mediator map!");
            }

            var viewClassName = view[view[_internals.fluxtuateNameProperty]];

            view[_internals.viewDelegator].attachDelegate(this);

            var mediatorClasses = [];
            if (this[mediatorMap][viewClassName]) {
                mediatorClasses = this[mediatorMap][viewClassName].mediatorClasses;
            }

            var mediatorObject = { mediatorClass: mediator, props: props };
            mediatorClasses.push(mediatorObject);

            this[mediatorMap][viewClassName] = { viewClass: view, mediatorClasses: mediatorClasses };

            function returnGuardObject() {
                return {
                    withGuard: function withGuard(guard) {
                        for (var _len2 = arguments.length, guardProperties = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
                            guardProperties[_key2 - 1] = arguments[_key2];
                        }

                        if (!mediatorObject.guards) mediatorObject.guards = [];
                        mediatorObject.guards.push({
                            guard: guard,
                            guardProperties: guardProperties
                        });

                        return returnGuardObject();
                    },
                    withHook: function withHook(hookClass) {
                        for (var _len3 = arguments.length, hookProperties = Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
                            hookProperties[_key3 - 1] = arguments[_key3];
                        }

                        if (!mediatorObject.hooks) mediatorObject.hooks = [];
                        mediatorObject.hooks.push({
                            hook: hookClass,
                            hookProperties: hookProperties
                        });

                        return returnGuardObject();
                    }
                };
            }

            return returnGuardObject();
        }
    }, {
        key: "unpamView",
        value: function unpamView(view, mediator) {
            var viewClassName = view[view[_internals.fluxtuateNameProperty]];

            if (!this[mediatorMap][viewClassName]) return;

            var mediatorClasses = this[mediatorMap][viewClassName].mediatorClasses;


            var index = (0, _array.findIndex)(mediatorClasses, { mediatorClass: mediator });

            if (index === -1) return;

            mediatorClasses.splice(index, 1);

            if (mediatorClasses.length === 0) view[_internals.viewDelegator].detachDelegate(this);

            this[controller][_internals.mapRemoved](view, mediator);

            return mediator;
        }
    }]);

    return MediatorMap;
}();

exports.default = MediatorMap;