@universis/common/fesm2020/universis-common-routing.mjs

Universis - common directives and services

import * as i0 from '@angular/core';
import { EventEmitter, Component, Input, ViewEncapsulation, NgModule } from '@angular/core';
import * as i1 from '@angular/router';
import { RouterModule } from '@angular/router';
import * as i2 from '@angular/common';
import { CommonModule } from '@angular/common';
import * as i3 from '@ngx-translate/core';
import { TranslateModule } from '@ngx-translate/core';

const ButtonTypes = {
    ok: {
        buttonText: 'OK',
        buttonClass: 'btn btn-indigo',
        buttonDisabled: false
    },
    cancel: {
        buttonText: 'Cancel',
        buttonClass: 'btn btn-gray-100',
        buttonDisabled: false
    },
    yes: {
        buttonText: 'Yes',
        buttonClass: 'btn btn-primary',
        buttonDisabled: false
    },
    no: {
        buttonText: 'No',
        buttonClass: 'btn btn-gray-100',
        buttonDisabled: false
    },
    abort: {
        buttonText: 'Abort',
        buttonClass: 'btn btn-danger',
        buttonDisabled: false
    },
    retry: {
        buttonText: 'Retry',
        buttonClass: 'btn btn-primary',
        buttonDisabled: false
    },
    ignore: {
        buttonText: 'Ignore',
        buttonClass: 'btn btn-warning',
        buttonDisabled: false
    },
    previous: {
        buttonText: 'Previous',
        buttonClass: 'btn btn-gray-100',
        buttonDisabled: false
    },
    next: {
        buttonText: 'Next',
        buttonClass: 'btn btn-theme',
        buttonDisabled: false
    }
};

class RouterModal {
    constructor(router, activatedRoute) {
        this.router = router;
        this.activatedRoute = activatedRoute;
        this.modalChanges = new EventEmitter();
        //
    }
    /**
     * Gets or modal window title
     */
    get modalTitle() {
        return this._modalTitle;
    }
    set modalTitle(value) {
        this._modalTitle = value;
        this.modalChanges.emit({
            modalTitle: this._modalTitle,
            modalClass: this._modalClass,
        });
    }
    /**
     * Gets or sets modal window additional class
     */
    get modalClass() {
        return this._modalClass;
    }
    set modalClass(value) {
        this._modalClass = value;
        this.modalChanges.emit({
            modalTitle: this._modalTitle,
            modalClass: this._modalClass,
        });
    }
    /**
     * Closes modal window
     */
    close(navigationExtras) {
        return this.router.navigate([
            {
                outlets: {
                    modal: null
                }
            }
        ], {
            relativeTo: this.activatedRoute.parent,
        }).then(navigationEnd => {
            if (navigationEnd && navigationExtras) {
                if (this.activatedRoute.parent && this.activatedRoute.parent.component) {
                    const finalNavigationExtras = Object.assign({
                        relativeTo: this.activatedRoute.parent
                    }, navigationExtras);
                    return this.router.navigate(['.'], finalNavigationExtras);
                }
            }
            return Promise.resolve(navigationEnd);
        });
    }
}
RouterModal.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: RouterModal, deps: [{ token: i1.Router }, { token: i1.ActivatedRoute }], target: i0.ɵɵFactoryTarget.Component });
RouterModal.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: RouterModal, selector: "ng-component", inputs: { modalTitle: "modalTitle", modalClass: "modalClass" }, ngImport: i0, template: '', isInline: true });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: RouterModal, decorators: [{
            type: Component,
            args: [{
                    template: ''
                }]
        }], ctorParameters: function () { return [{ type: i1.Router }, { type: i1.ActivatedRoute }]; }, propDecorators: { modalTitle: [{
                type: Input
            }], modalClass: [{
                type: Input
            }] } });

class RouterModalYesNo extends RouterModal {
    constructor() {
        super(...arguments);
        this.buttonChanges = new EventEmitter();
        this._yesButtonText = ButtonTypes.yes.buttonText;
        this._yesButtonClass = ButtonTypes.yes.buttonClass;
        this._noButtonText = ButtonTypes.no.buttonText;
        this._noButtonClass = ButtonTypes.no.buttonClass;
        this._yesButtonDisabled = ButtonTypes.yes.buttonDisabled;
        this._noButtonDisabled = ButtonTypes.no.buttonDisabled;
    }
    get yesButtonState() {
        return {
            yes: {
                buttonText: this._yesButtonText,
                buttonClass: this._yesButtonClass,
                buttonDisabled: this._yesButtonDisabled
            }
        };
    }
    get noButtonState() {
        return {
            no: {
                buttonText: this._noButtonText,
                buttonClass: this._noButtonClass,
                buttonDisabled: this._noButtonDisabled
            }
        };
    }
    get yesButtonText() {
        return this._yesButtonText;
    }
    set yesButtonText(value) {
        this._yesButtonText = value;
        this.buttonChanges.emit(this.yesButtonState);
    }
    get yesButtonClass() {
        return this._yesButtonClass;
    }
    set yesButtonClass(value) {
        this._yesButtonClass = value;
        this.buttonChanges.emit(this.yesButtonState);
    }
    get noButtonText() {
        return this._noButtonText;
    }
    set noButtonText(value) {
        this._noButtonText = value;
        this.buttonChanges.emit(this.noButtonState);
    }
    get noButtonClass() {
        return this._noButtonClass;
    }
    set noButtonClass(value) {
        this._noButtonClass = value;
        this.buttonChanges.emit(this.noButtonState);
    }
    get yesButtonDisabled() {
        return this._yesButtonDisabled;
    }
    set yesButtonDisabled(value) {
        this._yesButtonDisabled = value;
        this.buttonChanges.emit(this.yesButtonState);
    }
    get noButtonDisabled() {
        return this._noButtonDisabled;
    }
    set noButtonDisabled(value) {
        this._noButtonDisabled = value;
        this.buttonChanges.emit(this.noButtonState);
    }
}
RouterModalYesNo.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: RouterModalYesNo, deps: null, target: i0.ɵɵFactoryTarget.Component });
RouterModalYesNo.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: RouterModalYesNo, selector: "ng-component", inputs: { yesButtonText: "yesButtonText", yesButtonClass: "yesButtonClass", noButtonText: "noButtonText", noButtonClass: "noButtonClass", yesButtonDisabled: "yesButtonDisabled", noButtonDisabled: "noButtonDisabled" }, usesInheritance: true, ngImport: i0, template: '', isInline: true });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: RouterModalYesNo, decorators: [{
            type: Component,
            args: [{
                    template: ''
                }]
        }], propDecorators: { yesButtonText: [{
                type: Input
            }], yesButtonClass: [{
                type: Input
            }], noButtonText: [{
                type: Input
            }], noButtonClass: [{
                type: Input
            }], yesButtonDisabled: [{
                type: Input
            }], noButtonDisabled: [{
                type: Input
            }] } });

// noinspection JSUnusedGlobalSymbols
class RouterModalYesNoCancel extends RouterModalYesNo {
    constructor() {
        super(...arguments);
        this._cancelButtonText = ButtonTypes.cancel.buttonText;
        this._cancelButtonClass = ButtonTypes.cancel.buttonClass;
        this._cancelButtonDisabled = ButtonTypes.cancel.buttonDisabled;
    }
    get cancelButtonState() {
        return {
            cancel: {
                buttonText: this._cancelButtonText,
                buttonClass: this._cancelButtonClass,
                buttonDisabled: this._cancelButtonDisabled
            }
        };
    }
    get cancelButtonText() {
        return this._cancelButtonText;
    }
    set cancelButtonText(value) {
        this._cancelButtonText = value;
        this.buttonChanges.emit(this.cancelButtonState);
    }
    get cancelButtonClass() {
        return this._cancelButtonClass;
    }
    set cancelButtonClass(value) {
        this._cancelButtonClass = value;
        this.buttonChanges.emit(this.cancelButtonState);
    }
    get cancelButtonDisabled() {
        return this._cancelButtonDisabled;
    }
    set cancelButtonDisabled(value) {
        this._cancelButtonDisabled = value;
        this.buttonChanges.emit(this.cancelButtonState);
    }
}
RouterModalYesNoCancel.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: RouterModalYesNoCancel, deps: null, target: i0.ɵɵFactoryTarget.Component });
RouterModalYesNoCancel.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: RouterModalYesNoCancel, selector: "ng-component", inputs: { cancelButtonText: "cancelButtonText", cancelButtonClass: "cancelButtonClass", cancelButtonDisabled: "cancelButtonDisabled" }, usesInheritance: true, ngImport: i0, template: '', isInline: true });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: RouterModalYesNoCancel, decorators: [{
            type: Component,
            args: [{
                    template: ''
                }]
        }], propDecorators: { cancelButtonText: [{
                type: Input
            }], cancelButtonClass: [{
                type: Input
            }], cancelButtonDisabled: [{
                type: Input
            }] } });

class RouterModalOkCancel extends RouterModal {
    constructor() {
        super(...arguments);
        this.buttonChanges = new EventEmitter();
        this._okButtonText = ButtonTypes.ok.buttonText;
        this._okButtonClass = ButtonTypes.ok.buttonClass;
        this._cancelButtonText = ButtonTypes.cancel.buttonText;
        this._cancelButtonClass = ButtonTypes.cancel.buttonClass;
        this._okButtonDisabled = ButtonTypes.ok.buttonDisabled;
        this._cancelButtonDisabled = ButtonTypes.cancel.buttonDisabled;
    }
    get okButtonState() {
        return {
            ok: {
                buttonText: this._okButtonText,
                buttonClass: this._okButtonClass,
                buttonDisabled: this._okButtonDisabled
            }
        };
    }
    get cancelButtonState() {
        return {
            cancel: {
                buttonText: this._cancelButtonText,
                buttonClass: this._cancelButtonClass,
                buttonDisabled: this._cancelButtonDisabled
            }
        };
    }
    get okButtonText() {
        return this._okButtonText;
    }
    set okButtonText(value) {
        this._okButtonText = value;
        this.buttonChanges.emit(this.okButtonState);
    }
    get okButtonClass() {
        return this._okButtonClass;
    }
    set okButtonClass(value) {
        this._okButtonClass = value;
        this.buttonChanges.emit(this.okButtonState);
    }
    get cancelButtonText() {
        return this._cancelButtonText;
    }
    set cancelButtonText(value) {
        this._cancelButtonText = value;
        this.buttonChanges.emit(this.cancelButtonState);
    }
    get cancelButtonClass() {
        return this._cancelButtonClass;
    }
    set cancelButtonClass(value) {
        this._cancelButtonClass = value;
        this.buttonChanges.emit(this.cancelButtonState);
    }
    get okButtonDisabled() {
        return this._okButtonDisabled;
    }
    set okButtonDisabled(value) {
        this._okButtonDisabled = value;
        this.buttonChanges.emit(this.okButtonState);
    }
    get cancelButtonDisabled() {
        return this._cancelButtonDisabled;
    }
    set cancelButtonDisabled(value) {
        this._cancelButtonDisabled = value;
        this.buttonChanges.emit(this.cancelButtonState);
    }
}
RouterModalOkCancel.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: RouterModalOkCancel, deps: null, target: i0.ɵɵFactoryTarget.Component });
RouterModalOkCancel.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: RouterModalOkCancel, selector: "ng-component", inputs: { okButtonText: "okButtonText", okButtonClass: "okButtonClass", cancelButtonText: "cancelButtonText", cancelButtonClass: "cancelButtonClass", okButtonDisabled: "okButtonDisabled", cancelButtonDisabled: "cancelButtonDisabled" }, usesInheritance: true, ngImport: i0, template: '', isInline: true });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: RouterModalOkCancel, decorators: [{
            type: Component,
            args: [{
                    template: ''
                }]
        }], propDecorators: { okButtonText: [{
                type: Input
            }], okButtonClass: [{
                type: Input
            }], cancelButtonText: [{
                type: Input
            }], cancelButtonClass: [{
                type: Input
            }], okButtonDisabled: [{
                type: Input
            }], cancelButtonDisabled: [{
                type: Input
            }] } });

class RouterModalAbortRetryIgnore extends RouterModal {
    constructor() {
        super(...arguments);
        this.buttonChanges = new EventEmitter();
        // abort button (start)
        this._abortButtonText = ButtonTypes.abort.buttonText;
        this._abortButtonClass = ButtonTypes.abort.buttonClass;
        this._abortButtonDisabled = ButtonTypes.abort.buttonDisabled;
        // abort button (end)
        // retry button (start)
        this._retryButtonText = ButtonTypes.retry.buttonText;
        this._retryButtonClass = ButtonTypes.retry.buttonClass;
        this._retryButtonDisabled = ButtonTypes.retry.buttonDisabled;
        // retry button (end)
        // ignore button (start)
        this._ignoreButtonText = ButtonTypes.ignore.buttonText;
        this._ignoreButtonClass = ButtonTypes.ignore.buttonClass;
        this._ignoreButtonDisabled = ButtonTypes.ignore.buttonDisabled;
    }
    get abortButtonState() {
        return {
            abort: {
                buttonText: this._abortButtonText,
                buttonClass: this._abortButtonClass,
                buttonDisabled: this._abortButtonDisabled
            }
        };
    }
    get retryButtonState() {
        return {
            retry: {
                buttonText: this._retryButtonText,
                buttonClass: this._retryButtonClass,
                buttonDisabled: this._retryButtonDisabled
            }
        };
    }
    get ignoreButtonState() {
        return {
            ignore: {
                buttonText: this._ignoreButtonText,
                buttonClass: this._ignoreButtonClass,
                buttonDisabled: this._ignoreButtonDisabled
            }
        };
    }
    get abortButtonText() {
        return this._abortButtonText;
    }
    set abortButtonText(value) {
        this._abortButtonText = value;
        this.buttonChanges.emit(this.abortButtonState);
    }
    get abortButtonClass() {
        return this._abortButtonClass;
    }
    set abortButtonClass(value) {
        this._abortButtonClass = value;
        this.buttonChanges.emit(this.abortButtonState);
    }
    get abortButtonDisabled() {
        return this._abortButtonDisabled;
    }
    set abortButtonDisabled(value) {
        this._abortButtonDisabled = value;
        this.buttonChanges.emit(this.abortButtonState);
    }
    get retryButtonText() {
        return this._retryButtonText;
    }
    set retryButtonText(value) {
        this._retryButtonText = value;
        this.buttonChanges.emit(this.retryButtonState);
    }
    get retryButtonClass() {
        return this._retryButtonClass;
    }
    set retryButtonClass(value) {
        this._retryButtonClass = value;
        this.buttonChanges.emit(this.retryButtonState);
    }
    get retryButtonDisabled() {
        return this._retryButtonDisabled;
    }
    set retryButtonDisabled(value) {
        this._retryButtonDisabled = value;
        this.buttonChanges.emit(this.retryButtonState);
    }
    get ignoreButtonText() {
        return this._ignoreButtonText;
    }
    set ignoreButtonText(value) {
        this._ignoreButtonText = value;
        this.buttonChanges.emit(this.ignoreButtonState);
    }
    get ignoreButtonClass() {
        return this._ignoreButtonClass;
    }
    set ignoreButtonClass(value) {
        this._ignoreButtonClass = value;
        this.buttonChanges.emit(this.ignoreButtonState);
    }
    get ignoreButtonDisabled() {
        return this._ignoreButtonDisabled;
    }
    set ignoreButtonDisabled(value) {
        this._ignoreButtonDisabled = value;
        this.buttonChanges.emit(this.ignoreButtonState);
    }
}
RouterModalAbortRetryIgnore.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: RouterModalAbortRetryIgnore, deps: null, target: i0.ɵɵFactoryTarget.Component });
RouterModalAbortRetryIgnore.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: RouterModalAbortRetryIgnore, selector: "ng-component", inputs: { abortButtonText: "abortButtonText", abortButtonClass: "abortButtonClass", abortButtonDisabled: "abortButtonDisabled", retryButtonText: "retryButtonText", retryButtonClass: "retryButtonClass", retryButtonDisabled: "retryButtonDisabled", ignoreButtonText: "ignoreButtonText", ignoreButtonClass: "ignoreButtonClass", ignoreButtonDisabled: "ignoreButtonDisabled" }, usesInheritance: true, ngImport: i0, template: '', isInline: true });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: RouterModalAbortRetryIgnore, decorators: [{
            type: Component,
            args: [{
                    template: ''
                }]
        }], propDecorators: { abortButtonText: [{
                type: Input
            }], abortButtonClass: [{
                type: Input
            }], abortButtonDisabled: [{
                type: Input
            }], retryButtonText: [{
                type: Input
            }], retryButtonClass: [{
                type: Input
            }], retryButtonDisabled: [{
                type: Input
            }], ignoreButtonText: [{
                type: Input
            }], ignoreButtonClass: [{
                type: Input
            }], ignoreButtonDisabled: [{
                type: Input
            }] } });

// noinspection JSUnusedGlobalSymbols
class RouterModalPreviousNextCancel extends RouterModal {
    constructor() {
        super(...arguments);
        this.buttonChanges = new EventEmitter();
        this._previousButtonText = ButtonTypes.previous.buttonText;
        this._previousButtonClass = ButtonTypes.previous.buttonClass;
        this._previousButtonDisabled = ButtonTypes.previous.buttonDisabled;
        this._nextButtonText = ButtonTypes.next.buttonText;
        this._nextButtonClass = ButtonTypes.next.buttonClass;
        this._nextButtonDisabled = ButtonTypes.next.buttonDisabled;
        this._cancelButtonText = ButtonTypes.cancel.buttonText;
        this._cancelButtonClass = ButtonTypes.cancel.buttonClass;
        this._cancelButtonDisabled = ButtonTypes.cancel.buttonDisabled;
    }
    get previousButtonState() {
        return {
            previous: {
                buttonText: this._previousButtonText,
                buttonClass: this._previousButtonClass,
                buttonDisabled: this._previousButtonDisabled
            }
        };
    }
    get nextButtonState() {
        return {
            next: {
                buttonText: this._nextButtonText,
                buttonClass: this._nextButtonClass,
                buttonDisabled: this._nextButtonDisabled
            }
        };
    }
    get cancelButtonState() {
        return {
            cancel: {
                buttonText: this._cancelButtonText,
                buttonClass: this._cancelButtonClass,
                buttonDisabled: this._cancelButtonDisabled
            }
        };
    }
    get previousButtonText() {
        return this._previousButtonText;
    }
    set previousButtonText(value) {
        this._previousButtonText = value;
        this.buttonChanges.emit(this.previousButtonState);
    }
    get previousButtonClass() {
        return this._previousButtonClass;
    }
    set previousButtonClass(value) {
        this._previousButtonClass = value;
        this.buttonChanges.emit(this.previousButtonState);
    }
    get previousButtonDisabled() {
        return this._previousButtonDisabled;
    }
    set previousButtonDisabled(value) {
        this._previousButtonDisabled = value;
        this.buttonChanges.emit(this.previousButtonState);
    }
    get nextButtonText() {
        return this._nextButtonText;
    }
    set nextButtonText(value) {
        this._nextButtonText = value;
        this.buttonChanges.emit(this.nextButtonState);
    }
    get nextButtonClass() {
        return this._nextButtonClass;
    }
    set nextButtonClass(value) {
        this._nextButtonClass = value;
        this.buttonChanges.emit(this.nextButtonState);
    }
    get nextButtonDisabled() {
        return this._nextButtonDisabled;
    }
    set nextButtonDisabled(value) {
        this._nextButtonDisabled = value;
        this.buttonChanges.emit(this.nextButtonState);
    }
    get cancelButtonText() {
        return this._cancelButtonText;
    }
    set cancelButtonText(value) {
        this._cancelButtonText = value;
        this.buttonChanges.emit(this.cancelButtonState);
    }
    get cancelButtonClass() {
        return this._cancelButtonClass;
    }
    set cancelButtonClass(value) {
        this._cancelButtonClass = value;
        this.buttonChanges.emit(this.cancelButtonState);
    }
    get cancelButtonDisabled() {
        return this._cancelButtonDisabled;
    }
    set cancelButtonDisabled(value) {
        this._cancelButtonDisabled = value;
        this.buttonChanges.emit(this.cancelButtonState);
    }
}
RouterModalPreviousNextCancel.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: RouterModalPreviousNextCancel, deps: null, target: i0.ɵɵFactoryTarget.Component });
RouterModalPreviousNextCancel.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: RouterModalPreviousNextCancel, selector: "ng-component", inputs: { previousButtonText: "previousButtonText", previousButtonClass: "previousButtonClass", previousButtonDisabled: "previousButtonDisabled", nextButtonText: "nextButtonText", nextButtonClass: "nextButtonClass", nextButtonDisabled: "nextButtonDisabled", cancelButtonText: "cancelButtonText", cancelButtonClass: "cancelButtonClass", cancelButtonDisabled: "cancelButtonDisabled" }, usesInheritance: true, ngImport: i0, template: '', isInline: true });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: RouterModalPreviousNextCancel, decorators: [{
            type: Component,
            args: [{
                    template: ''
                }]
        }], propDecorators: { previousButtonText: [{
                type: Input
            }], previousButtonClass: [{
                type: Input
            }], previousButtonDisabled: [{
                type: Input
            }], nextButtonText: [{
                type: Input
            }], nextButtonClass: [{
                type: Input
            }], nextButtonDisabled: [{
                type: Input
            }], cancelButtonText: [{
                type: Input
            }], cancelButtonClass: [{
                type: Input
            }], cancelButtonDisabled: [{
                type: Input
            }] } });

class RouterModalComponent {
    constructor(_element, _activatedRoute, _router, _renderer) {
        this._element = _element;
        this._activatedRoute = _activatedRoute;
        this._router = _router;
        this._renderer = _renderer;
        this.componentModalChanges = null;
        this.componentButtonChanges = null;
        this.waiting = false;
        this.modalTitle = '';
        // these properties are here as inputs in order to have a way to customize text and class of each button
        this.okButtonText = ButtonTypes.ok.buttonText;
        this.okButtonClass = ButtonTypes.ok.buttonClass;
        this.cancelButtonText = ButtonTypes.cancel.buttonText;
        this.cancelButtonClass = ButtonTypes.cancel.buttonClass;
        this.yesButtonText = ButtonTypes.yes.buttonText;
        this.yesButtonClass = ButtonTypes.yes.buttonClass;
        this.noButtonText = ButtonTypes.no.buttonText;
        this.noButtonClass = ButtonTypes.no.buttonClass;
        this.abortButtonText = ButtonTypes.abort.buttonText;
        this.abortButtonClass = ButtonTypes.abort.buttonClass;
        this.retryButtonText = ButtonTypes.retry.buttonText;
        this.retryButtonClass = ButtonTypes.retry.buttonClass;
        this.ignoreButtonText = ButtonTypes.ignore.buttonText;
        this.ignoreButtonClass = ButtonTypes.ignore.buttonClass;
        this.previousButtonText = ButtonTypes.previous.buttonText;
        this.previousButtonClass = ButtonTypes.previous.buttonClass;
        this.nextButtonText = ButtonTypes.next.buttonText;
        this.nextButtonClass = ButtonTypes.next.buttonClass;
        // default instance buttons
        this.instanceButtons = {
            ok: null,
            cancel: null,
            yes: null,
            no: null,
            abort: null,
            retry: null,
            ignore: null,
            previous: null,
            next: null
        };
    }
    async cancel() {
        try {
            if (this.componentReference) {
                // set waiting
                this.waiting = true;
                // if component has cancel() method
                if (typeof this.componentReference.cancel === 'function') {
                    // do cancel
                    await this.componentReference.cancel();
                }
                else {
                    await this._router.navigate(['../'], { relativeTo: this._activatedRoute });
                }
                // unset waiting
                this.waiting = false;
            }
        }
        catch (err) {
            this.waiting = false;
        }
    }
    async ok() {
        try {
            if (this.componentReference) {
                // set waiting
                this.waiting = true;
                if (typeof this.componentReference.ok === 'function') {
                    // do submit
                    await this.componentReference.ok();
                }
                else {
                    await this._router.navigate(['../'], { relativeTo: this._activatedRoute });
                }
                // unset waiting
                this.waiting = false;
            }
        }
        catch (err) {
            this.waiting = false;
        }
    }
    async abort() {
        try {
            if (this.componentReference) {
                // set waiting
                this.waiting = true;
                if (typeof this.componentReference.abort === 'function') {
                    // do submit
                    await this.componentReference.abort();
                }
                else {
                    await this._router.navigate(['../'], { relativeTo: this._activatedRoute });
                }
                // unset waiting
                this.waiting = false;
            }
        }
        catch (err) {
            this.waiting = false;
        }
    }
    async retry() {
        try {
            if (this.componentReference) {
                // set waiting
                this.waiting = true;
                if (typeof this.componentReference.retry === 'function') {
                    // do submit
                    await this.componentReference.retry();
                }
                else {
                    await this._router.navigate(['../'], { relativeTo: this._activatedRoute });
                }
                // unset waiting
                this.waiting = false;
            }
        }
        catch (err) {
            this.waiting = false;
        }
    }
    async ignore() {
        try {
            if (this.componentReference) {
                // set waiting
                this.waiting = true;
                if (typeof this.componentReference.ignore === 'function') {
                    // do submit
                    await this.componentReference.ignore();
                }
                else {
                    await this._router.navigate(['../'], { relativeTo: this._activatedRoute });
                }
                // unset waiting
                this.waiting = false;
            }
        }
        catch (err) {
            this.waiting = false;
        }
    }
    async previous() {
        try {
            if (this.componentReference) {
                // set waiting
                this.waiting = true;
                if (typeof this.componentReference.previous === 'function') {
                    // do submit
                    await this.componentReference.previous();
                }
                else {
                    await this._router.navigate(['../'], { relativeTo: this._activatedRoute });
                }
                // unset waiting
                this.waiting = false;
            }
        }
        catch (err) {
            this.waiting = false;
        }
    }
    async next() {
        try {
            if (this.componentReference) {
                // set waiting
                this.waiting = true;
                if (typeof this.componentReference.next === 'function') {
                    // do submit
                    await this.componentReference.next();
                }
                else {
                    await this._router.navigate(['../'], { relativeTo: this._activatedRoute });
                }
                // unset waiting
                this.waiting = false;
            }
        }
        catch (err) {
            this.waiting = false;
        }
    }
    async yes() {
        try {
            if (this.componentReference) {
                // set waiting
                this.waiting = true;
                if (typeof this.componentReference.yes === 'function') {
                    // do submit
                    await this.componentReference.yes();
                }
                else {
                    await this._router.navigate(['../'], { relativeTo: this._activatedRoute });
                }
                // unset waiting
                this.waiting = false;
            }
        }
        catch (err) {
            this.waiting = false;
        }
    }
    async no() {
        try {
            if (this.componentReference) {
                // set waiting
                this.waiting = true;
                if (typeof this.componentReference.no === 'function') {
                    // do submit
                    await this.componentReference.no();
                }
                else {
                    await this._router.navigate(['../'], { relativeTo: this._activatedRoute });
                }
                // unset waiting
                this.waiting = false;
            }
        }
        catch (err) {
            this.waiting = false;
        }
    }
    onActivate(event) {
        this.componentReference = event;
        // get router outlet component
        if (this.componentReference) {
            if (this.componentReference.buttonChanges) {
                // subscribe for any button changes
                this.componentButtonChanges = this.componentReference.buttonChanges
                    .subscribe((buttonChange) => {
                    if (buttonChange) {
                        // assign button changes
                        Object.assign(this.instanceButtons, buttonChange);
                    }
                });
            }
            if (this.componentReference.modalChanges) {
                // get modal changes
                this.componentModalChanges = this.componentReference.modalChanges.subscribe((modalChanges) => {
                    this.modalInstanceTitle = modalChanges.modalTitle;
                    if (modalChanges.modalClass) {
                        this.modalInstanceClass = modalChanges.modalClass;
                    }
                });
            }
            // get title
            this.modalInstanceTitle = this.componentReference.modalTitle;
            // get class
            this.modalInstanceClass = this.componentReference.modalClass;
            // hold this to validate buttons
            let hasAtLeastOneButton = false;
            this.instanceButtons = {
                ok: null,
                cancel: null,
                yes: null,
                no: null,
                abort: null,
                retry: null,
                ignore: null,
                previous: null,
                next: null
            };
            // enumerate button types
            Object.keys(ButtonTypes).forEach(key => {
                // search if component has a method with the same name
                if (typeof this.componentReference[key] === 'function') {
                    // enable button
                    this.instanceButtons[key] = Object.assign({}, ButtonTypes[key]);
                    hasAtLeastOneButton = true;
                    const buttonTextProperty = `${key}ButtonText`;
                    if (this.componentReference.hasOwnProperty(buttonTextProperty)) {
                        this.instanceButtons[key].buttonText = this.componentReference[buttonTextProperty];
                    }
                    else {
                        // get property from this component
                        this.instanceButtons[key].buttonText = this[buttonTextProperty];
                    }
                    const buttonClassProperty = `${key}ButtonClass`;
                    if (this.componentReference.hasOwnProperty(buttonClassProperty)) {
                        this.instanceButtons[key].buttonClass = this.componentReference[buttonClassProperty];
                    }
                    else {
                        // get property from this component
                        this.instanceButtons[key].buttonClass = this[buttonClassProperty];
                    }
                }
            });
            if (!hasAtLeastOneButton) {
                // there are no buttons, so add only ok
                this.instanceButtons.ok = Object.assign({}, ButtonTypes.ok);
            }
        }
        const backdropElement = this._element.nativeElement.querySelector('.modal-backdrop');
        this._element.nativeElement.querySelector('.bd-modal').classList.remove('d-none');
        this._renderer.addClass(document.body, 'overflow-hidden');
        this._renderer.addClass(document.body, 'pr-3');
        // add large modal default styles
        // this operation adds scrolling to modal container
        // in cases where modal overflows the height of the container
        const modalElement = this._element.nativeElement.querySelector('.modal');
        if (modalElement) {
            modalElement.style.setProperty('overflow-x', 'hidden');
            modalElement.style.setProperty('overflow-y', 'auto');
        }
        if (backdropElement) {
            // remove d-none
            backdropElement.classList.remove('d-none');
            // add show
            backdropElement.classList.add('show');
        }
        return false;
    }
    // noinspection JSUnusedLocalSymbols
    onDeactivate(event) {
        if (this.componentModalChanges) {
            this.componentModalChanges.unsubscribe();
            this.componentModalChanges = null;
        }
        if (this.componentButtonChanges) {
            this.componentButtonChanges.unsubscribe();
            this.componentButtonChanges = null;
        }
        // restore properties
        this.modalInstanceTitle = this.modalTitle;
        this.modalInstanceClass = this.modalClass;
        this.componentReference = null;
        const backdropElement = this._element.nativeElement.querySelector('.modal-backdrop');
        this._element.nativeElement.querySelector('.bd-modal').classList.add('d-none');
        this._renderer.removeClass(document.body, 'overflow-hidden');
        this._renderer.removeClass(document.body, 'pr-3');
        if (backdropElement) {
            // remove show
            backdropElement.classList.remove('show');
            // add d-none
            backdropElement.classList.add('d-none');
        }
        return false;
    }
}
RouterModalComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: RouterModalComponent, deps: [{ token: i0.ElementRef }, { token: i1.ActivatedRoute }, { token: i1.Router }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Component });
RouterModalComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: RouterModalComponent, selector: "router-modal", inputs: { modalTitle: "modalTitle", modalClass: "modalClass", okButtonText: "okButtonText", okButtonClass: "okButtonClass", cancelButtonText: "cancelButtonText", cancelButtonClass: "cancelButtonClass", yesButtonText: "yesButtonText", yesButtonClass: "yesButtonClass", noButtonText: "noButtonText", noButtonClass: "noButtonClass", abortButtonText: "abortButtonText", abortButtonClass: "abortButtonClass", retryButtonText: "retryButtonText", retryButtonClass: "retryButtonClass", ignoreButtonText: "ignoreButtonText", ignoreButtonClass: "ignoreButtonClass", previousButtonText: "previousButtonText", previousButtonClass: "previousButtonClass", nextButtonText: "nextButtonText", nextButtonClass: "nextButtonClass" }, ngImport: i0, template: `
  <div class="bd-modal d-none">
    <div class="modal-backdrop fade d-none"></div>
    <div class="modal" tabindex="-1" role="dialog" [ngClass]="{ 'modal-waiting': waiting }">
    <div class="modal-dialog" [ngClass]="modalInstanceClass" role="document">
      <div class="modal-content">
        <div class="modal-header" *ngIf="modalInstanceTitle">
          <h5 class="modal-title">{{modalInstanceTitle | translate}}</h5>
          <button *ngIf="instanceButtons.cancel" [disabled]="waiting || instanceButtons.cancel.buttonDisabled" (click)="cancel()"
                  type="button" class="close" data-dismiss="modal" aria-label="Cancel">
            <span aria-hidden="true">&times;</span>
          </button>
        </div>
        <div class="modal-body">
          <router-outlet (activate)="onActivate($event)" (deactivate)="onDeactivate($event)" name="modal"></router-outlet>
        </div>
        <div class="modal-footer justify-content-end">
          <button *ngIf="instanceButtons.previous" [disabled]="waiting || instanceButtons.previous.buttonDisabled" (click)="previous()"
                  type="button" [ngClass]="instanceButtons.previous.buttonClass">
            {{instanceButtons.previous.buttonText | translate}}
          </button>
          <button *ngIf="instanceButtons.ok" [disabled]="waiting || instanceButtons.ok.buttonDisabled" (click)="ok()"
                  type="button" [ngClass]="instanceButtons.ok.buttonClass">
            {{instanceButtons.ok.buttonText | translate}}
          </button>
          <button *ngIf="instanceButtons.yes" [disabled]="waiting || instanceButtons.yes.buttonDisabled"
                  (click)="yes()" type="button" [ngClass]="instanceButtons.yes.buttonClass">
            {{instanceButtons.yes.buttonText | translate}}
          </button>
          <button *ngIf="instanceButtons.no" [disabled]="waiting || instanceButtons.no.buttonDisabled"
                  (click)="no()" type="button" [ngClass]="instanceButtons.no.buttonClass">
            {{instanceButtons.no.buttonText | translate}}
          </button>
          <button *ngIf="instanceButtons.next" [disabled]="waiting || instanceButtons.next.buttonDisabled" (click)="next()"
                  type="button" [ngClass]="instanceButtons.next.buttonClass">
            {{instanceButtons.next.buttonText | translate}}
          </button>
          <button *ngIf="instanceButtons.cancel" [disabled]="waiting || instanceButtons.cancel.buttonDisabled"
                  (click)="cancel()" type="button" [ngClass]="instanceButtons.cancel.buttonClass" data-dismiss="modal">
            {{instanceButtons.cancel.buttonText | translate}}
          </button>
          <button *ngIf="instanceButtons.abort" [disabled]="waiting || instanceButtons.abort.buttonDisabled"
                  (click)="abort()" type="button" [ngClass]="instanceButtons.abort.buttonClass">
            {{instanceButtons.abort.buttonText | translate}}
          </button>
          <button *ngIf="instanceButtons.retry" [disabled]="waiting || instanceButtons.retry.buttonDisabled"
                  (click)="retry()" type="button" [ngClass]="instanceButtons.retry.buttonClass">
            {{instanceButtons.retry.buttonText | translate}}
          </button>
          <button *ngIf="instanceButtons.ignore" [disabled]="waiting || instanceButtons.ignore.buttonDisabled"
                  (click)="ignore()" type="button" [ngClass]="instanceButtons.ignore.buttonClass" data-dismiss="modal">
            {{instanceButtons.ignore.buttonText | translate}}
          </button>
        </div>
      </div>
    </div>
  </div>
  </div>
  `, isInline: true, styles: [".bd-modal .modal{position:fixed;right:auto;bottom:auto;z-index:1045;display:block}.bd-modal .modal .modal-body{margin-top:0;margin-bottom:0}.bd-modal .modal.modal-waiting{opacity:.6}\n"], dependencies: [{ kind: "directive", type: i1.RouterOutlet, selector: "router-outlet", inputs: ["name"], outputs: ["activate", "deactivate", "attach", "detach"], exportAs: ["outlet"] }, { kind: "directive", type: i2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i3.TranslatePipe, name: "translate" }], encapsulation: i0.ViewEncapsulation.None });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: RouterModalComponent, decorators: [{
            type: Component,
            args: [{ selector: 'router-modal', template: `
  <div class="bd-modal d-none">
    <div class="modal-backdrop fade d-none"></div>
    <div class="modal" tabindex="-1" role="dialog" [ngClass]="{ 'modal-waiting': waiting }">
    <div class="modal-dialog" [ngClass]="modalInstanceClass" role="document">
      <div class="modal-content">
        <div class="modal-header" *ngIf="modalInstanceTitle">
          <h5 class="modal-title">{{modalInstanceTitle | translate}}</h5>
          <button *ngIf="instanceButtons.cancel" [disabled]="waiting || instanceButtons.cancel.buttonDisabled" (click)="cancel()"
                  type="button" class="close" data-dismiss="modal" aria-label="Cancel">
            <span aria-hidden="true">&times;</span>
          </button>
        </div>
        <div class="modal-body">
          <router-outlet (activate)="onActivate($event)" (deactivate)="onDeactivate($event)" name="modal"></router-outlet>
        </div>
        <div class="modal-footer justify-content-end">
          <button *ngIf="instanceButtons.previous" [disabled]="waiting || instanceButtons.previous.buttonDisabled" (click)="previous()"
                  type="button" [ngClass]="instanceButtons.previous.buttonClass">
            {{instanceButtons.previous.buttonText | translate}}
          </button>
          <button *ngIf="instanceButtons.ok" [disabled]="waiting || instanceButtons.ok.buttonDisabled" (click)="ok()"
                  type="button" [ngClass]="instanceButtons.ok.buttonClass">
            {{instanceButtons.ok.buttonText | translate}}
          </button>
          <button *ngIf="instanceButtons.yes" [disabled]="waiting || instanceButtons.yes.buttonDisabled"
                  (click)="yes()" type="button" [ngClass]="instanceButtons.yes.buttonClass">
            {{instanceButtons.yes.buttonText | translate}}
          </button>
          <button *ngIf="instanceButtons.no" [disabled]="waiting || instanceButtons.no.buttonDisabled"
                  (click)="no()" type="button" [ngClass]="instanceButtons.no.buttonClass">
            {{instanceButtons.no.buttonText | translate}}
          </button>
          <button *ngIf="instanceButtons.next" [disabled]="waiting || instanceButtons.next.buttonDisabled" (click)="next()"
                  type="button" [ngClass]="instanceButtons.next.buttonClass">
            {{instanceButtons.next.buttonText | translate}}
          </button>
          <button *ngIf="instanceButtons.cancel" [disabled]="waiting || instanceButtons.cancel.buttonDisabled"
                  (click)="cancel()" type="button" [ngClass]="instanceButtons.cancel.buttonClass" data-dismiss="modal">
            {{instanceButtons.cancel.buttonText | translate}}
          </button>
          <button *ngIf="instanceButtons.abort" [disabled]="waiting || instanceButtons.abort.buttonDisabled"
                  (click)="abort()" type="button" [ngClass]="instanceButtons.abort.buttonClass">
            {{instanceButtons.abort.buttonText | translate}}
          </button>
          <button *ngIf="instanceButtons.retry" [disabled]="waiting || instanceButtons.retry.buttonDisabled"
                  (click)="retry()" type="button" [ngClass]="instanceButtons.retry.buttonClass">
            {{instanceButtons.retry.buttonText | translate}}
          </button>
          <button *ngIf="instanceButtons.ignore" [disabled]="waiting || instanceButtons.ignore.buttonDisabled"
                  (click)="ignore()" type="button" [ngClass]="instanceButtons.ignore.buttonClass" data-dismiss="modal">
            {{instanceButtons.ignore.buttonText | translate}}
          </button>
        </div>
      </div>
    </div>
  </div>
  </div>
  `, encapsulation: ViewEncapsulation.None, styles: [".bd-modal .modal{position:fixed;right:auto;bottom:auto;z-index:1045;display:block}.bd-modal .modal .modal-body{margin-top:0;margin-bottom:0}.bd-modal .modal.modal-waiting{opacity:.6}\n"] }]
        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.ActivatedRoute }, { type: i1.Router }, { type: i0.Renderer2 }]; }, propDecorators: { modalTitle: [{
                type: Input
            }], modalClass: [{
                type: Input
            }], okButtonText: [{
                type: Input
            }], okButtonClass: [{
                type: Input
            }], cancelButtonText: [{
                type: Input
            }], cancelButtonClass: [{
                type: Input
            }], yesButtonText: [{
                type: Input
            }], yesButtonClass: [{
                type: Input
            }], noButtonText: [{
                type: Input
            }], noButtonClass: [{
                type: Input
            }], abortButtonText: [{
                type: Input
            }], abortButtonClass: [{
                type: Input
            }], retryButtonText: [{
                type: Input
            }], retryButtonClass: [{
                type: Input
            }], ignoreButtonText: [{
                type: Input
            }], ignoreButtonClass: [{
                type: Input
            }], previousButtonText: [{
                type: Input
            }], previousButtonClass: [{
                type: Input
            }], nextButtonText: [{
                type: Input
            }], nextButtonClass: [{
                type: Input
            }] } });

class RouterModalModule {
    constructor() {
        //
    }
}
RouterModalModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: RouterModalModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
RouterModalModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.10", ngImport: i0, type: RouterModalModule, declarations: [RouterModalComponent], imports: [RouterModule,
        CommonModule,
        TranslateModule], exports: [RouterModalComponent] });
RouterModalModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: RouterModalModule, imports: [RouterModule,
        CommonModule,
        TranslateModule] });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: RouterModalModule, decorators: [{
            type: NgModule,
            args: [{
                    declarations: [RouterModalComponent],
                    imports: [
                        RouterModule,
                        CommonModule,
                        TranslateModule
                    ],
                    providers: [],
                    exports: [RouterModalComponent]
                }]
        }], ctorParameters: function () { return []; } });

/*
 * Public API Surface of modals
 */

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

export { ButtonTypes, RouterModal, RouterModalAbortRetryIgnore, RouterModalComponent, RouterModalModule, RouterModalOkCancel, RouterModalPreviousNextCancel, RouterModalYesNo, RouterModalYesNoCancel };
//# sourceMappingURL=universis-common-routing.mjs.map