ngx-rx-if/bundles/ngx-rx-if.umd.js

An implementation of conditional reactive directive based on @ngrx/store (Redux)

(function (global, factory) {
	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('@angular/core'), require('@ngrx/store'), require('rxjs/add/operator/map'), require('rxjs/add/operator/distinctUntilChanged')) :
	typeof define === 'function' && define.amd ? define(['@angular/core', '@ngrx/store', 'rxjs/add/operator/map', 'rxjs/add/operator/distinctUntilChanged'], factory) :
	(global.ngx = global.ngx || {}, global.ngx.rx = global.ngx.rx || {}, global.ngx.rx.if = factory(global.ng.core,global.ngrx.store,global.rxjs.add.operator.map,global.rxjs.add.operator.distinctUntilChanged));
}(this, (function (core,store,map,distinctUntilChanged) { 'use strict';

core = 'default' in core ? core['default'] : core;
store = 'default' in store ? store['default'] : store;
map = 'default' in map ? map['default'] : map;
distinctUntilChanged = 'default' in distinctUntilChanged ? distinctUntilChanged['default'] : distinctUntilChanged;

function unwrapExports (x) {
	return x && x.__esModule ? x['default'] : x;
}

function createCommonjsModule(fn, module) {
	return module = { exports: {} }, fn(module, module.exports), module.exports;
}

var rxIfElseMessage_component = createCommonjsModule(function (module, exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var core_1 = core;
var RxIfElseMessageComponent = (function () {
    function RxIfElseMessageComponent() {
    }
    return RxIfElseMessageComponent;
}());
RxIfElseMessageComponent.decorators = [
    { type: core_1.Component, args: [{
                selector: 'rx-if-message',
                template: '<span class="rx-if-message">{{ message }}</span>',
                encapsulation: core_1.ViewEncapsulation.None
            },] },
];
/** @nocollapse */
RxIfElseMessageComponent.ctorParameters = function () { return []; };
RxIfElseMessageComponent.propDecorators = {
    'message': [{ type: core_1.Input },],
};
exports.RxIfElseMessageComponent = RxIfElseMessageComponent;
});

var rxIf_directive = createCommonjsModule(function (module, exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var core_1 = core;
var store_1 = store;


var rx_if_else_message_component_1 = rxIfElseMessage_component;
var RxIfDirective = (function () {
    function RxIfDirective(_viewContainer, templateRef, store$$1, componentFactoryResolver) {
        this._viewContainer = _viewContainer;
        this.templateRef = templateRef;
        this.store = store$$1;
        this.componentFactoryResolver = componentFactoryResolver;
    }
    Object.defineProperty(RxIfDirective.prototype, "rxIf", {
        set: function (config) {
            var _this = this;
            this.config = config;
            this.ngOnDestroy();
            this.subscription = this.store
                .select(function (state) { return _this.extractBindingFromState(state); })
                .map(Boolean)
                .distinctUntilChanged()
                .subscribe(function (result) { return _this.updateView(result); });
        },
        enumerable: true,
        configurable: true
    });
    RxIfDirective.prototype.ngOnDestroy = function () {
        if (this.subscription) {
            this.subscription.unsubscribe();
        }
    };
    RxIfDirective.prototype.updateView = function (result) {
        if (typeof result === 'undefined' || result === null) {
            return;
        }
        this._viewContainer.clear();
        if (result) {
            this._viewContainer.createEmbeddedView(this.templateRef);
        }
        else {
            var component = this._viewContainer.createComponent(this.componentFactoryResolver.resolveComponentFactory(this.config.elseMsg ? rx_if_else_message_component_1.RxIfElseMessageComponent : this.config.elseMsgCmp));
            if (this.config.elseMsg) {
                component.instance.message = this.config.elseMsg;
            }
            else {
                component.instance.ctx = this.config.elseMsgCmpCtx;
            }
        }
    };
    RxIfDirective.prototype.extractBindingFromState = function (state) {
        return this.config.bindTo
            .split('.')
            .reduce(function (acc, key) { return typeof acc === 'string' ? (state && state[acc] ? state[acc][key] : null) : (acc ? acc[key] : null); });
    };
    return RxIfDirective;
}());
RxIfDirective.decorators = [
    { type: core_1.Directive, args: [{
                selector: '[rxIf]'
            },] },
];
/** @nocollapse */
RxIfDirective.ctorParameters = function () { return [
    { type: core_1.ViewContainerRef, },
    { type: core_1.TemplateRef, },
    { type: store_1.Store, },
    { type: core_1.ComponentFactoryResolver, },
]; };
RxIfDirective.propDecorators = {
    'rxIf': [{ type: core_1.Input },],
};
exports.RxIfDirective = RxIfDirective;
});

var rxIf_module = createCommonjsModule(function (module, exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var core_1 = core;
var rx_if_directive_1 = rxIf_directive;
var rx_if_else_message_component_1 = rxIfElseMessage_component;
var RxIfModule = (function () {
    function RxIfModule() {
    }
    RxIfModule.forRoot = function () {
        return {
            ngModule: RxIfModule
        };
    };
    return RxIfModule;
}());
RxIfModule.decorators = [
    { type: core_1.NgModule, args: [{
                declarations: [
                    rx_if_directive_1.RxIfDirective,
                    rx_if_else_message_component_1.RxIfElseMessageComponent,
                ],
                entryComponents: [
                    rx_if_else_message_component_1.RxIfElseMessageComponent,
                ],
                exports: [
                    rx_if_directive_1.RxIfDirective,
                ]
            },] },
];
/** @nocollapse */
RxIfModule.ctorParameters = function () { return []; };
exports.RxIfModule = RxIfModule;
});

var index = createCommonjsModule(function (module, exports) {
"use strict";
function __export(m) {
    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
}
Object.defineProperty(exports, "__esModule", { value: true });
__export(rxIf_directive);
__export(rxIf_module);
});

var index$1 = unwrapExports(index);

return index$1;

})));