codefoxcore 0.0.1

package/fesm2022/codefoxcore.mjs

@@ -0,0 +1,820 @@
+import { Subject, filter, Observable, takeUntil, timer } from 'rxjs';
+import { isPlatformBrowser } from '@angular/common';
+import * as i0 from '@angular/core';
+import { InjectionToken, inject, Injector, PLATFORM_ID, ApplicationRef, createComponent, Injectable } from '@angular/core';
+import { Title } from '@angular/platform-browser';
+import { HttpClient } from '@angular/common/http';
+
+class DialogRef {
+    constructor() {
+        this.messageService = null;
+        this.dialogConfig = null;
+        this._onClose = new Subject();
+        this.onClose = this._onClose.asObservable();
+        this.onCloseValue = this._onClose.pipe(filter(result => result !== undefined && result !== null));
+        this.onCloseOnValue = (value) => this._onClose.pipe(filter(result => result === value));
+        this._onMessage = new Subject();
+        this.onMessage = this._onMessage.asObservable();
+        this._onDestroy = new Subject();
+        this.onDestroy = this._onDestroy.asObservable();
+        this.savedTitle = '';
+        this.title = null;
+        this.opened = new Date();
+    }
+    doClose(result, params = {}) {
+        if (params.message !== undefined && this.messageService !== null) {
+            this.messageService.show(params.message.title, params.message.message, params.message);
+        }
+        this._onClose.next(result);
+    }
+    close(result, params = {}) {
+        if (this.dialogConfig === null || this.dialogConfig.beforeClose === null) {
+            this.doClose(result, params);
+            return;
+        }
+        if (this.dialogConfig.beforeClose instanceof Promise) {
+            this.dialogConfig.beforeClose.then((value) => {
+                if (value) {
+                    this.doClose(result, params);
+                }
+            }).catch(() => { });
+            return;
+        }
+        if (this.dialogConfig.beforeClose instanceof Observable) {
+            this.dialogConfig.beforeClose.pipe(takeUntil(this._onClose)).subscribe((value) => {
+                if (value) {
+                    this.doClose(result, params);
+                }
+            });
+            return;
+        }
+        const beforeCloseResult = this.dialogConfig.beforeClose();
+        if (beforeCloseResult instanceof Promise) {
+            beforeCloseResult.then((value) => {
+                if (value) {
+                    this.doClose(result, params);
+                }
+            }).catch(() => { });
+            return;
+        }
+        if (beforeCloseResult instanceof Observable) {
+            beforeCloseResult.pipe(takeUntil(this._onClose)).subscribe((value) => {
+                if (value) {
+                    this.doClose(result, params);
+                }
+            });
+            return;
+        }
+        if (beforeCloseResult) {
+            this.doClose(result, params);
+        }
+    }
+    forceClose(result) {
+        this.doClose(result);
+    }
+    message(message) { this._onMessage.next(message); }
+    destroy() { this._onDestroy.next(undefined); }
+}
+
+class DialogConfig {
+    constructor() {
+        this.showCloseIcon = true;
+        this.beforeClose = null;
+        this.ignoreKeyUp = false;
+        this.data = {};
+        this.noPadding = false;
+        this.keepActiveElement = false;
+        this.containerClasses = [];
+        this.dialogClasses = [];
+        this.resolve = {};
+        this.title = null;
+        this.contentElement = null;
+        this.single = false;
+        this.width = null;
+        this.height = null;
+    }
+    getData(key, defaultOnUndefined = null) {
+        return this.data[key] !== undefined ? this.data[key] : defaultOnUndefined;
+    }
+}
+
+class DialogInjector {
+    constructor(_parentInjector, _additionalTokens) {
+        this._parentInjector = _parentInjector;
+        this._additionalTokens = _additionalTokens;
+    }
+    get(token, notFoundValue, _) {
+        const value = this._additionalTokens.get(token);
+        if (value) {
+            return value;
+        }
+        return this._parentInjector.get(token, notFoundValue);
+    }
+}
+
+const ALERT_DEFAULT_BUTTON_CONFIGURATION = new InjectionToken('Alert default button', {
+    factory: () => {
+        return {
+            label: 'alert.ok',
+            severity: 'success',
+            callback: ({ dialogRef }) => {
+                dialogRef.close();
+            },
+            focus: true,
+            translateLabel: true
+        };
+    }
+});
+const ALERT_CONFIGURATIONS = new InjectionToken('Alert configurations predefined', {
+    factory: () => {
+        return {};
+    }
+});
+
+const CF_PREDEFINED_DIALOGS = new InjectionToken('Predefined dialogs', {
+    factory: () => {
+        return {};
+    }
+});
+
+const CONFIRM_CONFIGURATIONS = new InjectionToken('Confirm configurations predefined', {
+    factory: () => {
+        return {};
+    }
+});
+
+var AcceptValidationMode;
+(function (AcceptValidationMode) {
+    AcceptValidationMode["PATTERN"] = "PATTERN";
+    AcceptValidationMode["TEXT"] = "TEXT";
+})(AcceptValidationMode || (AcceptValidationMode = {}));
+var MessagePosition;
+(function (MessagePosition) {
+    MessagePosition["TOP"] = "top";
+    MessagePosition["BOTTOM"] = "bottom";
+})(MessagePosition || (MessagePosition = {}));
+var MessageSeverity;
+(function (MessageSeverity) {
+    MessageSeverity["SUCCESS"] = "success";
+    MessageSeverity["WARNING"] = "warning";
+    MessageSeverity["DANGER"] = "danger";
+    MessageSeverity["INFO"] = "info";
+})(MessageSeverity || (MessageSeverity = {}));
+var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["All"] = 0] = "All";
+    LogLevel[LogLevel["Debug"] = 1] = "Debug";
+    LogLevel[LogLevel["Info"] = 2] = "Info";
+    LogLevel[LogLevel["Warn"] = 3] = "Warn";
+    LogLevel[LogLevel["Error"] = 4] = "Error";
+    LogLevel[LogLevel["Fatal"] = 5] = "Fatal";
+    LogLevel[LogLevel["Off"] = 6] = "Off";
+})(LogLevel || (LogLevel = {}));
+
+const MESSAGE_DEFAULT_CONFIGURATION = new InjectionToken('Message default configuration', {
+    factory: () => {
+        return {
+            closeable: true,
+            lifetime: 3000,
+            position: MessagePosition.TOP,
+            severity: MessageSeverity.SUCCESS,
+            keepOnHover: false
+        };
+    }
+});
+
+const LOG_LEVEL = new InjectionToken('Log level', {
+    factory: () => {
+        return LogLevel.All;
+    }
+});
+
+class DialogService {
+    constructor() {
+        this.injector = inject(Injector);
+        this.predefinedConfirmConfigurations = inject(CONFIRM_CONFIGURATIONS);
+        this.predefinedAlertConfigurations = inject(ALERT_CONFIGURATIONS);
+        this.predefinedDialogs = inject(CF_PREDEFINED_DIALOGS);
+        this.title = inject(Title);
+        this.messageService = inject(MessageService);
+        this.dialogs = new Map();
+        this.openIndex = 1;
+        this.platformId = inject(PLATFORM_ID);
+        if (isPlatformBrowser(this.platformId)) {
+            document.addEventListener("keyup", (keyboardEvent) => {
+                if (keyboardEvent.key.toLowerCase() === 'escape') {
+                    let lastOpenIndex = 0;
+                    let lastOpenedDialogRef = null;
+                    for (const [dialogRef, cfDialogComponentRefContainer] of this.dialogs.entries()) {
+                        if (cfDialogComponentRefContainer.openIndex > lastOpenIndex) {
+                            lastOpenIndex = cfDialogComponentRefContainer.openIndex;
+                            lastOpenedDialogRef = dialogRef;
+                        }
+                    }
+                    if (lastOpenedDialogRef !== null && lastOpenedDialogRef.dialogConfig !== null) {
+                        if (lastOpenedDialogRef.dialogConfig.ignoreKeyUp || document.activeElement instanceof HTMLInputElement || document.activeElement instanceof HTMLTextAreaElement) {
+                            return;
+                        }
+                        lastOpenedDialogRef.close();
+                    }
+                }
+            });
+        }
+    }
+    async openPredefined(name, dialogConfiguration = {}) {
+        if (this.predefinedDialogs[name] === undefined) {
+            throw Error('Dialog with name "' + name + '" not found!');
+        }
+        const predefinedDialog = this.predefinedDialogs[name];
+        if (typeof predefinedDialog === 'function') {
+            return this.openImport(predefinedDialog, dialogConfiguration);
+        }
+        return this.openImport(predefinedDialog.component, { ...predefinedDialog.configuration, ...dialogConfiguration });
+    }
+    async openImport(component, dialogConfiguration = {}) {
+        return new Promise(async (resolve) => {
+            resolve(this.open(await component(), dialogConfiguration));
+        });
+    }
+    open(component, dialogConfiguration = {}) {
+        for (let dialog of this.dialogs.entries()) {
+            if ((dialogConfiguration.single && dialog[1].componentRef.componentType.name === component.name) ||
+                (dialog[0].dialogConfig !== null && dialog[0].dialogConfig.single && dialog[1].componentRef.componentType.name === component.name)) {
+                return dialog[0];
+            }
+        }
+        const dialogConfig = this.createDialogConfig(dialogConfiguration);
+        if (!dialogConfig.keepActiveElement) {
+            if (document.activeElement instanceof HTMLElement) {
+                document.activeElement.blur();
+            }
+        }
+        const dialogRef = this.appendToBody(component, dialogConfig);
+        dialogRef.messageService = this.messageService;
+        dialogRef.dialogConfig = dialogConfig;
+        this.changeAndStoreTitle(dialogRef);
+        return dialogRef;
+    }
+    changeAndStoreTitle(dialogRef) {
+        dialogRef.savedTitle = this.title.getTitle();
+        if (dialogRef.dialogConfig !== null && dialogRef.dialogConfig.title !== null) {
+            this.title.setTitle(dialogRef.dialogConfig.title);
+        }
+    }
+    createDialogConfig(dialogConfiguration) {
+        const dialogConfig = new DialogConfig();
+        if (dialogConfiguration.showCloseIcon !== undefined) {
+            dialogConfig.showCloseIcon = dialogConfiguration.showCloseIcon;
+        }
+        if (dialogConfiguration.beforeClose !== undefined) {
+            dialogConfig.beforeClose = dialogConfiguration.beforeClose;
+        }
+        if (dialogConfiguration.ignoreKeyUp !== undefined) {
+            dialogConfig.ignoreKeyUp = dialogConfiguration.ignoreKeyUp;
+        }
+        if (dialogConfiguration.data !== undefined) {
+            dialogConfig.data = dialogConfiguration.data;
+        }
+        if (dialogConfiguration.noPadding !== undefined) {
+            dialogConfig.noPadding = dialogConfiguration.noPadding;
+        }
+        if (dialogConfiguration.keepActiveElement !== undefined) {
+            dialogConfig.keepActiveElement = dialogConfiguration.keepActiveElement;
+        }
+        if (dialogConfiguration.containerClasses !== undefined) {
+            dialogConfig.containerClasses = dialogConfiguration.containerClasses;
+        }
+        if (dialogConfiguration.dialogClasses !== undefined) {
+            dialogConfig.dialogClasses = dialogConfiguration.dialogClasses;
+        }
+        if (dialogConfiguration.title !== undefined) {
+            dialogConfig.title = dialogConfiguration.title;
+        }
+        if (dialogConfiguration.contentElement !== undefined) {
+            dialogConfig.contentElement = dialogConfiguration.contentElement;
+        }
+        if (dialogConfiguration.single !== undefined) {
+            dialogConfig.single = dialogConfiguration.single;
+        }
+        if (dialogConfiguration.width !== undefined) {
+            dialogConfig.width = dialogConfiguration.width;
+        }
+        if (dialogConfiguration.height !== undefined) {
+            dialogConfig.height = dialogConfiguration.height;
+        }
+        return dialogConfig;
+    }
+    appendToBody(component, dialogConfig) {
+        const appRef = this.injector.get(ApplicationRef);
+        // CREATE INJECTION TOKENS
+        const tokens = new WeakMap();
+        // CREATE DIALOG CONFIGURATION CLASS
+        tokens.set(DialogConfig, dialogConfig);
+        // CREATE DIALOG REFERENCE CLASS
+        const dialogRef = new DialogRef();
+        tokens.set(DialogRef, dialogRef);
+        // LISTEN ON DIALOG CLOSE
+        const closeSub = dialogRef.onClose.subscribe(() => {
+            this.removeFromBody(dialogRef);
+            closeSub.unsubscribe();
+        });
+        // CREATE COMPONENT REF
+        const componentRef = createComponent(component, {
+            environmentInjector: appRef.injector,
+            elementInjector: new DialogInjector(this.injector, tokens)
+        });
+        // ATTACH VIEW TO ANGULAR
+        appRef.attachView(componentRef.hostView);
+        // CREATE DIALOG CONTAINER ELEMENT
+        const dialogContainer = document.createElement('div');
+        dialogContainer.classList.add('cf-dialog-container');
+        if (dialogConfig.containerClasses.length > 0) {
+            dialogContainer.classList.add(...dialogConfig.containerClasses);
+        }
+        // APPEND DOM ELEMENT TO DIALOG
+        const childDomElem = componentRef.hostView.rootNodes[0];
+        childDomElem.classList.add('cf-dialog');
+        if (dialogConfig.width !== null) {
+            childDomElem.style.width = dialogConfig.width;
+        }
+        if (dialogConfig.height !== null) {
+            childDomElem.style.height = dialogConfig.height;
+        }
+        if (dialogConfig.noPadding) {
+            childDomElem.classList.add('no-padding');
+        }
+        if (dialogConfig.dialogClasses.length > 0) {
+            childDomElem.classList.add(...dialogConfig.dialogClasses);
+        }
+        if (dialogConfig.contentElement !== null) {
+            childDomElem.appendChild(dialogConfig.contentElement);
+        }
+        dialogContainer.appendChild(childDomElem);
+        // CLOSEABLE? APPEND BUTTON
+        if (dialogConfig.showCloseIcon) {
+            const closeElement = document.createElement('div');
+            closeElement.classList.add(...['cf-dialog-close', 'remixicon', 'close-line']);
+            closeElement.onclick = () => {
+                dialogRef.close();
+            };
+            childDomElem.appendChild(closeElement);
+        }
+        // APPEND DIALOG CONTAINER TO BODY
+        document.body.appendChild(dialogContainer);
+        this.dialogs.set(dialogRef, {
+            componentRef,
+            container: dialogContainer,
+            openIndex: this.openIndex
+        });
+        this.openIndex++;
+        return dialogRef;
+    }
+    removeFromBody(dialogRef) {
+        const appRef = this.injector.get(ApplicationRef);
+        if (!dialogRef || !this.dialogs.has(dialogRef)) {
+            return;
+        }
+        const dialogComponentRefContainer = this.dialogs.get(dialogRef);
+        if (dialogComponentRefContainer == undefined) {
+            return;
+        }
+        appRef.detachView(dialogComponentRefContainer.componentRef.hostView);
+        if (dialogComponentRefContainer.container !== null) {
+            dialogComponentRefContainer.container.remove();
+        }
+        dialogComponentRefContainer.componentRef.destroy();
+        this.dialogs.delete(dialogRef);
+        if (this.dialogs.size === 0) {
+            this.openIndex = 1;
+        }
+        // Restore title
+        if (this.dialogs.size === 0) {
+            this.title.setTitle(dialogRef.savedTitle);
+        }
+        else {
+            let latestOpenedDialogRef = null;
+            this.dialogs.forEach((_, dialogRef) => {
+                if (latestOpenedDialogRef === null) {
+                    latestOpenedDialogRef = dialogRef;
+                }
+                else {
+                    if (latestOpenedDialogRef.opened < dialogRef.opened) {
+                        latestOpenedDialogRef = dialogRef;
+                    }
+                }
+            });
+            if (latestOpenedDialogRef !== null) {
+                //this.title.setTitle(latestOpenedDialogRef.savedTitle);
+            }
+            else {
+                this.title.setTitle(dialogRef.savedTitle);
+            }
+        }
+    }
+    confirm(configuration, dialogConfiguration = {}, component) {
+        if (typeof configuration === 'string') {
+            const predefinedConfirmConfiguration = this.predefinedConfirmConfigurations[configuration];
+            if (predefinedConfirmConfiguration === undefined) {
+                throw new Error('Predefined confirm configuration not found for: ' + configuration);
+            }
+            configuration = predefinedConfirmConfiguration;
+        }
+        return new Promise((resolve, reject) => {
+            this.open(component, {
+                ...dialogConfiguration,
+                data: {
+                    configuration
+                },
+                ignoreKeyUp: true,
+                showCloseIcon: false
+            }).onClose.pipe(filter(value => value !== undefined)).subscribe((accepted) => {
+                if (accepted) {
+                    resolve(true);
+                }
+                else {
+                    reject(true);
+                }
+            });
+        });
+    }
+    async confirmAsync(configuration, dialogConfiguration = {}, component) {
+        return await new Promise((resolve) => {
+            this.confirm(configuration, dialogConfiguration, component).then(() => {
+                resolve(true);
+            }).catch(() => {
+                resolve(false);
+            });
+        });
+    }
+    confirmAccept(configuration, dialogConfiguration = {}, component) {
+        return new Promise((resolve) => {
+            this.confirm(configuration, dialogConfiguration, component).then(() => resolve(true)).catch(() => { });
+        });
+    }
+    confirmDecline(configuration, dialogConfiguration = {}, component) {
+        return new Promise((resolve) => {
+            this.confirm(configuration, dialogConfiguration, component).then(() => { }).catch(() => resolve(true));
+        });
+    }
+    showLoading(configuration, dialogConfiguration = {}, component) {
+        return this.open(component, {
+            ...dialogConfiguration,
+            showCloseIcon: false,
+            ignoreKeyUp: true,
+            data: {
+                configuration
+            }
+        });
+    }
+    showAlert(configuration, dialogConfiguration = {}, component) {
+        if (typeof configuration === 'string') {
+            const predefinedAlertConfiguration = this.predefinedAlertConfigurations[configuration];
+            if (predefinedAlertConfiguration === undefined) {
+                throw new Error('Predefined alert configuration not found for: ' + configuration);
+            }
+            configuration = predefinedAlertConfiguration;
+        }
+        return new Promise((resolve) => {
+            return this.open(component, {
+                ...dialogConfiguration,
+                data: {
+                    configuration
+                },
+                ignoreKeyUp: true,
+                showCloseIcon: false
+            }).onClose.subscribe(() => {
+                resolve();
+            });
+        });
+    }
+    showModalWithButtons(configuration, dialogConfiguration = {}, component) {
+        return this.open(component, {
+            ...dialogConfiguration,
+            data: {
+                configuration
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DialogService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DialogService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DialogService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+
+class MessageService {
+    /**
+     * Show
+     *
+     * Displays message with the given configuration
+     *
+     * @param messageConfiguration `Partial<MessageConfiguration>`
+     */
+    show(title, message, configuration) {
+        this.messageSubject.next({
+            ...this.defaultConfiguration,
+            ...configuration,
+            title,
+            message
+        });
+    }
+    /**
+     * Show success message
+     *
+     * Display a message with default success severity
+     *
+     * @param title `string`, required
+     * @param message `string`, required
+     * @param lifetime `number`, optional, default is `this.defaultLifetime`
+     * @param position `MessagePosition`, optional, default is `this.defaultPosition`
+     * @param closeable `boolean`, optional, default is `this.defaultClosable`
+     */
+    showSuccessMessage(title, message, configuration) {
+        this.show(title, message, {
+            ...configuration,
+            severity: MessageSeverity.SUCCESS
+        });
+    }
+    /**
+     * Show danger message
+     *
+     * Display a message with default danger severity
+     *
+     * @param title `string`, required
+     * @param message `string`, required
+     * @param lifetime `number`, optional, default is `this.defaultLifetime`
+     * @param position `MessagePosition`, optional, default is `this.defaultPosition`
+     * @param closeable `boolean`, optional, default is `this.defaultClosable`
+     */
+    showDangerMessage(title, message, configuration) {
+        this.show(title, message, {
+            ...configuration,
+            severity: MessageSeverity.DANGER,
+            keepOnHover: true
+        });
+    }
+    /**
+     * Show warning message
+     *
+     * Display a message with default warning severity
+     *
+     * @param title `string`, required
+     * @param message `string`, required
+     * @param lifetime `number`, optional, default is `this.defaultLifetime`
+     * @param position `MessagePosition`, optional, default is `this.defaultPosition`
+     * @param closeable `boolean`, optional, default is `this.defaultClosable`
+     */
+    showWarningMessage(title, message, configuration) {
+        this.show(title, message, {
+            ...configuration,
+            severity: MessageSeverity.WARNING
+        });
+    }
+    /**
+     * Show info message
+     *
+     * Display a message with default info severity
+     *
+     * @param title `string`, required
+     * @param message `string`, required
+     * @param lifetime `number`, optional, default is `this.defaultLifetime`
+     * @param position `MessagePosition`, optional, default is `this.defaultPosition`
+     * @param closeable `boolean`, optional, default is `this.defaultClosable`
+     */
+    showInfoMessage(title, message, configuration) {
+        this.show(title, message, {
+            ...configuration,
+            severity: MessageSeverity.INFO
+        });
+    }
+    showMessage(message) {
+        let container = document.getElementById('cf-toasts-' + message.position + '-container');
+        if (container === null) {
+            container = document.createElement('div');
+            container.id = 'cf-toasts-' + message.position + '-container';
+            document.body.appendChild(container);
+        }
+        const div = this.createMessageHtmlElement(message);
+        container.appendChild(div);
+        if (message.lifetime !== null) {
+            let disposeTimerSubscription = timer(message.lifetime + 500).subscribe(() => {
+                this.hideMessage(div);
+            });
+            if (message.keepOnHover) {
+                div.addEventListener('mouseenter', () => {
+                    if (disposeTimerSubscription !== null) {
+                        disposeTimerSubscription.unsubscribe();
+                        disposeTimerSubscription = null;
+                    }
+                });
+            }
+        }
+    }
+    createMessageHtmlElement(message) {
+        const div = document.createElement('div');
+        div.classList.add('cf-toast', 'cf-' + message.severity + '-toast');
+        const titleDiv = document.createElement('div');
+        titleDiv.classList.add('cf-toast-title');
+        titleDiv.innerText = message.title;
+        const messageDiv = document.createElement('div');
+        messageDiv.classList.add('cf-toast-message');
+        messageDiv.innerText = message.message;
+        div.appendChild(titleDiv);
+        div.appendChild(messageDiv);
+        if (message.closeable) {
+            const closeIcon = document.createElement('i');
+            closeIcon.classList.add('close-icon', 'remixicon', 'close-line');
+            closeIcon.onclick = () => {
+                this.hideMessage(div, true);
+            };
+            div.appendChild(closeIcon);
+        }
+        return div;
+    }
+    hideMessage(messageElement, forceClose = false) {
+        messageElement.classList.add('hidden-toast');
+        let remainOpen = false;
+        messageElement.addEventListener('mouseenter', (() => {
+            remainOpen = true;
+        }));
+        timer(500).subscribe(() => {
+            if (remainOpen && !forceClose) {
+                messageElement.classList.remove('hidden-toast');
+                return;
+            }
+            messageElement.removeEventListener('mouseenter', (() => { }));
+            messageElement.remove();
+        });
+    }
+    constructor() {
+        /**
+         * Default configuration
+         *
+         * Can be changed if you overwrite it or use the `MESSAGE_DEFAULT_CONFIGURATION` InjectionToken
+         */
+        this.defaultConfiguration = inject(MESSAGE_DEFAULT_CONFIGURATION);
+        /**
+         * Message subject
+         */
+        this.messageSubject = new Subject();
+        this.messageSubject.subscribe((message) => {
+            this.showMessage(message);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: MessageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: MessageService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: MessageService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+
+class LoggerService {
+    constructor() {
+        this._logLevel = inject(LOG_LEVEL);
+        this.logLevelColors = [
+            '',
+            'background-color: #D2BDF3; padding: 5px 10px;',
+            'background-color: #A2DDFF; padding: 5px 10px;',
+            'background-color: #FFD5C5; padding: 5px 10px;',
+            'background-color: #EA4331; color: #FFFFFF; padding: 5px 10px;',
+            'background-color: #F71900; color: #FFFFFF; padding: 5px 10px;',
+            ''
+        ];
+    }
+    debug(log, group = false) {
+        this.log({ log, logLevel: LogLevel.Debug, group });
+    }
+    info(log, group = false) {
+        this.log({ log, logLevel: LogLevel.Info, group });
+    }
+    warn(log, group = false) {
+        this.log({ log, logLevel: LogLevel.Warn, group });
+    }
+    error(log, group = false) {
+        this.log({ log, logLevel: LogLevel.Error, group });
+    }
+    fatal(log, group = false) {
+        this.log({ log, logLevel: LogLevel.Fatal, group });
+    }
+    groupEnd() {
+        console.groupEnd();
+    }
+    log(configuration) {
+        if (this._logLevel === null || this._logLevel === LogLevel.Off || this._logLevel > configuration.logLevel) {
+            return;
+        }
+        if (configuration.group) {
+            console.group(configuration.log);
+        }
+        else {
+            console.log('%c' + configuration.log, this.logLevelColors[configuration.logLevel]);
+        }
+    }
+    set logLevel(logLevel) {
+        this._logLevel = logLevel;
+    }
+    get logLevel() {
+        return this._logLevel;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: LoggerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: LoggerService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: LoggerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class ApiService {
+    constructor() {
+        this.httpClient = inject(HttpClient);
+        this.loggerService = inject(LoggerService);
+        this._apiBaseUrl = null;
+    }
+    post(endPoint, body) {
+        return this.httpClient.post(this.generateUrl(endPoint), body);
+    }
+    get(endPoint) {
+        return this.httpClient.get(this.generateUrl(endPoint));
+    }
+    getFileArrayBuffer(endPoint) {
+        return this.httpClient.get(this.generateUrl(endPoint), {
+            responseType: 'arraybuffer'
+        });
+    }
+    getFileText(endPoint) {
+        return this.httpClient.get(this.generateUrl(endPoint), {
+            responseType: 'text'
+        });
+    }
+    getWithHttpParams(endPoint, params = null) {
+        if (params === null) {
+            return this.get(endPoint);
+        }
+        else {
+            return this.httpClient.get(this.generateUrl(endPoint), {
+                params
+            });
+        }
+    }
+    delete(endPoint) {
+        return this.httpClient.delete(this.generateUrl(endPoint));
+    }
+    patch(endPoint, body) {
+        return this.httpClient.patch(this.generateUrl(endPoint), body);
+    }
+    head(endPoint) {
+        return this.httpClient.head(this.generateUrl(endPoint));
+    }
+    options(endPoint) {
+        return this.httpClient.options(this.generateUrl(endPoint));
+    }
+    put(endPoint, body) {
+        return this.httpClient.put(this.generateUrl(endPoint), body);
+    }
+    generateUrl(endPoint) {
+        if (this._apiBaseUrl === null) {
+            throw new Error('No API base url set in generateUrl call!');
+        }
+        if (endPoint.length === 0) {
+            return this._apiBaseUrl;
+        }
+        if (typeof endPoint[0] === 'string' && endPoint[0].startsWith('#')) {
+            endPoint[0] = endPoint[0].slice(1);
+            return endPoint.map((v, i) => i === 0 ? v : encodeURIComponent(v)).join('/');
+        }
+        return [this._apiBaseUrl, ...endPoint.map((v) => encodeURIComponent(v))].join('/');
+    }
+    set apiBaseUrl(apiBaseUrl) {
+        this.loggerService.info('Api Service base url set to: ' + apiBaseUrl);
+        if (apiBaseUrl[apiBaseUrl.length - 1] === '/') {
+            apiBaseUrl = apiBaseUrl.slice(0, apiBaseUrl.length - 1);
+        }
+        this._apiBaseUrl = apiBaseUrl;
+    }
+    get apiBaseUrl() {
+        return this._apiBaseUrl;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ApiService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ApiService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ApiService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { ALERT_CONFIGURATIONS, ALERT_DEFAULT_BUTTON_CONFIGURATION, AcceptValidationMode, ApiService, CF_PREDEFINED_DIALOGS, CONFIRM_CONFIGURATIONS, DialogConfig, DialogInjector, DialogRef, DialogService, LOG_LEVEL, LogLevel, LoggerService, MESSAGE_DEFAULT_CONFIGURATION, MessagePosition, MessageService, MessageSeverity };
+//# sourceMappingURL=codefoxcore.mjs.map