@foblex/mediator/bundles/foblex-mediator.umd.js

An Angular library that implements the mediator pattern, providing a centralized way to handle requests with optional validation and execution pipelines.

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

    function _interopNamespace(e) {
        if (e && e.__esModule) return e;
        var n = Object.create(null);
        if (e) {
            Object.keys(e).forEach(function (k) {
                if (k !== 'default') {
                    var d = Object.getOwnPropertyDescriptor(e, k);
                    Object.defineProperty(n, k, d.get ? d : {
                        enumerable: true,
                        get: function () { return e[k]; }
                    });
                }
            });
        }
        n["default"] = e;
        return Object.freeze(n);
    }

    var i0__namespace = /*#__PURE__*/_interopNamespace(i0);

    var Pipeline = /** @class */ (function () {
        function Pipeline() {
        }
        Pipeline.prototype.handle = function (request, injector) {
            var isValid = true;
            if (this.validator) {
                isValid = injector.get(this.validator).handle(request);
            }
            if (!isValid) {
                return;
            }
            return injector.get(this.execution).handle(request);
        };
        Pipeline.prototype.execute = function (request, injector) {
            return injector.get(this.execution).handle(request);
        };
        Pipeline.prototype.setValidator = function (validator) {
            this.validator = validator;
        };
        Pipeline.prototype.setExecution = function (execution) {
            this.execution = execution;
        };
        return Pipeline;
    }());

    var FMediator = /** @class */ (function () {
        function FMediator() {
            this._injector = i0.inject(i0.Injector);
        }
        FMediator.registerPipeline = function (type, handler, isValidator) {
            if (!type || !type.fToken) {
                throw new Error('Type must have a fToken static property.');
            }
            var pipeline = this.pipelines.get(type.fToken) || new Pipeline();
            isValidator
                ? pipeline.setValidator(handler)
                : pipeline.setExecution(handler);
            this.pipelines.set(type.fToken, pipeline);
        };
        FMediator.prototype.send = function (request) {
            var pipeline = FMediator.pipelines.get(request.constructor.fToken);
            if (pipeline) {
                return pipeline.handle(request, this._injector);
            }
            throw new Error('Handler not registered for request type.');
        };
        // run pipeline without validation and error handling
        FMediator.prototype.execute = function (request) {
            return FMediator.pipelines.get(request.constructor.fToken).execute(request, this._injector);
        };
        return FMediator;
    }());
    FMediator.pipelines = new Map();
    FMediator.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0__namespace, type: FMediator, deps: [], target: i0__namespace.ɵɵFactoryTarget.Injectable });
    FMediator.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0__namespace, type: FMediator });
    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0__namespace, type: FMediator, decorators: [{
                type: i0.Injectable
            }] });

    function FExecutionRegister(requestType) {
        return function (constructor) {
            FMediator.registerPipeline(requestType, constructor, false);
        };
    }

    function FValidatorRegister(requestType) {
        return function (constructor) {
            FMediator.registerPipeline(requestType, constructor, true);
        };
    }

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

    exports.FExecutionRegister = FExecutionRegister;
    exports.FMediator = FMediator;
    exports.FValidatorRegister = FValidatorRegister;
    exports.Pipeline = Pipeline;

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

}));
//# sourceMappingURL=foblex-mediator.umd.js.map