mobx-angular/dist/mobx-angular.umd.js

(function (global, factory) {
	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('mobx')) :
	typeof define === 'function' && define.amd ? define(['exports', '@angular/core', 'mobx'], factory) :
	(factory((global['mobx-angular'] = global['mobx-angular'] || {}),global._angular_core,global.mobx));
}(this, (function (exports,_angular_core,mobx) { 'use strict';

// import { mobxAngularDebug } from '../utils/mobx-angular-debug';
var MobxAutorunDirective = /** @class */ (function () {
    function MobxAutorunDirective(templateRef, viewContainer) {
        this.templateRef = templateRef;
        this.viewContainer = viewContainer;
        this.templateBindings = {};
    }
    MobxAutorunDirective.prototype.ngOnInit = function () {
        this.view = this.viewContainer.createEmbeddedView(this.templateRef);
        if (this.dispose)
            this.dispose();
        if (this.shouldDetach()) {
            this.view.detach();
        }
        this.autoDetect(this.view);
        // mobxAngularDebug(this.view, this.dispose);
    };
    MobxAutorunDirective.prototype.shouldDetach = function () {
        return this.mobxAutorun && this.mobxAutorun.detach;
    };
    MobxAutorunDirective.prototype.autoDetect = function (view) {
        var autorunName = view._view.component
            ? view._view.component.constructor.name + ".detectChanges()" // angular 4+
            : view._view.parentView.context.constructor.name + ".detectChanges()"; // angular 2
        this.dispose = mobx.autorun(function () { return view['detectChanges'](); }, { name: autorunName });
    };
    MobxAutorunDirective.prototype.ngOnDestroy = function () {
        if (this.dispose)
            this.dispose();
    };
    MobxAutorunDirective.decorators = [
        { type: _angular_core.Directive, args: [{ selector: '[mobxAutorun]' },] },
    ];
    /** @nocollapse */
    MobxAutorunDirective.ctorParameters = function () { return [
        { type: _angular_core.TemplateRef, },
        { type: _angular_core.ViewContainerRef, },
    ]; };
    MobxAutorunDirective.propDecorators = {
        "mobxAutorun": [{ type: _angular_core.Input },],
    };
    return MobxAutorunDirective;
}());

var __extends = (undefined && undefined.__extends) || (function () {
    var extendStatics = Object.setPrototypeOf ||
        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
    return function (d, b) {
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    };
})();
var MobxAutorunSyncDirective = /** @class */ (function (_super) {
    __extends(MobxAutorunSyncDirective, _super);
    function MobxAutorunSyncDirective(templateRef, viewContainer) {
        var _this = _super.call(this, templateRef, viewContainer) || this;
        _this.templateRef = templateRef;
        _this.viewContainer = viewContainer;
        return _this;
    }
    MobxAutorunSyncDirective.prototype.autoDetect = function (view) {
        console.warn('mobxAutorunSync is deprecated, please use mobxAutorun instead - it\'s doing exactly the same thing');
        this.dispose = mobx.autorun(function () {
            view['detectChanges']();
        });
    };
    MobxAutorunSyncDirective.decorators = [
        { type: _angular_core.Directive, args: [{ selector: '[mobxAutorunSync]' },] },
    ];
    /** @nocollapse */
    MobxAutorunSyncDirective.ctorParameters = function () { return [
        { type: _angular_core.TemplateRef, },
        { type: _angular_core.ViewContainerRef, },
    ]; };
    return MobxAutorunSyncDirective;
}(MobxAutorunDirective));

var __extends$1 = (undefined && undefined.__extends) || (function () {
    var extendStatics = Object.setPrototypeOf ||
        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
    return function (d, b) {
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    };
})();
var MobxReactionDirective = /** @class */ (function (_super) {
    __extends$1(MobxReactionDirective, _super);
    function MobxReactionDirective(templateRef, viewContainer) {
        var _this = _super.call(this, templateRef, viewContainer) || this;
        _this.templateRef = templateRef;
        _this.viewContainer = viewContainer;
        return _this;
    }
    MobxReactionDirective.prototype.autoDetect = function (view) {
        this.dispose = mobx.reaction(this.mobxReaction, function () {
            view['detectChanges']();
        }, { fireImmediately: true });
    };
    MobxReactionDirective.decorators = [
        { type: _angular_core.Directive, args: [{ selector: '[mobxReaction]' },] },
    ];
    /** @nocollapse */
    MobxReactionDirective.ctorParameters = function () { return [
        { type: _angular_core.TemplateRef, },
        { type: _angular_core.ViewContainerRef, },
    ]; };
    MobxReactionDirective.propDecorators = {
        "mobxReaction": [{ type: _angular_core.Input },],
    };
    return MobxReactionDirective;
}(MobxAutorunDirective));

var DIRECTIVES = [MobxAutorunDirective, MobxAutorunSyncDirective, MobxReactionDirective];
var MobxAngularModule = /** @class */ (function () {
    function MobxAngularModule() {
    }
    MobxAngularModule.decorators = [
        { type: _angular_core.NgModule, args: [{
                    declarations: DIRECTIVES.slice(),
                    exports: DIRECTIVES.slice(),
                    imports: [],
                    providers: []
                },] },
    ];
    /** @nocollapse */
    MobxAngularModule.ctorParameters = function () { return []; };
    return MobxAngularModule;
}());
function action$1() {
    var args = [];
    for (var _i = 0; _i < arguments.length; _i++) {
        args[_i] = arguments[_i];
    }
    return mobx.action.apply(void 0, args);
}
function computed$1() {
    var args = [];
    for (var _i = 0; _i < arguments.length; _i++) {
        args[_i] = arguments[_i];
    }
    return mobx.computed.apply(void 0, args);
}
function observable$1() {
    var args = [];
    for (var _i = 0; _i < arguments.length; _i++) {
        args[_i] = arguments[_i];
    }
    return mobx.observable.apply(void 0, args);
}

exports.MobxAutorunDirective = MobxAutorunDirective;
exports.MobxAutorunSyncDirective = MobxAutorunSyncDirective;
exports.MobxReactionDirective = MobxReactionDirective;
exports.MobxAngularModule = MobxAngularModule;
exports.action = action$1;
exports.computed = computed$1;
exports.observable = observable$1;

Object.defineProperty(exports, '__esModule', { value: true });

})));