fluxtuate/lib/mediator/mediator-controller.js

a javascript ES7 library for handling complex data transactions

"use strict";

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

var _chainFunctions = require("../utils/chainFunctions");

var _chainFunctions2 = _interopRequireDefault(_chainFunctions);

var _lang = require("lodash/lang");

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

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

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

var _model = require("../model");

var _model2 = _interopRequireDefault(_model);

var _mediatorModelWrapper = require("./mediator-model-wrapper");

var _mediatorModelWrapper2 = _interopRequireDefault(_mediatorModelWrapper);

var _modelWrapper = require("../model/model-wrapper");

var _modelWrapper2 = _interopRequireDefault(_modelWrapper);

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

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

function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }

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

var props = Symbol("props");
var mediator = Symbol("fluxtuateController_mediator");
var views = Symbol("fluxtuateController_views");
var createMediator = Symbol("fluxtuateController_createMediator");
var destroyMediator = Symbol("fluxtuateController_destroyMediator");
var context = Symbol("fluxtuateController__context");
var mediatorsOnView = Symbol("fluxtuateController__context");

function updateMediatorProps(callback, view, newProps) {
    if (callback("updating", this, view, newProps) === false) return false;
    this[props] = Object.assign(this[props], newProps);
}

function updatedProps(callback, view) {
    callback("updated", this, view);
}

var MediatorController = function MediatorController(c) {
    var _this = this;

    _classCallCheck(this, MediatorController);

    this[views] = {};
    this[context] = c;
    this[_internals.viewCreated] = function (view, viewClass, mediatorClasses) {
        if (view[mediator] && view[mediator].length > 0) return;

        view[mediator] = [];
        var self = _this;
        view[_internals.mediate] = function (functionName) {
            for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
                args[_key - 1] = arguments[_key];
            }

            var meds = view[mediator].slice();
            meds.forEach(function (med) {
                if (self[context][_internals2.contextMediatorCallback]("mediated", med, view, functionName) === false) return;

                if ((0, _lang.isFunction)(med[functionName])) {
                    med[functionName].apply(med, args);
                }
            });
        };

        mediatorClasses.forEach(function (mediator) {
            if (mediator.guards) {

                var guard = void 0;
                if (mediator.guardProperties) {
                    var convertedProperties = mediator.guardProperties.map(function (prop) {
                        if (prop instanceof _modelWrapper2.default) {
                            prop = prop[_internals4.model];
                        }

                        if (prop instanceof _model2.default) {
                            return new _modelWrapper2.default(prop, _this[context]);
                        }

                        return prop;
                    });
                    guard = new (Function.prototype.bind.apply(mediator.guard, [_this].concat(_toConsumableArray(convertedProperties))))();
                } else {
                    guard = new mediator.guard();
                }

                Object.defineProperty(guard, "props", {
                    get: function get() {
                        return Object.assign({}, view.props);
                    }
                });

                _this[context][_internals2.applyGuardContext](guard, { view: view });

                if (!(0, _lang.isFunction)(guard[_internals3.approveGuard])) {
                    throw new Error("Guards must have a approve function! " + guard);
                }
                guard[_internals3.approveGuard]().then(function (isApproved) {
                    if ((0, _lang.isFunction)(guard.destroy)) guard.destroy();
                    if (!isApproved) return;

                    _this[createMediator](view, mediator.mediatorClass, mediator.props);
                });
            } else {
                _this[createMediator](view, mediator.mediatorClass, mediator.props);
            }
        });
        var viewsArray = _this[views][viewClass[viewClass[_internals.fluxtuateNameProperty]]];
        if (!viewsArray) viewsArray = [];
        viewsArray.push(view);
        _this[views][viewClass[viewClass[_internals.fluxtuateNameProperty]]] = viewsArray;
    };

    this[_internals.viewDestroyed] = function (view, viewClass) {
        var meds = view[mediator].slice();
        meds.forEach(function (med) {
            _this[destroyMediator](view, med);
        });

        var viewsArray = _this[views][viewClass[viewClass[_internals.fluxtuateNameProperty]]];
        if (viewsArray) {
            var index = viewsArray.indexOf(view);
            if (index !== -1) {
                viewsArray.splice(index, 1);
            }
            _this[views][viewClass[viewClass[_internals.fluxtuateNameProperty]]] = viewsArray;
        }
    };

    this[createMediator] = function (view, mediatorClass, properties) {
        if (view[mediatorsOnView] && view[mediatorsOnView].indexOf(mediatorClass) !== -1) {
            return;
        }
        var med = void 0;
        if (properties) {
            var injectedModels = [];
            var convertedProperties = properties.map(function (prop) {
                if (prop instanceof _modelWrapper2.default) {
                    prop = prop[_internals4.model];
                }

                if (prop instanceof _model2.default) {
                    var modelWrapper = new _mediatorModelWrapper2.default(prop, _this[context]);
                    injectedModels.push(modelWrapper);
                    return modelWrapper;
                }

                return prop;
            });
            med = new (Function.prototype.bind.apply(mediatorClass, [_this].concat(_toConsumableArray(convertedProperties))))();
            injectedModels.forEach(function (modelWrapper) {
                modelWrapper[_internals.mediator] = med;
            });
        } else {
            med = new mediatorClass();
        }
        if (!view[mediatorsOnView]) {
            view[mediatorsOnView] = [];
        }
        view[mediatorsOnView].push(mediatorClass);
        med[_internals.dispatchFunction] = _this[context].dispatch;
        med.setProps = (0, _chainFunctions2.default)(updateMediatorProps.bind(med, _this[context][_internals2.contextMediatorCallback], view), view[view[_internals.fluxtuateUpdateFunction]], updatedProps.bind(med, _this[context][_internals2.contextMediatorCallback], view));
        med[props] = Object.assign({}, view.props);
        med[_internals.context] = _this[context];

        Object.defineProperty(med, "props", {
            get: function get() {
                return med[props];
            }
        });

        var creationResult = _this[context][_internals2.contextMediatorCallback]("created", med, view);
        if (creationResult === false) return;

        _this[context][_internals2.applyMediatorContext](med, { view: view }, creationResult.injections);

        if ((0, _lang.isFunction)(med.init)) {
            med.init();
        }

        if (_this[context][_internals2.contextMediatorCallback]("initialized", med, view) === false) return;

        view[mediator].push(med);
    };

    this[destroyMediator] = function (view, med) {
        if ((0, _lang.isFunction)(med.destroy)) med.destroy();

        _this[context][_internals2.contextMediatorCallback]("destroyed", med, view);

        var index = view[mediator].indexOf(med);

        if (index !== -1) {
            view[mediator].splice(index, 1);
        }

        med[_internals.destroy]();
    };

    this[_internals.mapRemoved] = function (viewClass, mediatorClass) {
        var foundViews = _this[views][viewClass[viewClass[_internals.fluxtuateNameProperty]]];

        if (!foundViews) return;

        foundViews = foundViews.slice();

        foundViews.forEach(function (view) {
            var meds = view[mediator].slice();
            meds.forEach(function (med) {
                if (med instanceof mediatorClass) {
                    _this[destroyMediator](view, med);
                }
            });
        });
    };
};

exports.default = MediatorController;