ngx-until-on-destroy/bundles/ngx-until-on-destroy.umd.js

Allow you unsubscribe subscriptions when component was destroying. Can be used with Angular 5-10

(function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('rxjs'), require('@angular/core')) :
    typeof define === 'function' && define.amd ? define('ngx-until-on-destroy', ['exports', 'rxjs', '@angular/core'], factory) :
    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global['ngx-until-on-destroy'] = {}, global.rxjs, global.ng.core));
}(this, (function (exports, rxjs, core) { 'use strict';

    function decorateMethod(_a) {
        var target = _a.target, hookName = _a.hookName, oldName = _a.oldName, wrappingFn = _a.wrappingFn;
        var oldMethod = target[hookName];
        target[oldName] = oldMethod;
        return function () {
            wrappingFn.call(this);
            if (oldMethod) {
                return oldMethod.call(this);
            }
        };
    }

    var componentDefKey = 'ɵcmp';
    var factoryDefKey = 'ɵfac';
    var directiveDefKey = 'ɵdir';

    var isIvy = function (target) { return target.constructor[factoryDefKey]; };
    function getIvyDef(target) {
        return target.constructor[componentDefKey] || target.constructor[directiveDefKey];
    }
    function wrapIvyHook(_a) {
        var target = _a.target, hookName = _a.hookName, oldName = _a.oldName, wrappingFn = _a.wrappingFn;
        var ivyHookName = hookName.slice(0, 1).toLowerCase() + hookName.slice(1);
        var ivyDef = getIvyDef(target);
        ivyDef[ivyHookName] = decorateMethod({
            target: ivyDef,
            hookName: ivyHookName,
            oldName: oldName,
            wrappingFn: wrappingFn,
        });
    }

    function getViewEngineError(hookName, constructorName) {
        return new Error("You have to implements " + hookName + " in component (or directive) " + constructorName);
    }
    function wrapViewEngineHook(_a) {
        var target = _a.target, hookName = _a.hookName, oldName = _a.oldName, wrappingFn = _a.wrappingFn;
        var veHookName = 'ng' + hookName;
        if (!target[veHookName] && +core.VERSION.major < 9) {
            throw getViewEngineError(veHookName, target.constructor.name);
        }
        target[veHookName] = decorateMethod({
            target: target,
            hookName: veHookName,
            oldName: oldName,
            wrappingFn: wrappingFn
        });
    }

    var subSymbol = Symbol('subscription');
    var decoratedSymbol = Symbol('decorated');
    var onInitSymbol = Symbol('onInit');
    var onDestroySymbol = Symbol('onDestroy');

    function markAsDecorated(target) {
        target[decoratedSymbol] = true;
    }
    function isDecorated(target) {
        return target.hasOwnProperty(decoratedSymbol);
    }
    function createMethodWrapper(originalMethod) {
        return function () {
            var _this = this;
            var args = [];
            for (var _i = 0; _i < arguments.length; _i++) {
                args[_i] = arguments[_i];
            }
            var originalResult = originalMethod.apply(this, args);
            if (originalResult instanceof rxjs.Subscription) {
                this[subSymbol].add(originalResult);
            }
            else if (Array.isArray(originalResult)) {
                originalResult.forEach(function (s) { return _this[subSymbol].add(s); });
            }
            else {
                throw new Error('Decorated method must return Subscription or Subscription[]');
            }
            return originalResult;
        };
    }
    function wrapOneHook(wrapParams) {
        if (isIvy(wrapParams.target)) {
            wrapIvyHook(wrapParams);
        }
        wrapViewEngineHook(wrapParams);
    }
    function wrapHooks(target) {
        if (!isDecorated(target)) {
            markAsDecorated(target);
            wrapOneHook({
                target: target,
                hookName: 'OnInit',
                oldName: onInitSymbol,
                wrappingFn: function () {
                    this[subSymbol] = new rxjs.Subscription();
                }
            });
            wrapOneHook({
                target: target,
                hookName: 'OnDestroy',
                oldName: onDestroySymbol,
                wrappingFn: function () {
                    this[subSymbol].unsubscribe();
                }
            });
        }
    }
    function UntilOnDestroy() {
        return function UntilOnDestroyDecorator(target, propertyKey) {
            wrapHooks(target);
            return {
                value: createMethodWrapper(target[propertyKey]),
            };
        };
    }

    /*
     * Public API Surface of ngx-until-on-destroy
     */

    /**
     * Generated bundle index. Do not edit.
     */

    exports.UntilOnDestroy = UntilOnDestroy;

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

})));
//# sourceMappingURL=ngx-until-on-destroy.umd.js.map